[maven-release-plugin] prepare release avaje-ebeanorm-6.13.2

This adds default implementations for register,filter, prepare and log of the change sets.

.gitignore

@@ -1,13 +1,17 @@
 *.autofetch
 *.sql
+*.orig
 .classpath
 .project
 .settings/
 target/
 logs/
 log/
+ebean-autotune.xml
+ebean-profiling*.xml
 /db
 /mydb.db
+!src/test/ddl-review/*.sql
 
 
 # Intellij project files

README.md

@@ -1,12 +1,14 @@
-[![Stories in Ready](https://badge.waffle.io/ebean-orm/avaje-ebeanorm.png?label=ready&title=Ready)](https://waffle.io/ebean-orm/avaje-ebeanorm)
-avaje-ebeanorm
+* [![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
+
+
+Ebean ORM
 ==============
+[https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Website")
+
+
+[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")
 
-Maven Dependency
-----------------
-    <dependency>
-      <groupId>org.avaje.ebeanorm</groupId>
-      <artifactId>avaje-ebeanorm</artifactId>
-      <version>4.4.1</version>
-    </dependency>
-    

pom.xml

@@ -9,7 +9,7 @@
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>4.5.2</version>
+  <version>6.13.2</version>
   <packaging>jar</packaging>
 
   <name>avaje-ebeanorm</name>
@@ -43,6 +43,12 @@
 
   <dependencies>
 
+    <dependency>
+      <groupId>org.jetbrains</groupId>
+      <artifactId>annotations</artifactId>
+      <version>13.0</version>
+    </dependency>
+
     <dependency>
       <groupId>javax.persistence</groupId>
       <artifactId>persistence-api</artifactId>
@@ -55,12 +61,29 @@
       <version>1.7.7</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>
+    </dependency>
+
+    <!-- Jackson core used internally by Ebean -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
-      <version>2.4.3</version>
+      <version>2.5.3</version>
     </dependency>
-    
+
     <dependency>
       <groupId>javax.transaction</groupId>
       <artifactId>jta</artifactId>
@@ -68,6 +91,7 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- provided scope to read validation annotations Size etc -->
     <dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
@@ -89,6 +113,28 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- Provided scope for Postgres JSON/JSONB support -->
+    <dependency>
+      <groupId>org.postgresql</groupId>
+      <artifactId>postgresql</artifactId>
+      <version>9.4-1202-jdbc41</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <!--<dependency>-->
+      <!--<groupId>oracle</groupId>-->
+      <!--<artifactId>oracle-jdbc</artifactId>-->
+      <!--<version>7.0</version>-->
+      <!--<scope>test</scope>-->
+    <!--</dependency>-->
+
+    <!--<dependency>-->
+      <!--<groupId>microsoft</groupId>-->
+      <!--<artifactId>sqlserver-jdbc</artifactId>-->
+      <!--<version>4.2</version>-->
+      <!--<scope>test</scope>-->
+    <!--</dependency>-->
+
     <dependency>
       <groupId>com.squareup.okhttp</groupId>
       <artifactId>okhttp</artifactId>
@@ -106,15 +152,17 @@
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.5.1</version>
+      <version>4.7.1</version>
       <scope>test</scope>
     </dependency>
-        
+
+    <!-- Provided scope so that the H2HistoryTrigger can live in Ebean core
+         and not require a separate module for it -->
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.4.182</version>
-      <scope>test</scope>
+      <version>1.4.189</version>
+      <scope>provided</scope>
     </dependency>
     
     <dependency>
@@ -124,13 +172,6 @@
       <scope>test</scope>
     </dependency>
 
-    <dependency>
-      <groupId>postgresql</groupId>
-      <artifactId>postgresql</artifactId>
-      <version>8.4-701.jdbc4</version>
-      <scope>test</scope>
-    </dependency>
-
     <dependency>
       <groupId>org.hsqldb</groupId>
       <artifactId>hsqldb</artifactId>
@@ -141,36 +182,16 @@
     <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
-      <version>5.1.27</version>
+      <version>5.1.36</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <version>4.11</version>
-      <scope>test</scope>
-    </dependency>
-    
-    <dependency>
-      <groupId>org.hamcrest</groupId>
-      <artifactId>hamcrest-integration</artifactId>
-      <version>1.3</version>
-      <scope>test</scope>
-    </dependency>    
-
-    <dependency>
-      <groupId>org.mockito</groupId>
-      <artifactId>mockito-core</artifactId>
-      <version>1.9.5</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>ch.qos.logback</groupId>
-      <artifactId>logback-classic</artifactId>
-      <version>1.0.9</version>
+      <groupId>org.avaje.composite</groupId>
+      <artifactId>avaje-composite-testing</artifactId>
+      <version>1.1</version>
       <scope>test</scope>
+      <type>pom</type>
     </dependency>
 
     <dependency>
@@ -198,7 +219,7 @@
       <plugin>
         <groupId>org.avaje.ebeanorm</groupId>
         <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.5.1</version>
+        <version>4.7.1</version>
         <executions>
           <!--   Not going to enhance Model bean -->
           <execution>
@@ -228,6 +249,13 @@
             <include>**/*Test.java</include>
             <include>**/*Tests.java</include>
           </includes>
+          <systemProperties>
+            <property>
+              <!-- transfer datasource.default parameter -->
+              <name>datasource.default</name>
+              <value>${datasource.default}</value>
+            </property>
+          </systemProperties>
         </configuration>
       </plugin>
  	 <plugin>
@@ -245,13 +273,11 @@
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>2.9.1</version>
         <configuration>
-          <doctitle>Ebean 4</doctitle>
+          <doctitle>Ebean 6</doctitle>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
-         <!-- <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames> -->
-          <!--<additionalparam>-Xdoclint:none</additionalparam>-->
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
-          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames>
+          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util:com.avaje.ebean.dbmigration.ddlgeneration:com.avaje.ebean.dbmigration.migration:com.avaje.ebean.dbmigration.migrationreader:com.avaje.ebean.dbmigration.model</excludePackageNames>
           <docletArtifact>
             <groupId>org.avaje</groupId>
             <artifactId>pygments-doclet</artifactId>

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

@@ -1,137 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Administrative control of Autofetch during runtime.
- */
-public interface AdminAutofetch {
-
-  /**
-   * Return true if profiling is enabled.
-   */
-  public boolean isProfiling();
-
-  /**
-   * Set to true to enable profiling.
-   */
-  public void setProfiling(boolean enable);
-
-  /**
-   * Return true if autoFetch automatic query tuning is enabled.
-   */
-  public boolean isQueryTuning();
-
-  /**
-   * Set to true to enable autoFetch automatic query tuning.
-   */
-  public void setQueryTuning(boolean enable);
-
-  /**
-   * Returns the rate which profiling is collected. This is an int between 0 and
-   * 100.
-   */
-  public double getProfilingRate();
-
-  /**
-   * Set the rate at which profiling is collected after the base.
-   * 
-   * @param rate
-   *          a int between 0 and 100.
-   */
-  public void setProfilingRate(double rate);
-
-  /**
-   * Return the number of queries profiled after which profiling is collected at
-   * a percentage rate.
-   */
-  public int getProfilingBase();
-
-  /**
-   * Set a base number of queries to profile per query point.
-   * <p>
-   * After this amount of profiling has been obtained profiling is collected at
-   * the Profiling Percentage rate.
-   * </p>
-   */
-  public void setProfilingBase(int profilingBase);
-
-  /**
-   * Return the minimum number of queries profiled before autoFetch will start
-   * automatically tuning the queries.
-   * <p>
-   * This could be one which means start autoFetch tuning after the first
-   * profiling information is collected.
-   * </p>
-   */
-  public int getProfilingMin();
-
-  /**
-   * Set the minimum number of queries profiled per query point before autoFetch
-   * will automatically tune the queries.
-   * <p>
-   * Increasing this number will mean more profiling is collected before
-   * autoFetch starts tuning the query.
-   * </p>
-   */
-  public void setProfilingMin(int autoFetchMinThreshold);
-
-  /**
-   * Fire a garbage collection (hint to the JVM). Assuming garbage collection
-   * fires this will gather the usage profiling information.
-   */
-  public String collectUsageViaGC();
-
-  /**
-   * This will take the current profiling information and update the "tuned
-   * query detail".
-   * <p>
-   * This is done periodically and can also be manually invoked.
-   * </p>
-   * 
-   * @return a summary of the updates that occurred
-   */
-  public String updateTunedQueryInfo();
-
-  /**
-   * Clear all the tuned query info.
-   * <p>
-   * Should only need do this for testing and playing around.
-   * </p>
-   * 
-   * @return the amount of tuned query information cleared.
-   */
-  public int clearTunedQueryInfo();
-
-  /**
-   * Clear all the profiling information.
-   * <p>
-   * This means the profiling information will need to be re-gathered.
-   * </p>
-   * <p>
-   * Should only need do this for testing and playing around.
-   * </p>
-   * 
-   * @return the amount of profiled information cleared.
-   */
-  public int clearProfilingInfo();
-
-  /**
-   * Clear the query execution statistics.
-   */
-  public void clearQueryStatistics();
-
-  /**
-   * Return the number of queries tuned by AutoFetch.
-   */
-  public int getTotalTunedQueryCount();
-
-  /**
-   * Return the size of the TuneQuery map.
-   */
-  public int getTotalTunedQuerySize();
-
-  /**
-   * Return the size of the profile map.
-   */
-  public int getTotalProfileSize();
-
-}

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

@@ -0,0 +1,14 @@
+package com.avaje.ebean;
+
+/**
+ * Administrative control of AutoTune during runtime.
+ */
+public interface AutoTune {
+
+  /**
+   * Fire a garbage collection (hint to the JVM). Assuming garbage collection
+   * fires this will gather remaining usage profiling information.
+   */
+  void collectProfiling();
+
+}

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

@@ -1,40 +1,40 @@
-package com.avaje.ebean;
-
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Background thread pool service for executing of tasks asynchronously.
- * <p>
- * This service is used internally by Ebean for executing background tasks such
- * as the {@link Query#findFutureList()} and also for executing background tasks
- * periodically.
- * </p>
- * <p>
- * This service has been made available so you can use it for your application
- * 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 {
-
-  /**
-   * Execute a task in the background.
-   */
-  public void execute(Runnable r);
-
-  /**
-   * Execute a task periodically with a fixed delay between each execution.
-   * <p>
-   * For example, execute a runnable every minute.
-   * </p>
-   * <p>
-   * The delay is the time between executions no matter how long the task took.
-   * That is, this method has the same behaviour characteristics as
-   * {@link ScheduledExecutorService#scheduleWithFixedDelay(Runnable, long, long, TimeUnit)}
-   * </p>
-   */
-  public void executePeriodically(Runnable r, long delay, TimeUnit unit);
-}
+package com.avaje.ebean;
+
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Background thread pool service for executing of tasks asynchronously.
+ * <p>
+ * This service is used internally by Ebean for executing background tasks such
+ * as the {@link Query#findFutureList()} and also for executing background tasks
+ * periodically.
+ * </p>
+ * <p>
+ * This service has been made available so you can use it for your application
+ * 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 {
+
+  /**
+   * Execute a task in the background.
+   */
+  void execute(Runnable r);
+
+  /**
+   * Execute a task periodically with a fixed delay between each execution.
+   * <p>
+   * For example, execute a runnable every minute.
+   * </p>
+   * <p>
+   * The delay is the time between executions no matter how long the task took.
+   * That is, this method has the same behaviour characteristics as
+   * {@link ScheduledExecutorService#scheduleWithFixedDelay(Runnable, long, long, TimeUnit)}
+   * </p>
+   */
+  void executePeriodically(Runnable r, long delay, TimeUnit unit);
+}

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

@@ -1,86 +1,118 @@
-package com.avaje.ebean;
-
-import java.beans.PropertyChangeListener;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Provides access to the internal state of an entity bean.
- */
-public interface BeanState {
-
-  /**
-   * Return true if this is a lazy loading reference bean.
-   * <p>
-   * If so the this bean only holds the Id property and will invoke lazy loading
-   * if any other property is get or set.
-   * </p>
-   */
-  public boolean isReference();
-
-  /**
-   * Return true if the bean is new (and not yet saved).
-   */
-  public boolean isNew();
-
-  /**
-   * Return true if the bean is new or dirty (and probably needs to be saved).
-   */
-  public boolean isNewOrDirty();
-
-  /**
-   * Return true if the bean has been changed but not yet saved.
-   */
-  public boolean isDirty();
-
-  /**
-   * For partially populated beans returns the properties that are loaded on the
-   * bean.
-   * <p>
-   * Accessing another property will cause lazy loading to occur.
-   * </p>
-   */
-  public Set<String> getLoadedProps();
-
-  /**
-   * Return the set of changed properties.
-   */
-  public Set<String> getChangedProps();
-
-  /**
-   * Return a map of the updated properties and their new and old values.
-   */
-  public Map<String,ValuePair> getDirtyValues();
-  
-  /**
-   * Return true if the bean is readOnly.
-   * <p>
-   * If a setter is called on a readOnly bean it will throw an exception.
-   * </p>
-   */
-  public boolean isReadOnly();
-
-  /**
-   * Set the readOnly status for the bean.
-   */
-  public void setReadOnly(boolean readOnly);
-
-  /**
-   * Add a propertyChangeListener.
-   */
-  public void addPropertyChangeListener(PropertyChangeListener listener);
-
-  /**
-   * Remove a propertyChangeListener.
-   */
-  public void removePropertyChangeListener(PropertyChangeListener listener);
-
-  /**
-   * Advanced - Used to programmatically build a partially or fully loaded
-   * entity bean. First create an entity bean via
-   * {@link EbeanServer#createEntityBean(Class)}, then populate its properties
-   * and then call this method specifying which properties where loaded or null
-   * for a fully loaded entity bean.
-   */
-  public void setLoaded();
+package com.avaje.ebean;
+
+import java.beans.PropertyChangeListener;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Provides access to the internal state of an entity bean.
+ */
+public interface BeanState {
+
+  /**
+   * Return true if this is a lazy loading reference bean.
+   * <p>
+   * If so the this bean only holds the Id property and will invoke lazy loading
+   * if any other property is get or set.
+   * </p>
+   */
+  boolean isReference();
+
+  /**
+   * Return true if the bean is new (and not yet saved).
+   */
+  boolean isNew();
+
+  /**
+   * Return true if the bean is new or dirty (and probably needs to be saved).
+   */
+  boolean isNewOrDirty();
+
+  /**
+   * Return true if the bean has been changed but not yet saved.
+   */
+  boolean isDirty();
+
+  /**
+   * This can be called with true to disable lazy loading on the bean.
+   */
+  void setDisableLazyLoad(boolean disableLazyLoading);
+
+  /**
+   * 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.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *   // populate a bean via say JSON
+   *   User user = ...;
+   *
+   *   // set loaded state on the email property to false so that
+   *   // the email property is not included in a stateless update
+   *   Ebean.getBeanState(user).setPropertyLoaded("email", false);
+   *
+   *   user.update();
+   *
+   * }</pre>
+   *
+   *
+   * This will throw an IllegalArgumentException if the property is unknown.
+   */
+  void setPropertyLoaded(String propertyName, boolean loaded);
+
+  /**
+   * For partially populated beans returns the properties that are loaded on the
+   * bean.
+   * <p>
+   * Accessing another property will cause lazy loading to occur.
+   * </p>
+   */
+  Set<String> getLoadedProps();
+
+  /**
+   * Return the set of changed properties.
+   */
+  Set<String> getChangedProps();
+
+  /**
+   * Return a map of the updated properties and their new and old values.
+   */
+  Map<String,ValuePair> getDirtyValues();
+  
+  /**
+   * Return true if the bean is readOnly.
+   * <p>
+   * If a setter is called on a readOnly bean it will throw an exception.
+   * </p>
+   */
+  boolean isReadOnly();
+
+  /**
+   * Set the readOnly status for the bean.
+   */
+  void setReadOnly(boolean readOnly);
+
+  /**
+   * Add a propertyChangeListener.
+   */
+  void addPropertyChangeListener(PropertyChangeListener listener);
+
+  /**
+   * Remove a propertyChangeListener.
+   */
+  void removePropertyChangeListener(PropertyChangeListener listener);
+
+  /**
+   * Advanced - Used to programmatically build a partially or fully loaded
+   * entity bean. First create an entity bean via
+   * {@link EbeanServer#createEntityBean(Class)}, then populate its properties
+   * and then call this method specifying which properties where loaded or null
+   * for a fully loaded entity bean.
+   */
+  void setLoaded();
 }

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

@@ -80,22 +80,22 @@ public interface CallableSql {
   /**
    * Return the label that is put into the transaction log.
    */
-  public String getLabel();
+  String getLabel();
 
   /**
    * Set the label that is put in the transaction log.
    */
-  public CallableSql setLabel(String label);
+  CallableSql setLabel(String label);
 
   /**
    * Return the statement execution timeout.
    */
-  public int getTimeout();
+  int getTimeout();
 
   /**
    * Return the callable sql.
    */
-  public String getSql();
+  String getSql();
 
   /**
    * Set the statement execution timeout. Zero implies unlimited time.
@@ -103,12 +103,12 @@ public interface CallableSql {
    * This is set to the underlying CallableStatement.
    * </p>
    */
-  public CallableSql setTimeout(int secs);
+  CallableSql setTimeout(int secs);
 
   /**
    * Set the callable sql.
    */
-  public CallableSql setSql(String sql);
+  CallableSql setSql(String sql);
 
   /**
    * Bind a parameter that is bound as a IN parameter.
@@ -125,7 +125,7 @@ public interface CallableSql {
    * @param value
    *          the value of the parameter.
    */
-  public CallableSql bind(int position, Object value);
+  CallableSql bind(int position, Object value);
 
   /**
    * Bind a positioned parameter (same as bind method).
@@ -135,7 +135,7 @@ public interface CallableSql {
    * @param value
    *          the value of the parameter.
    */
-  public CallableSql setParameter(int position, Object value);
+  CallableSql setParameter(int position, Object value);
 
   /**
    * Register an OUT parameter.
@@ -153,7 +153,7 @@ public interface CallableSql {
    * @param type
    *          the jdbc type of the OUT parameter that will be read.
    */
-  public CallableSql registerOut(int position, int type);
+  CallableSql registerOut(int position, int type);
 
   /**
    * Return an OUT parameter value.
@@ -165,7 +165,7 @@ public interface CallableSql {
    * in batch mode you effectively can't use this method.
    * </p>
    */
-  public Object getObject(int position);
+  Object getObject(int position);
 
   /**
    * 
@@ -173,7 +173,7 @@ public interface CallableSql {
    * stored procedure calls. This would be the case when ResultSets are returned
    * etc.
    */
-  public boolean executeOverride(CallableStatement cstmt) throws SQLException;
+  boolean executeOverride(CallableStatement cstmt) throws SQLException;
 
   /**
    * Add table modification information to the TransactionEvent.
@@ -188,7 +188,6 @@ public interface CallableSql {
    * delete.
    * </p>
    */
-  public CallableSql addModification(String tableName, boolean inserts, boolean updates,
-      boolean deletes);
+  CallableSql addModification(String tableName, boolean inserts, boolean updates, boolean deletes);
 
 }

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

@@ -80,17 +80,16 @@ final class DRawSqlColumnsParser {
     return new ColumnMapping.Column(indexPos++, sb.toString(), split[split.length - 1]);
   }
 
-  private int nextComma() {
+  private void nextComma() {
     boolean inQuote = false;
     while (pos < end) {
       char c = sqlSelect.charAt(pos);
       if (c == '\'') {
         inQuote = !inQuote;
       } else if (!inQuote && c == ',') {
-        return pos;
+        return;
       }
       pos++;
     }
-    return pos;
   }
 }

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

@@ -24,7 +24,7 @@ class DRawSqlParser {
   private int placeHolderAndWhere;
   private int placeHolderHaving;
   private int placeHolderAndHaving;
-  private boolean hasPlaceHolders;
+  private final boolean hasPlaceHolders;
 
   private int selectPos = -1;
   private int distinctPos = -1;
@@ -98,19 +98,7 @@ class DRawSqlParser {
   }
 
   private boolean hasPlaceHolders() {
-    if (placeHolderWhere > -1) {
-      return true;
-    }
-    if (placeHolderAndWhere > -1) {
-      return true;
-    }
-    if (placeHolderHaving > -1) {
-      return true;
-    }
-    if (placeHolderAndHaving > -1) {
-      return true;
-    }
-    return false;
+    return placeHolderWhere > -1 || placeHolderAndWhere > -1 || placeHolderHaving > -1 || placeHolderAndHaving > -1;
   }
 
   /**

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

@@ -1,119 +1,148 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.common.BootupEbeanManager;
-import com.avaje.ebean.config.ContainerConfig;
-import com.avaje.ebean.config.ServerConfig;
-
-import javax.persistence.PersistenceException;
-import java.lang.reflect.Constructor;
-import java.util.Properties;
-
-/**
- * Creates EbeanServer instances.
- * <p>
- * This uses either a ServerConfig or properties in the ebean.properties file to
- * configure and create a EbeanServer instance.
- * </p>
- * <p>
- * The EbeanServer instance can either be registered with the Ebean singleton or
- * not. The Ebean singleton effectively holds a map of EbeanServers by a name.
- * If the EbeanServer is registered with the Ebean singleton you can retrieve it
- * later via {@link Ebean#getServer(String)}.
- * </p>
- * <p>
- * One EbeanServer can be nominated as the 'default/primary' EbeanServer. Many
- * methods on the Ebean singleton such as {@link Ebean#find(Class)} are just a
- * convenient way of using the 'default/primary' EbeanServer.
- * </p>
- */
-public class EbeanServerFactory {
-
-
-  private static BootupEbeanManager bootupEbeanManager;
-
-  /**
-   * Initialise the container with clustering configuration.
-   *
-   * Call this prior to creating any EbeanServer instances or alternatively set the
-   * ContainerConfig on the ServerConfig when creating the first EbeanServer instance.
-   */
-  public static synchronized void initialiseContainer(ContainerConfig containerConfig) {
-    getServerFactory(containerConfig);
-  }
-
-  /**
-   * Create using ebean.properties to configure the server.
-   */
-  public static synchronized EbeanServer create(String name) {
-
-    // construct based on loading properties files
-    // and if invoked by Ebean then it handles registration
-    BootupEbeanManager serverFactory = getServerFactory(null);
-    return serverFactory.createServer(name);
-  }
-
-  /**
-   * Create using the ServerConfig object to configure the server.
-   */
-  public static synchronized EbeanServer create(ServerConfig config) {
-
-    if (config.getName() == null) {
-      throw new PersistenceException("The name is null (it is required)");
-    }
-
-    EbeanServer server = createInternal(config);
-
-    if (config.isDefaultServer()) {
-      PrimaryServer.setSkip(true);
-    }
-    if (config.isRegister()) {
-      Ebean.register(server, config.isDefaultServer());
-    }
-
-    return server;
-  }
-
-
-  private static EbeanServer createInternal(ServerConfig config) {
-
-    return getServerFactory(config.getContainerConfig()).createServer(config);
-  }
-
-  /**
-   * Get the BootupEbeanManager initialising it if necessary.
-   *
-   * @param containerConfig the configuration controlling clustering communication
-   */
-  private static BootupEbeanManager getServerFactory(ContainerConfig containerConfig) {
-
-    if (bootupEbeanManager != null) {
-      return bootupEbeanManager;
-    }
-
-    if (containerConfig == null) {
-      // effectively load configuration from ebean.properties
-      Properties properties = PrimaryServer.getProperties();
-      containerConfig = new ContainerConfig();
-      containerConfig.loadFromProperties(properties);
-    }
-    bootupEbeanManager = createServerFactory(containerConfig);
-    return bootupEbeanManager;
-  }
-
-  /**
-   * Create the container instance using the configuration.
-   */
-  private static BootupEbeanManager createServerFactory(ContainerConfig containerConfig) {
-
-    String dflt = "com.avaje.ebeaninternal.server.core.DefaultServerFactory";
-    String implClassName = System.getProperty("ebean.serverfactory", dflt);
-
-    try {
-      Class<?> cls = Class.forName(implClassName);
-      Constructor<?> constructor = cls.getConstructor(ContainerConfig.class);
-      return (BootupEbeanManager) constructor.newInstance(containerConfig);
-    } catch (Exception ex) {
-      throw new RuntimeException(ex);
-    }
-  }
-}
+package com.avaje.ebean;
+
+import com.avaje.ebean.common.SpiContainer;
+import com.avaje.ebean.config.ContainerConfig;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebeaninternal.server.lib.ShutdownManager;
+
+import javax.persistence.PersistenceException;
+import java.lang.reflect.Constructor;
+import java.util.Properties;
+
+/**
+ * Creates EbeanServer instances.
+ * <p>
+ * This uses either a ServerConfig or properties in the ebean.properties file to
+ * configure and create a EbeanServer instance.
+ * </p>
+ * <p>
+ * The EbeanServer instance can either be registered with the Ebean singleton or
+ * not. The Ebean singleton effectively holds a map of EbeanServers by a name.
+ * If the EbeanServer is registered with the Ebean singleton you can retrieve it
+ * later via {@link Ebean#getServer(String)}.
+ * </p>
+ * <p>
+ * One EbeanServer can be nominated as the 'default/primary' EbeanServer. Many
+ * methods on the Ebean singleton such as {@link Ebean#find(Class)} are just a
+ * convenient way of using the 'default/primary' EbeanServer.
+ * </p>
+ */
+public class EbeanServerFactory {
+
+
+  private static final String DEFAULT_CONTAINER = "com.avaje.ebeaninternal.server.core.DefaultContainer";
+
+  private static SpiContainer container;
+
+  /**
+   * Initialise the container with clustering configuration.
+   *
+   * Call this prior to creating any EbeanServer instances or alternatively set the
+   * ContainerConfig on the ServerConfig when creating the first EbeanServer instance.
+   */
+  public static synchronized void initialiseContainer(ContainerConfig containerConfig) {
+    getContainer(containerConfig);
+  }
+
+  /**
+   * Create using ebean.properties to configure the server.
+   */
+  public static synchronized EbeanServer create(String name) {
+
+    // construct based on loading properties files
+    // and if invoked by Ebean then it handles registration
+    SpiContainer serverFactory = getContainer(null);
+    return serverFactory.createServer(name);
+  }
+
+  /**
+   * Create using the ServerConfig object to configure the server.
+   */
+  public static synchronized EbeanServer create(ServerConfig config) {
+
+    if (config.getName() == null) {
+      throw new PersistenceException("The name is null (it is required)");
+    }
+
+    EbeanServer server = createInternal(config);
+
+    if (config.isDefaultServer()) {
+      PrimaryServer.setSkip(true);
+    }
+    if (config.isRegister()) {
+      Ebean.register(server, config.isDefaultServer());
+    }
+
+    return server;
+  }
+
+  /**
+   * Create using the ServerConfig additionally specifying a classLoader to use as the context class loader.
+   */
+  public static synchronized EbeanServer createWithContextClassLoader(ServerConfig config, ClassLoader classLoader) {
+
+    ClassLoader currentContextLoader = Thread.currentThread().getContextClassLoader();
+    Thread.currentThread().setContextClassLoader(classLoader);
+    try {
+      return EbeanServerFactory.create(config);
+
+    } finally {
+      // set the currentContextLoader back
+      Thread.currentThread().setContextClassLoader(currentContextLoader);
+    }
+  }
+
+  /**
+   * Shutdown gracefully all EbeanServers cleaning up any resources as required.
+   * <p>
+   * This is typically invoked via JVM shutdown hook and not explicitly called.
+   * </p>
+   */
+  public static synchronized void shutdown() {
+    ShutdownManager.shutdown();
+  }
+
+
+  private static EbeanServer createInternal(ServerConfig config) {
+
+    return getContainer(config.getContainerConfig()).createServer(config);
+  }
+
+  /**
+   * Get the EbeanContainer initialising it if necessary.
+   *
+   * @param containerConfig the configuration controlling clustering communication
+   */
+  private static SpiContainer getContainer(ContainerConfig containerConfig) {
+
+    // thread safe in that all calling methods are synchronized
+    if (container != null) {
+      return container;
+    }
+
+    if (containerConfig == null) {
+      // effectively load configuration from ebean.properties
+      Properties properties = PrimaryServer.getProperties();
+      containerConfig = new ContainerConfig();
+      containerConfig.loadFromProperties(properties);
+    }
+    container = createContainer(containerConfig);
+    return container;
+  }
+
+  /**
+   * Create the container instance using the configuration.
+   */
+  private static SpiContainer createContainer(ContainerConfig containerConfig) {
+
+    String implClassName = System.getProperty("ebean.container", DEFAULT_CONTAINER);
+
+    try {
+      Class<?> cls = Class.forName(implClassName);
+      Constructor<?> constructor = cls.getConstructor(ContainerConfig.class);
+      return (SpiContainer) constructor.newInstance(containerConfig);
+    } catch (Exception ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+}

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

@@ -1,93 +1,93 @@
-package com.avaje.ebean;
-
-/**
- * Query by Example expression.
- * <p>
- * Pass in an example entity and for each non-null scalar properties an
- * expression is added.
- * </p>
- * <p>
- * By Default this case sensitive, will ignore numeric zero values and will use
- * a Like for string values (you must put in your own wildcards).
- * </p>
- * <p>
- * To get control over the options you can create an ExampleExpression and set
- * those options such as case insensitive etc.
- * </p>
- * 
- * <pre class="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;);
- * 
- * 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)
- *         .findList();
- * 
- * </pre>
- * 
- * Similarly you can create an ExampleExpression
- * 
- * <pre>
- * Customer example = new Customer();
- * example.setName(&quot;Rob%&quot;);
- * example.setNotes(&quot;%something%&quot;);
- * 
- * // create a ExampleExpression with more control
- * ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO)
- *     .includeZeros();
- * 
- * List&lt;Customer&gt; list =
- *     Ebean.find(Customer.class)
- *         .where()
- *         .add(qbe)
- *         .findList();
- * </pre>
- * 
- * @author Rob Bygrave
- */
-public interface ExampleExpression extends Expression {
-
-  /**
-   * By calling this method zero value properties are going to be included in
-   * the expression.
-   * <p>
-   * By default numeric zero values are excluded as they can result from
-   * primitive int and long types.
-   * </p>
-   */
-  public ExampleExpression includeZeros();
-
-  /**
-   * Set case insensitive to true.
-   */
-  public ExampleExpression caseInsensitive();
-
-  /**
-   * Use startsWith expression for string properties.
-   */
-  public ExampleExpression useStartsWith();
-
-  /**
-   * Use contains expression for string properties.
-   */
-  public ExampleExpression useContains();
-
-  /**
-   * Use endsWith expression for string properties.
-   */
-  public ExampleExpression useEndsWith();
-
-  /**
-   * Use equal to expression for string properties.
-   */
-  public ExampleExpression useEqualTo();
-
+package com.avaje.ebean;
+
+/**
+ * Query by Example expression.
+ * <p>
+ * Pass in an example entity and for each non-null scalar properties an
+ * expression is added.
+ * </p>
+ * <p>
+ * By Default this case sensitive, will ignore numeric zero values and will use
+ * a Like for string values (you must put in your own wildcards).
+ * </p>
+ * <p>
+ * To get control over the options you can create an ExampleExpression and set
+ * those options such as case insensitive etc.
+ * </p>
+ * 
+ * <pre class="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;);
+ * 
+ * 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)
+ *         .findList();
+ * 
+ * </pre>
+ * 
+ * Similarly you can create an ExampleExpression
+ * 
+ * <pre>
+ * Customer example = new Customer();
+ * example.setName(&quot;Rob%&quot;);
+ * example.setNotes(&quot;%something%&quot;);
+ * 
+ * // create a ExampleExpression with more control
+ * ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO)
+ *     .includeZeros();
+ * 
+ * List&lt;Customer&gt; list =
+ *     Ebean.find(Customer.class)
+ *         .where()
+ *         .add(qbe)
+ *         .findList();
+ * </pre>
+ * 
+ * @author Rob Bygrave
+ */
+public interface ExampleExpression extends Expression {
+
+  /**
+   * By calling this method zero value properties are going to be included in
+   * the expression.
+   * <p>
+   * By default numeric zero values are excluded as they can result from
+   * primitive int and long types.
+   * </p>
+   */
+  ExampleExpression includeZeros();
+
+  /**
+   * Set case insensitive to true.
+   */
+  ExampleExpression caseInsensitive();
+
+  /**
+   * Use startsWith expression for string properties.
+   */
+  ExampleExpression useStartsWith();
+
+  /**
+   * Use contains expression for string properties.
+   */
+  ExampleExpression useContains();
+
+  /**
+   * Use endsWith expression for string properties.
+   */
+  ExampleExpression useEndsWith();
+
+  /**
+   * Use equal to expression for string properties.
+   */
+  ExampleExpression useEqualTo();
+
 }

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

@@ -1,322 +1,322 @@
-package com.avaje.ebean;
-
-import java.util.Collection;
-import java.util.Map;
-
-/**
- * Expression factory for creating standard expressions for WHERE and HAVING
- * clauses.
- * <p>
- * Generally you will only need to use this object for creating OR, JUNCTION or
- * CONJUNCTION expressions. To create simple expressions you will most likely
- * just use the methods on the ExpressionList object that is returned via
- * {@link Query#where()}.
- * </p>
- * <p>
- * This provides a convenient way to create expressions for the 'Default'
- * server. It is actually a short cut for using the ExpressionFactory of the
- * 'default' EbeanServer.
- * <p>
- * See also {@link Ebean#getExpressionFactory()}
- * </p>
- * <p>
- * 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>
- * 
- * @see Query#where()
- * @author Rob Bygrave
- */
-public class Expr {
-
-  private Expr() {
-  }
-
-  /**
-   * Equal To - property equal to the given value.
-   */
-  public static Expression eq(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().eq(propertyName, value);
-  }
-
-  /**
-   * Not Equal To - property not equal to the given value.
-   */
-  public static Expression ne(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().ne(propertyName, value);
-  }
-
-  /**
-   * Case Insensitive Equal To - property equal to the given value (typically
-   * using a lower() function to make it case insensitive).
-   */
-  public static Expression ieq(String propertyName, String value) {
-    return Ebean.getExpressionFactory().ieq(propertyName, value);
-  }
-
-  /**
-   * Between - property between the two given values.
-   */
-  public static Expression between(String propertyName, Object value1, Object value2) {
-
-    return Ebean.getExpressionFactory().between(propertyName, value1, value2);
-  }
-
-  /**
-   * 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.
-   */
-  public static Expression gt(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().gt(propertyName, value);
-  }
-
-  /**
-   * Greater Than or Equal to - property greater than or equal to the given
-   * value.
-   */
-  public static Expression ge(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().ge(propertyName, value);
-  }
-
-  /**
-   * Less Than - property less than the given value.
-   */
-  public static Expression lt(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().lt(propertyName, value);
-  }
-
-  /**
-   * Less Than or Equal to - property less than or equal to the given value.
-   */
-  public static Expression le(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().le(propertyName, value);
-  }
-
-  /**
-   * Is Null - property is null.
-   */
-  public static Expression isNull(String propertyName) {
-    return Ebean.getExpressionFactory().isNull(propertyName);
-  }
-
-  /**
-   * Is Not Null - property is not null.
-   */
-  public static Expression isNotNull(String propertyName) {
-    return Ebean.getExpressionFactory().isNotNull(propertyName);
-  }
-
-  /**
-   * Case insensitive {@link #exampleLike(Object)}
-   */
-  public static ExampleExpression iexampleLike(Object example) {
-    return Ebean.getExpressionFactory().iexampleLike(example);
-  }
-
-  /**
-   * Create the query by Example expression which is case sensitive and using
-   * LikeType.RAW (you need to add you own wildcards % and _).
-   */
-  public static ExampleExpression exampleLike(Object example) {
-    return Ebean.getExpressionFactory().exampleLike(example);
-  }
-
-  /**
-   * Create the query by Example expression specifying more options.
-   */
-  public static ExampleExpression exampleLike(Object example, boolean caseInsensitive,
-      LikeType likeType) {
-    return Ebean.getExpressionFactory().exampleLike(example, caseInsensitive, likeType);
-  }
-
-  /**
-   * Like - property like value where the value contains the SQL wild card
-   * characters % (percentage) and _ (underscore).
-   */
-  public static Expression like(String propertyName, String value) {
-    return Ebean.getExpressionFactory().like(propertyName, value);
-  }
-
-  /**
-   * Case insensitive Like - property like value where the value contains the
-   * SQL wild card characters % (percentage) and _ (underscore). Typically uses
-   * a lower() function to make the expression case insensitive.
-   */
-  public static Expression ilike(String propertyName, String value) {
-    return Ebean.getExpressionFactory().ilike(propertyName, value);
-  }
-
-  /**
-   * Starts With - property like value%.
-   */
-  public static Expression startsWith(String propertyName, String value) {
-    return Ebean.getExpressionFactory().startsWith(propertyName, value);
-  }
-
-  /**
-   * Case insensitive Starts With - property like value%. Typically uses a
-   * lower() function to make the expression case insensitive.
-   */
-  public static Expression istartsWith(String propertyName, String value) {
-    return Ebean.getExpressionFactory().istartsWith(propertyName, value);
-  }
-
-  /**
-   * Ends With - property like %value.
-   */
-  public static Expression endsWith(String propertyName, String value) {
-    return Ebean.getExpressionFactory().endsWith(propertyName, value);
-  }
-
-  /**
-   * Case insensitive Ends With - property like %value. Typically uses a lower()
-   * function to make the expression case insensitive.
-   */
-  public static Expression iendsWith(String propertyName, String value) {
-    return Ebean.getExpressionFactory().iendsWith(propertyName, value);
-  }
-
-  /**
-   * Contains - property like %value%.
-   */
-  public static Expression contains(String propertyName, String value) {
-    return Ebean.getExpressionFactory().contains(propertyName, value);
-  }
-
-  /**
-   * Case insensitive Contains - property like %value%. Typically uses a lower()
-   * function to make the expression case insensitive.
-   */
-  public static Expression icontains(String propertyName, String value) {
-    return Ebean.getExpressionFactory().icontains(propertyName, value);
-  }
-
-  /**
-   * In - property has a value in the array of values.
-   */
-  public static Expression in(String propertyName, Object[] values) {
-    return Ebean.getExpressionFactory().in(propertyName, values);
-  }
-
-  /**
-   * In - using a subQuery.
-   */
-  public static Expression in(String propertyName, Query<?> subQuery) {
-    return Ebean.getExpressionFactory().in(propertyName, subQuery);
-  }
-
-  /**
-   * In - property has a value in the collection of values.
-   */
-  public static Expression in(String propertyName, Collection<?> values) {
-    return Ebean.getExpressionFactory().in(propertyName, values);
-  }
-
-  /**
-   * Id Equal to - ID property is equal to the value.
-   */
-  public static Expression idEq(Object value) {
-    return Ebean.getExpressionFactory().idEq(value);
-  }
-
-  /**
-   * All Equal - Map containing property names and their values.
-   * <p>
-   * Expression where all the property names in the map are equal to the
-   * corresponding value.
-   * </p>
-   * 
-   * @param propertyMap
-   *          a map keyed by property names.
-   */
-  public static Expression allEq(Map<String, Object> propertyMap) {
-    return Ebean.getExpressionFactory().allEq(propertyMap);
-  }
-
-  /**
-   * Add raw expression with a single parameter.
-   * <p>
-   * The raw expression should contain a single ? at the location of the
-   * parameter.
-   * </p>
-   */
-  public static Expression raw(String raw, Object value) {
-    return Ebean.getExpressionFactory().raw(raw, value);
-  }
-
-  /**
-   * Add raw expression with an array of parameters.
-   * <p>
-   * The raw expression should contain the same number of ? as there are
-   * parameters.
-   * </p>
-   */
-  public static Expression raw(String raw, Object[] values) {
-    return Ebean.getExpressionFactory().raw(raw, values);
-  }
-
-  /**
-   * Add raw expression with no parameters.
-   */
-  public static Expression raw(String raw) {
-    return Ebean.getExpressionFactory().raw(raw);
-  }
-
-  /**
-   * And - join two expressions with a logical and.
-   */
-  public static Expression and(Expression expOne, Expression expTwo) {
-
-    return Ebean.getExpressionFactory().and(expOne, expTwo);
-  }
-
-  /**
-   * Or - join two expressions with a logical or.
-   */
-  public static Expression or(Expression expOne, Expression expTwo) {
-
-    return Ebean.getExpressionFactory().or(expOne, expTwo);
-  }
-
-  /**
-   * Negate the expression (prefix it with NOT).
-   */
-  public static Expression not(Expression exp) {
-
-    return Ebean.getExpressionFactory().not(exp);
-  }
-
-  /**
-   * Return a list of expressions that will be joined by AND's.
-   */
-  public static <T> Junction<T> conjunction(Query<T> query) {
-
-    return Ebean.getExpressionFactory().conjunction(query);
-  }
-
-  /**
-   * Return a list of expressions that will be joined by OR's.
-   */
-  public static <T> Junction<T> disjunction(Query<T> query) {
-
-    return Ebean.getExpressionFactory().disjunction(query);
-  }
-}
+package com.avaje.ebean;
+
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * Expression factory for creating standard expressions for WHERE and HAVING
+ * clauses.
+ * <p>
+ * Generally you will only need to use this object for creating OR, JUNCTION or
+ * CONJUNCTION expressions. To create simple expressions you will most likely
+ * just use the methods on the ExpressionList object that is returned via
+ * {@link Query#where()}.
+ * </p>
+ * <p>
+ * This provides a convenient way to create expressions for the 'Default'
+ * server. It is actually a short cut for using the ExpressionFactory of the
+ * 'default' EbeanServer.
+ * <p>
+ * See also {@link Ebean#getExpressionFactory()}
+ * </p>
+ * <p>
+ * 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>
+ * 
+ * @see Query#where()
+ * @author Rob Bygrave
+ */
+public class Expr {
+
+  private Expr() {
+  }
+
+  /**
+   * Equal To - property equal to the given value.
+   */
+  public static Expression eq(String propertyName, Object value) {
+    return Ebean.getExpressionFactory().eq(propertyName, value);
+  }
+
+  /**
+   * Not Equal To - property not equal to the given value.
+   */
+  public static Expression ne(String propertyName, Object value) {
+    return Ebean.getExpressionFactory().ne(propertyName, value);
+  }
+
+  /**
+   * Case Insensitive Equal To - property equal to the given value (typically
+   * using a lower() function to make it case insensitive).
+   */
+  public static Expression ieq(String propertyName, String value) {
+    return Ebean.getExpressionFactory().ieq(propertyName, value);
+  }
+
+  /**
+   * Between - property between the two given values.
+   */
+  public static Expression between(String propertyName, Object value1, Object value2) {
+
+    return Ebean.getExpressionFactory().between(propertyName, value1, value2);
+  }
+
+  /**
+   * 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.
+   */
+  public static Expression gt(String propertyName, Object value) {
+    return Ebean.getExpressionFactory().gt(propertyName, value);
+  }
+
+  /**
+   * Greater Than or Equal to - property greater than or equal to the given
+   * value.
+   */
+  public static Expression ge(String propertyName, Object value) {
+    return Ebean.getExpressionFactory().ge(propertyName, value);
+  }
+
+  /**
+   * Less Than - property less than the given value.
+   */
+  public static Expression lt(String propertyName, Object value) {
+    return Ebean.getExpressionFactory().lt(propertyName, value);
+  }
+
+  /**
+   * Less Than or Equal to - property less than or equal to the given value.
+   */
+  public static Expression le(String propertyName, Object value) {
+    return Ebean.getExpressionFactory().le(propertyName, value);
+  }
+
+  /**
+   * Is Null - property is null.
+   */
+  public static Expression isNull(String propertyName) {
+    return Ebean.getExpressionFactory().isNull(propertyName);
+  }
+
+  /**
+   * Is Not Null - property is not null.
+   */
+  public static Expression isNotNull(String propertyName) {
+    return Ebean.getExpressionFactory().isNotNull(propertyName);
+  }
+
+  /**
+   * Case insensitive {@link #exampleLike(Object)}
+   */
+  public static ExampleExpression iexampleLike(Object example) {
+    return Ebean.getExpressionFactory().iexampleLike(example);
+  }
+
+  /**
+   * Create the query by Example expression which is case sensitive and using
+   * LikeType.RAW (you need to add you own wildcards % and _).
+   */
+  public static ExampleExpression exampleLike(Object example) {
+    return Ebean.getExpressionFactory().exampleLike(example);
+  }
+
+  /**
+   * Create the query by Example expression specifying more options.
+   */
+  public static ExampleExpression exampleLike(Object example, boolean caseInsensitive,
+      LikeType likeType) {
+    return Ebean.getExpressionFactory().exampleLike(example, caseInsensitive, likeType);
+  }
+
+  /**
+   * Like - property like value where the value contains the SQL wild card
+   * characters % (percentage) and _ (underscore).
+   */
+  public static Expression like(String propertyName, String value) {
+    return Ebean.getExpressionFactory().like(propertyName, value);
+  }
+
+  /**
+   * Case insensitive Like - property like value where the value contains the
+   * SQL wild card characters % (percentage) and _ (underscore). Typically uses
+   * a lower() function to make the expression case insensitive.
+   */
+  public static Expression ilike(String propertyName, String value) {
+    return Ebean.getExpressionFactory().ilike(propertyName, value);
+  }
+
+  /**
+   * Starts With - property like value%.
+   */
+  public static Expression startsWith(String propertyName, String value) {
+    return Ebean.getExpressionFactory().startsWith(propertyName, value);
+  }
+
+  /**
+   * Case insensitive Starts With - property like value%. Typically uses a
+   * lower() function to make the expression case insensitive.
+   */
+  public static Expression istartsWith(String propertyName, String value) {
+    return Ebean.getExpressionFactory().istartsWith(propertyName, value);
+  }
+
+  /**
+   * Ends With - property like %value.
+   */
+  public static Expression endsWith(String propertyName, String value) {
+    return Ebean.getExpressionFactory().endsWith(propertyName, value);
+  }
+
+  /**
+   * Case insensitive Ends With - property like %value. Typically uses a lower()
+   * function to make the expression case insensitive.
+   */
+  public static Expression iendsWith(String propertyName, String value) {
+    return Ebean.getExpressionFactory().iendsWith(propertyName, value);
+  }
+
+  /**
+   * Contains - property like %value%.
+   */
+  public static Expression contains(String propertyName, String value) {
+    return Ebean.getExpressionFactory().contains(propertyName, value);
+  }
+
+  /**
+   * Case insensitive Contains - property like %value%. Typically uses a lower()
+   * function to make the expression case insensitive.
+   */
+  public static Expression icontains(String propertyName, String value) {
+    return Ebean.getExpressionFactory().icontains(propertyName, value);
+  }
+
+  /**
+   * In - property has a value in the array of values.
+   */
+  public static Expression in(String propertyName, Object[] values) {
+    return Ebean.getExpressionFactory().in(propertyName, values);
+  }
+
+  /**
+   * In - using a subQuery.
+   */
+  public static Expression in(String propertyName, Query<?> subQuery) {
+    return Ebean.getExpressionFactory().in(propertyName, subQuery);
+  }
+
+  /**
+   * In - property has a value in the collection of values.
+   */
+  public static Expression in(String propertyName, Collection<?> values) {
+    return Ebean.getExpressionFactory().in(propertyName, values);
+  }
+
+  /**
+   * Id Equal to - ID property is equal to the value.
+   */
+  public static Expression idEq(Object value) {
+    return Ebean.getExpressionFactory().idEq(value);
+  }
+
+  /**
+   * All Equal - Map containing property names and their values.
+   * <p>
+   * Expression where all the property names in the map are equal to the
+   * corresponding value.
+   * </p>
+   * 
+   * @param propertyMap
+   *          a map keyed by property names.
+   */
+  public static Expression allEq(Map<String, Object> propertyMap) {
+    return Ebean.getExpressionFactory().allEq(propertyMap);
+  }
+
+  /**
+   * Add raw expression with a single parameter.
+   * <p>
+   * The raw expression should contain a single ? at the location of the
+   * parameter.
+   * </p>
+   */
+  public static Expression raw(String raw, Object value) {
+    return Ebean.getExpressionFactory().raw(raw, value);
+  }
+
+  /**
+   * Add raw expression with an array of parameters.
+   * <p>
+   * The raw expression should contain the same number of ? as there are
+   * parameters.
+   * </p>
+   */
+  public static Expression raw(String raw, Object[] values) {
+    return Ebean.getExpressionFactory().raw(raw, values);
+  }
+
+  /**
+   * Add raw expression with no parameters.
+   */
+  public static Expression raw(String raw) {
+    return Ebean.getExpressionFactory().raw(raw);
+  }
+
+  /**
+   * And - join two expressions with a logical and.
+   */
+  public static Expression and(Expression expOne, Expression expTwo) {
+
+    return Ebean.getExpressionFactory().and(expOne, expTwo);
+  }
+
+  /**
+   * Or - join two expressions with a logical or.
+   */
+  public static Expression or(Expression expOne, Expression expTwo) {
+
+    return Ebean.getExpressionFactory().or(expOne, expTwo);
+  }
+
+  /**
+   * Negate the expression (prefix it with NOT).
+   */
+  public static Expression not(Expression exp) {
+
+    return Ebean.getExpressionFactory().not(exp);
+  }
+
+  /**
+   * Return a list of expressions that will be joined by AND's.
+   */
+  public static <T> Junction<T> conjunction(Query<T> query) {
+
+    return Ebean.getExpressionFactory().conjunction(query);
+  }
+
+  /**
+   * Return a list of expressions that will be joined by OR's.
+   */
+  public static <T> Junction<T> disjunction(Query<T> query) {
+
+    return Ebean.getExpressionFactory().disjunction(query);
+  }
+}

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

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

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

@@ -1,252 +1,322 @@
-package com.avaje.ebean;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Expression factory for creating standard expressions.
- * <p>
- * Creates standard common expressions for using in a Query Where or Having
- * clause.
- * </p>
- * <p>
- * You will often not use this class directly but instead just add expressions
- * via the methods on ExpressionList such as
- * {@link ExpressionList#gt(String, Object)}.
- * </p>
- * <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);
- * query.where().add(newOrLastWeek);
- * List&lt;Order&gt; list = query.findList();
- * ...
- * </pre>
- * 
- * @see Query#where()
- */
-public interface ExpressionFactory {
-
-  /**
-   * Equal To - property equal to the given value.
-   */
-  public Expression eq(String propertyName, Object value);
-
-  /**
-   * Not Equal To - property not equal to the given value.
-   */
-  public Expression ne(String propertyName, Object value);
-
-  /**
-   * Case Insensitive Equal To - property equal to the given value (typically
-   * using a lower() function to make it case insensitive).
-   */
-  public Expression ieq(String propertyName, String value);
-
-  /**
-   * Between - property between the two given values.
-   */
-  public Expression between(String propertyName, Object value1, Object value2);
-
-  /**
-   * Between - value between two given properties.
-   */
-  public Expression betweenProperties(String lowProperty, String highProperty, Object value);
-
-  /**
-   * Greater Than - property greater than the given value.
-   */
-  public Expression gt(String propertyName, Object value);
-
-  /**
-   * Greater Than or Equal to - property greater than or equal to the given
-   * value.
-   */
-  public Expression ge(String propertyName, Object value);
-
-  /**
-   * Less Than - property less than the given value.
-   */
-  public Expression lt(String propertyName, Object value);
-
-  /**
-   * Less Than or Equal to - property less than or equal to the given value.
-   */
-  public Expression le(String propertyName, Object value);
-
-  /**
-   * Is Null - property is null.
-   */
-  public Expression isNull(String propertyName);
-
-  /**
-   * Is Not Null - property is not null.
-   */
-  public Expression isNotNull(String propertyName);
-
-  /**
-   * Case insensitive {@link #exampleLike(Object)}
-   */
-  public ExampleExpression iexampleLike(Object example);
-
-  /**
-   * Create the query by Example expression which is case sensitive and using
-   * LikeType.RAW (you need to add you own wildcards % and _).
-   */
-  public ExampleExpression exampleLike(Object example);
-
-  /**
-   * Create the query by Example expression specifying more options.
-   */
-  public ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType);
-
-  /**
-   * Like - property like value where the value contains the SQL wild card
-   * characters % (percentage) and _ (underscore).
-   */
-  public Expression like(String propertyName, String value);
-
-  /**
-   * Case insensitive Like - property like value where the value contains the
-   * SQL wild card characters % (percentage) and _ (underscore). Typically uses
-   * a lower() function to make the expression case insensitive.
-   */
-  public Expression ilike(String propertyName, String value);
-
-  /**
-   * Starts With - property like value%.
-   */
-  public Expression startsWith(String propertyName, String value);
-
-  /**
-   * Case insensitive Starts With - property like value%. Typically uses a
-   * lower() function to make the expression case insensitive.
-   */
-  public Expression istartsWith(String propertyName, String value);
-
-  /**
-   * Ends With - property like %value.
-   */
-  public Expression endsWith(String propertyName, String value);
-
-  /**
-   * Case insensitive Ends With - property like %value. Typically uses a lower()
-   * function to make the expression case insensitive.
-   */
-  public Expression iendsWith(String propertyName, String value);
-
-  /**
-   * Contains - property like %value%.
-   */
-  public Expression contains(String propertyName, String value);
-
-  /**
-   * Case insensitive Contains - property like %value%. Typically uses a lower()
-   * function to make the expression case insensitive.
-   */
-  public Expression icontains(String propertyName, String value);
-
-  /**
-   * In - property has a value in the array of values.
-   */
-  public Expression in(String propertyName, Object[] values);
-
-  /**
-   * In - using a subQuery.
-   */
-  public Expression in(String propertyName, Query<?> subQuery);
-
-  /**
-   * In - property has a value in the collection of values.
-   */
-  public Expression in(String propertyName, Collection<?> values);
-
-  /**
-   * Id Equal to - ID property is equal to the value.
-   */
-  public Expression idEq(Object value);
-
-  /**
-   * Id IN a list of Id values.
-   */
-  public Expression idIn(List<?> idList);
-
-  /**
-   * All Equal - Map containing property names and their values.
-   * <p>
-   * Expression where all the property names in the map are equal to the
-   * corresponding value.
-   * </p>
-   * 
-   * @param propertyMap
-   *          a map keyed by property names.
-   */
-  public Expression allEq(Map<String, Object> propertyMap);
-
-  /**
-   * Add raw expression with a single parameter.
-   * <p>
-   * The raw expression should contain a single ? at the location of the
-   * parameter.
-   * </p>
-   */
-  public Expression raw(String raw, Object value);
-
-  /**
-   * Add raw expression with an array of parameters.
-   * <p>
-   * The raw expression should contain the same number of ? as there are
-   * parameters.
-   * </p>
-   */
-  public Expression raw(String raw, Object[] values);
-
-  /**
-   * Add raw expression with no parameters.
-   */
-  public Expression raw(String raw);
-
-  /**
-   * And - join two expressions with a logical and.
-   */
-  public Expression and(Expression expOne, Expression expTwo);
-
-  /**
-   * Or - join two expressions with a logical or.
-   */
-  public Expression or(Expression expOne, Expression expTwo);
-
-  /**
-   * Negate the expression (prefix it with NOT).
-   */
-  public Expression not(Expression exp);
-
-  /**
-   * Return a list of expressions that will be joined by AND's.
-   */
-  public <T> Junction<T> conjunction(Query<T> query);
-
-  /**
-   * Return a list of expressions that will be joined by OR's.
-   */
-  public <T> Junction<T> disjunction(Query<T> query);
-
-  /**
-   * Return a list of expressions that will be joined by AND's.
-   */
-  public <T> Junction<T> conjunction(Query<T> query, ExpressionList<T> parent);
-
-  /**
-   * Return a list of expressions that will be joined by OR's.
-   */
-  public <T> Junction<T> disjunction(Query<T> query, ExpressionList<T> parent);
-}
+package com.avaje.ebean;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Expression factory for creating standard expressions.
+ * <p>
+ * Creates standard common expressions for using in a Query Where or Having
+ * clause.
+ * </p>
+ * <p>
+ * You will often not use this class directly but instead just add expressions
+ * via the methods on ExpressionList such as
+ * {@link ExpressionList#gt(String, Object)}.
+ * </p>
+ * <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);
+ * query.where().add(newOrLastWeek);
+ * List&lt;Order&gt; list = query.findList();
+ * ...
+ * </pre>
+ * 
+ * @see Query#where()
+ */
+public interface ExpressionFactory {
+
+  /**
+   * Path exists - for the given path in a JSON document.
+   */
+  Expression jsonExists(String propertyName, String path);
+
+  /**
+   * Path does not exist - for the given path in a JSON document.
+   */
+  Expression jsonNotExists(String propertyName, String path);
+
+  /**
+   * Equal to - for the given path in a JSON document.
+   */
+  Expression jsonEqualTo(String propertyName, String path, Object val);
+
+  /**
+   * Not Equal to - for the given path in a JSON document.
+   */
+  Expression jsonNotEqualTo(String propertyName, String path, Object val);
+
+  /**
+   * Greater than - for the given path in a JSON document.
+   */
+  Expression jsonGreaterThan(String propertyName, String path, Object val);
+
+  /**
+   * Greater than or equal to - for the given path in a JSON document.
+   */
+  Expression jsonGreaterOrEqual(String propertyName, String path, Object val);
+
+  /**
+   * Less than - for the given path in a JSON document.
+   */
+  Expression jsonLessThan(String propertyName, String path, Object val);
+
+  /**
+   * Less than or equal to - for the given path in a JSON document.
+   */
+  Expression jsonLessOrEqualTo(String propertyName, String path, Object val);
+
+  /**
+   * Between - for the given path in a JSON document.
+   */
+  Expression jsonBetween(String propertyName, String path, Object lowerValue, Object upperValue);
+
+  /**
+   * Equal To - property equal to the given value.
+   */
+  Expression eq(String propertyName, Object value);
+
+  /**
+   * Not Equal To - property not equal to the given value.
+   */
+  Expression ne(String propertyName, Object value);
+
+  /**
+   * Case Insensitive Equal To - property equal to the given value (typically
+   * using a lower() function to make it case insensitive).
+   */
+  Expression ieq(String propertyName, String value);
+
+  /**
+   * Between - property between the two given values.
+   */
+  Expression between(String propertyName, Object value1, Object value2);
+
+  /**
+   * Between - value between two given properties.
+   */
+  Expression betweenProperties(String lowProperty, String highProperty, Object value);
+
+  /**
+   * Greater Than - property greater than the given value.
+   */
+  Expression gt(String propertyName, Object value);
+
+  /**
+   * Greater Than or Equal to - property greater than or equal to the given
+   * value.
+   */
+  Expression ge(String propertyName, Object value);
+
+  /**
+   * Less Than - property less than the given value.
+   */
+  Expression lt(String propertyName, Object value);
+
+  /**
+   * Less Than or Equal to - property less than or equal to the given value.
+   */
+  Expression le(String propertyName, Object value);
+
+  /**
+   * Is Null - property is null.
+   */
+  Expression isNull(String propertyName);
+
+  /**
+   * Is Not Null - property is not null.
+   */
+  Expression isNotNull(String propertyName);
+
+  /**
+   * Case insensitive {@link #exampleLike(Object)}
+   */
+  ExampleExpression iexampleLike(Object example);
+
+  /**
+   * Create the query by Example expression which is case sensitive and using
+   * LikeType.RAW (you need to add you own wildcards % and _).
+   */
+  ExampleExpression exampleLike(Object example);
+
+  /**
+   * Create the query by Example expression specifying more options.
+   */
+  ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType);
+
+  /**
+   * Like - property like value where the value contains the SQL wild card
+   * characters % (percentage) and _ (underscore).
+   */
+  Expression like(String propertyName, String value);
+
+  /**
+   * Case insensitive Like - property like value where the value contains the
+   * SQL wild card characters % (percentage) and _ (underscore). Typically uses
+   * a lower() function to make the expression case insensitive.
+   */
+  Expression ilike(String propertyName, String value);
+
+  /**
+   * Starts With - property like value%.
+   */
+  Expression startsWith(String propertyName, String value);
+
+  /**
+   * Case insensitive Starts With - property like value%. Typically uses a
+   * lower() function to make the expression case insensitive.
+   */
+  Expression istartsWith(String propertyName, String value);
+
+  /**
+   * Ends With - property like %value.
+   */
+  Expression endsWith(String propertyName, String value);
+
+  /**
+   * Case insensitive Ends With - property like %value. Typically uses a lower()
+   * function to make the expression case insensitive.
+   */
+  Expression iendsWith(String propertyName, String value);
+
+  /**
+   * Contains - property like %value%.
+   */
+  Expression contains(String propertyName, String value);
+
+  /**
+   * Case insensitive Contains - property like %value%. Typically uses a lower()
+   * function to make the expression case insensitive.
+   */
+  Expression icontains(String propertyName, String value);
+
+  /**
+   * In - property has a value in the array of values.
+   */
+  Expression in(String propertyName, Object[] values);
+
+  /**
+   * In - using a subQuery.
+   */
+  Expression in(String propertyName, Query<?> subQuery);
+
+  /**
+   * In - property has a value in the collection of values.
+   */
+  Expression in(String propertyName, Collection<?> values);
+
+  /**
+   * Not In - property has a value in the array of values.
+   */
+  Expression notIn(String propertyName, Object[] values);
+
+  /**
+   * Not In - property has a value in the collection of values.
+   */
+  Expression notIn(String propertyName, Collection<?> values);
+
+  /**
+   * Not In - using a subQuery.
+   */
+  Expression notIn(String propertyName, Query<?> subQuery);
+
+  /**
+   * Exists expression
+   */
+  Expression exists(Query<?> subQuery);
+  
+  /**
+   * Not exists expression
+   */
+  Expression notExists(Query<?> subQuery);
+
+  /**
+   * Id Equal to - ID property is equal to the value.
+   */
+  Expression idEq(Object value);
+
+  /**
+   * Id IN a list of Id values.
+   */
+  Expression idIn(List<?> idList);
+
+  /**
+   * All Equal - Map containing property names and their values.
+   * <p>
+   * Expression where all the property names in the map are equal to the
+   * corresponding value.
+   * </p>
+   * 
+   * @param propertyMap
+   *          a map keyed by property names.
+   */
+  Expression allEq(Map<String, Object> propertyMap);
+
+  /**
+   * Add raw expression with a single parameter.
+   * <p>
+   * The raw expression should contain a single ? at the location of the
+   * parameter.
+   * </p>
+   */
+  Expression raw(String raw, Object value);
+
+  /**
+   * Add raw expression with an array of parameters.
+   * <p>
+   * The raw expression should contain the same number of ? as there are
+   * parameters.
+   * </p>
+   */
+  Expression raw(String raw, Object[] values);
+
+  /**
+   * Add raw expression with no parameters.
+   */
+  Expression raw(String raw);
+
+  /**
+   * And - join two expressions with a logical and.
+   */
+  Expression and(Expression expOne, Expression expTwo);
+
+  /**
+   * Or - join two expressions with a logical or.
+   */
+  Expression or(Expression expOne, Expression expTwo);
+
+  /**
+   * Negate the expression (prefix it with NOT).
+   */
+  Expression not(Expression exp);
+
+  /**
+   * Return a list of expressions that will be joined by AND's.
+   */
+  <T> Junction<T> conjunction(Query<T> query);
+
+  /**
+   * Return a list of expressions that will be joined by OR's.
+   */
+  <T> Junction<T> disjunction(Query<T> query);
+
+  /**
+   * Return a list of expressions that will be joined by AND's.
+   */
+  <T> Junction<T> conjunction(Query<T> query, ExpressionList<T> parent);
+
+  /**
+   * Return a list of expressions that will be joined by OR's.
+   */
+  <T> Junction<T> disjunction(Query<T> query, ExpressionList<T> parent);
+}

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

@@ -1,252 +1,252 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-
-/**
- * Defines the configuration options for a "query fetch" or a
- * "lazy loading fetch". This gives you the ability to use multiple smaller
- * queries to populate an object graph as opposed to a single large query.
- * <p>
- * The primary goal is to provide efficient ways of loading complex object
- * graphs avoiding SQL Cartesian product and issues around populating object
- * graphs that have multiple *ToMany relationships.
- * </p>
- * <p>
- * It also provides the ability to control the lazy loading queries (batch size,
- * selected properties and fetches) to avoid N+1 queries etc.
- * <p>
- * There can also be cases loading across a single OneToMany where 2 SQL queries
- * using Ebean FetchConfig.query() can be more efficient than one SQL query.
- * When the "One" side is wide (lots of columns) and the cardinality difference
- * is high (a lot of "Many" beans per "One" bean) then this can be more
- * efficient loaded as 2 SQL queries.
- * </p>
- * 
- * <pre class="code">
- * // Normal fetch join results in a single SQL query
- * List&lt;Order&gt; list = Ebean.find(Order.class).fetch(&quot;details&quot;).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
- * </p>
- * 
- * <pre class="code">
- * // This will use 2 SQL queries to build this object graph
- * List&lt;Order&gt; list =
- *     Ebean.find(Order.class)
- *         .fetch(&quot;details&quot;, 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>
- * 
- * <pre class="code">
- * // This will use 3 SQL queries to build this object graph
- * List&lt;Order&gt; list =
- *     Ebean.find(Order.class)
- *         .fetch(&quot;details&quot;, new FetchConfig().query())
- *         .fetch(&quot;customer&quot;, 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>
- * 
- * <pre class="code">
- * // This will use 3 SQL queries to build this object graph
- * List&lt;Order&gt; list =
- *     Ebean.find(Order.class)
- *         .select(&quot;status, shipDate&quot;)
- *         .fetch(&quot;details&quot;, &quot;quantity, price&quot;, new FetchConfig().query())
- *         .fetch(&quot;details.product&quot;, &quot;sku, name&quot;)
- *         .fetch(&quot;customer&quot;, &quot;name&quot;, new FetchConfig().queryFirst(5))
- *         .fetch(&quot;customer.contacts&quot;)
- *         .fetch(&quot;customer.shippingAddress&quot;)
- *         .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 &quot;details.product&quot; is automatically included into the
- * // fetch of &quot;details&quot;
- * //
- * // Note: the fetch of &quot;customer.contacts&quot; and &quot;customer.shippingAddress&quot;
- * // are automatically included in the fetch of &quot;customer&quot;
- * </pre>
- * <p>
- * You can use query() and lazy together on a single join. The query is executed
- * immediately and the lazy defines the batch size to use for further lazy
- * loading (if lazy loading is invoked).
- * </p>
- * 
- * <pre class="code">
- * List&lt;Order&gt; list =
- *     Ebean.find(Order.class)
- *         .fetch(&quot;customer&quot;, 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>
- * Example of controlling the lazy loading query:
- * </p>
- * <p>
- * This gives us the ability to optimise the lazy loading query for a given use
- * case.
- * </p>
- * 
- * <pre class="code">
- * List&lt;Order&gt; list = Ebean.find(Order.class)
- *   .fetch(&quot;customer&quot;,&quot;name&quot;, new FetchConfig().lazy(5))
- *   .fetch(&quot;customer.contacts&quot;,&quotcontactName, phone, email&quot)
- *   .fetch(&quot;customer.shippingAddress&quot;)
- *   .where().eq(&quot;status&quot;,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 (?,?,?,?,?)
- * 
- * </pre>
- * 
- * @author mario
- * @author rbygrave
- */
-public class FetchConfig implements Serializable {
-
-  private static final long serialVersionUID = 1L;
-
-  private int lazyBatchSize = -1;
-
-  private int queryBatchSize = -1;
-
-  private boolean queryAll;
-
-  /**
-   * Construct the fetch configuration object.
-   */
-  public FetchConfig() {
-  }
-
-  /**
-   * Specify that this path should be lazy loaded using the default batch load
-   * size.
-   */
-  public FetchConfig lazy() {
-    this.lazyBatchSize = 0;
-    this.queryAll = false;
-    return this;
-  }
-
-  /**
-   * Specify that this path should be lazy loaded with a specified batch size.
-   * 
-   * @param lazyBatchSize
-   *          the batch size for lazy loading
-   */
-  public FetchConfig lazy(int lazyBatchSize) {
-    this.lazyBatchSize = lazyBatchSize;
-    this.queryAll = false;
-    return this;
-  }
-
-  /**
-   * Eagerly fetch the beans in this path as a separate query (rather than as
-   * part of the main query).
-   * <p>
-   * This will use the default batch size for separate query which is 100.
-   * </p>
-   */
-  public FetchConfig query() {
-    this.queryBatchSize = 0;
-    this.queryAll = true;
-    return this;
-  }
-
-  /**
-   * Eagerly fetch the beans in this path as a separate query (rather than as
-   * part of the main query).
-   * <p>
-   * The queryBatchSize is the number of parent id's that this separate query
-   * will load per batch.
-   * </p>
-   * <p>
-   * 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
-   */
-  public FetchConfig query(int queryBatchSize) {
-    this.queryBatchSize = queryBatchSize;
-    // queryAll true as long as a lazy batch size has not already been set
-    this.queryAll = (lazyBatchSize == -1);
-    return this;
-  }
-
-  /**
-   * Eagerly fetch the first batch of beans on this path.
-   * This is similar to {@link #query(int)} but only fetches the first batch.
-   * <p>
-   * 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
-   */
-  public FetchConfig queryFirst(int queryBatchSize) {
-    this.queryBatchSize = queryBatchSize;
-    this.queryAll = false;
-    return this;
-  }
-
-  /**
-   * Return the batch size for lazy loading.
-   */
-  public int getLazyBatchSize() {
-    return lazyBatchSize;
-  }
-  
-  /**
-   * Return the batch size for separate query load.
-   */
-  public int getQueryBatchSize() {
-    return queryBatchSize;
-  }
-
-  /**
-   * Return true if the query fetch should fetch 'all' rather than just the
-   * 'first' batch.
-   */
-  public boolean isQueryAll() {
-    return queryAll;
-  }
-
-}
+package com.avaje.ebean;
+
+import java.io.Serializable;
+
+/**
+ * Defines the configuration options for a "query fetch" or a
+ * "lazy loading fetch". This gives you the ability to use multiple smaller
+ * queries to populate an object graph as opposed to a single large query.
+ * <p>
+ * The primary goal is to provide efficient ways of loading complex object
+ * graphs avoiding SQL Cartesian product and issues around populating object
+ * graphs that have multiple *ToMany relationships.
+ * </p>
+ * <p>
+ * It also provides the ability to control the lazy loading queries (batch size,
+ * selected properties and fetches) to avoid N+1 queries etc.
+ * <p>
+ * There can also be cases loading across a single OneToMany where 2 SQL queries
+ * using Ebean FetchConfig.query() can be more efficient than one SQL query.
+ * When the "One" side is wide (lots of columns) and the cardinality difference
+ * is high (a lot of "Many" beans per "One" bean) then this can be more
+ * efficient loaded as 2 SQL queries.
+ * </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
+ * </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>
+ * 
+ * <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>
+ * 
+ * <pre>{@code
+ * // This will use 3 SQL queries to build this object graph
+ * List<Order> list =
+ *     Ebean.find(Order.class)
+ *         .select("status, shipDate")
+ *         .fetch("details", "quantity, price", new FetchConfig().query())
+ *         .fetch("details.product", "sku, name")
+ *         .fetch("customer", "name", new FetchConfig().queryFirst(5))
+ *         .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"
+ * //
+ * // Note: the fetch of "customer.contacts" and "customer.shippingAddress"
+ * // are automatically included in the fetch of "customer"
+ * }</pre>
+ * <p>
+ * You can use query() and lazy together on a single join. The query is executed
+ * immediately and the lazy defines the batch size to use for further lazy
+ * loading (if lazy loading is invoked).
+ * </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>
+ * Example of controlling the lazy loading query:
+ * </p>
+ * <p>
+ * This gives us the ability to optimise the lazy loading query for a given use
+ * case.
+ * </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.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 (?,?,?,?,?)
+ * 
+ * }</pre>
+ * 
+ * @author mario
+ * @author rbygrave
+ */
+public class FetchConfig implements Serializable {
+
+  private static final long serialVersionUID = 1L;
+
+  private int lazyBatchSize = -1;
+
+  private int queryBatchSize = -1;
+
+  private boolean queryAll;
+
+  /**
+   * Construct the fetch configuration object.
+   */
+  public FetchConfig() {
+  }
+
+  /**
+   * Specify that this path should be lazy loaded using the default batch load
+   * size.
+   */
+  public FetchConfig lazy() {
+    this.lazyBatchSize = 0;
+    this.queryAll = false;
+    return this;
+  }
+
+  /**
+   * Specify that this path should be lazy loaded with a specified batch size.
+   * 
+   * @param lazyBatchSize
+   *          the batch size for lazy loading
+   */
+  public FetchConfig lazy(int lazyBatchSize) {
+    this.lazyBatchSize = lazyBatchSize;
+    this.queryAll = false;
+    return this;
+  }
+
+  /**
+   * Eagerly fetch the beans in this path as a separate query (rather than as
+   * part of the main query).
+   * <p>
+   * This will use the default batch size for separate query which is 100.
+   * </p>
+   */
+  public FetchConfig query() {
+    this.queryBatchSize = 0;
+    this.queryAll = true;
+    return this;
+  }
+
+  /**
+   * Eagerly fetch the beans in this path as a separate query (rather than as
+   * part of the main query).
+   * <p>
+   * The queryBatchSize is the number of parent id's that this separate query
+   * will load per batch.
+   * </p>
+   * <p>
+   * 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
+   */
+  public FetchConfig query(int queryBatchSize) {
+    this.queryBatchSize = queryBatchSize;
+    // queryAll true as long as a lazy batch size has not already been set
+    this.queryAll = (lazyBatchSize == -1);
+    return this;
+  }
+
+  /**
+   * Eagerly fetch the first batch of beans on this path.
+   * This is similar to {@link #query(int)} but only fetches the first batch.
+   * <p>
+   * 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
+   */
+  public FetchConfig queryFirst(int queryBatchSize) {
+    this.queryBatchSize = queryBatchSize;
+    this.queryAll = false;
+    return this;
+  }
+
+  /**
+   * Return the batch size for lazy loading.
+   */
+  public int getLazyBatchSize() {
+    return lazyBatchSize;
+  }
+  
+  /**
+   * Return the batch size for separate query load.
+   */
+  public int getQueryBatchSize() {
+    return queryBatchSize;
+  }
+
+  /**
+   * Return true if the query fetch should fetch 'all' rather than just the
+   * 'first' batch.
+   */
+  public boolean isQueryAll() {
+    return queryAll;
+  }
+
+}

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

@@ -36,7 +36,7 @@ import java.util.Set;
  *         .sort("avgTimeMicros desc")
  *         .gt("executionCount", 0)
  *         .gt("lastQueryTime", nowMinus24Hrs)
- *         .eq("autofetchTuned", true)
+ *         .eq("autoTuned", true)
  *         .maxRows(10)
  *         .filter(list);
  * 
@@ -90,98 +90,98 @@ public interface Filter<T> {
    * Refer to {@link Ebean#sort(List, String)} for more detail.
    * </p>
    */
-  public Filter<T> sort(String sortByClause);
+  Filter<T> sort(String sortByClause);
 
   /**
    * Specify the maximum number of rows/elements to return.
    */
-  public Filter<T> maxRows(int maxRows);
+  Filter<T> maxRows(int maxRows);
 
   /**
    * Equal To - property equal to the given value.
    */
-  public Filter<T> eq(String prop, Object value);
+  Filter<T> eq(String prop, Object value);
 
   /**
    * Not Equal To - property not equal to the given value.
    */
-  public Filter<T> ne(String propertyName, Object value);
+  Filter<T> ne(String propertyName, Object value);
 
   /**
    * Case Insensitive Equal To.
    */
-  public Filter<T> ieq(String propertyName, String value);
+  Filter<T> ieq(String propertyName, String value);
 
   /**
    * Between - property between the two given values.
    */
-  public Filter<T> between(String propertyName, Object value1, Object value2);
+  Filter<T> between(String propertyName, Object value1, Object value2);
 
   /**
    * Greater Than - property greater than the given value.
    */
-  public Filter<T> gt(String propertyName, Object value);
+  Filter<T> gt(String propertyName, Object value);
 
   /**
    * Greater Than or Equal to - property greater than or equal to the given
    * value.
    */
-  public Filter<T> ge(String propertyName, Object value);
+  Filter<T> ge(String propertyName, Object value);
 
   /**
    * Less Than - property less than the given value.
    */
-  public Filter<T> lt(String propertyName, Object value);
+  Filter<T> lt(String propertyName, Object value);
 
   /**
    * Less Than or Equal to - property less than or equal to the given value.
    */
-  public Filter<T> le(String propertyName, Object value);
+  Filter<T> le(String propertyName, Object value);
 
   /**
    * Is Null - property is null.
    */
-  public Filter<T> isNull(String propertyName);
+  Filter<T> isNull(String propertyName);
 
   /**
    * Is Not Null - property is not null.
    */
-  public Filter<T> isNotNull(String propertyName);
+  Filter<T> isNotNull(String propertyName);
 
   /**
    * Starts With.
    */
-  public Filter<T> startsWith(String propertyName, String value);
+  Filter<T> startsWith(String propertyName, String value);
 
   /**
    * Case insensitive Starts With.
    */
-  public Filter<T> istartsWith(String propertyName, String value);
+  Filter<T> istartsWith(String propertyName, String value);
 
   /**
    * Ends With.
    */
-  public Filter<T> endsWith(String propertyName, String value);
+  Filter<T> endsWith(String propertyName, String value);
 
   /**
    * Case insensitive Ends With.
    */
-  public Filter<T> iendsWith(String propertyName, String value);
+  Filter<T> iendsWith(String propertyName, String value);
 
   /**
    * Contains - property contains the string "value".
    */
-  public Filter<T> contains(String propertyName, String value);
+  Filter<T> contains(String propertyName, String value);
 
   /**
    * Case insensitive Contains.
    */
-  public Filter<T> icontains(String propertyName, String value);
+  Filter<T> icontains(String propertyName, String value);
 
   /**
    * In - property has a value contained in the set of values.
    */
-  public Filter<T> in(String propertyName, Set<?> values);
+  Filter<T> in(String propertyName, Set<?> values);
 
   /**
    * Apply the filter to the list returning a new list of the matching elements
@@ -192,6 +192,6 @@ public interface Filter<T> {
    * 
    * @return Returns a new list with the sorting and filters applied.
    */
-  public List<T> filter(List<T> sourceList);
+  List<T> filter(List<T> sourceList);
 
 }

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

@@ -0,0 +1,167 @@
+package com.avaje.ebean;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * Intended to be used as a base class for 'Finder' implementations that can then
+ * be injected or used as public static fields on the associated entity bean.
+ * <p>
+ * 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
+ *
+ * </p>
+ * <pre>{@code
+ *
+ * public class CustomerFinder extends Finder<Customer> {
+ *
+ *   public CustomerFinder() {
+ *     super(Customer.class);
+ *   }
+ *
+ *   // Add your customer finder methods ...
+ *
+ *   public Customer byName(String name) {
+ *     return query().eq("name", name).findUnique();
+ *   }
+ *
+ *   public List<Customer> findNew() {
+ *     return query()
+ *       .eq("status", Customer.Status.NEW)
+ *       .orderBy("name")
+ *       .findList()
+ *   }
+ * }
+ *
+ * @Entity
+ * public class Customer extends BaseModel {
+ *
+ *   public static final CustomerFinder find = new CustomerFinder();
+ *   ...
+ *
+ * }</pre>
+ */
+public class Finder<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;
+
+  /**
+   * Create with the type of the entity bean.
+   *
+   * <pre>{@code
+   *
+   * public class CustomerFinder extends Finder<Customer> {
+   *
+   *   public CustomerFinder() {
+   *     super(Customer.class);
+   *   }
+   *
+   *   // ... add extra customer specific finder methods
+   * }
+   *
+   * @Entity
+   * public class Customer extends BaseModel {
+   *
+   *   public static final CustomerFinder find = new CustomerFinder();
+   *   ...
+   *
+   * }</pre>
+   */
+  public Finder(Class<T> type) {
+    this.type = type;
+    this.serverName = null;
+  }
+
+  /**
+   * Create with the type of the entity bean and specific server name.
+   */
+  public Finder(Class<T> type, String serverName) {
+    this.type = type;
+    this.serverName = serverName;
+  }
+
+  /**
+   * 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 equivalent 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 an entity reference for this ID.
+   *
+   * <p>
+   * Equivalent to {@link EbeanServer#getReference(Class, Object)}
+   */
+  public T ref(I id) {
+    return db().getReference(type, id);
+  }
+
+  /**
+   * Retrieves an entity by ID.
+   *
+   * <p>
+   * Equivalent to {@link EbeanServer#find(Class, Object)}
+   */
+  @Nullable
+  public T byId(I id) {
+    return db().find(type, id);
+  }
+
+  /**
+   * 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.
+   */
+  public List<T> all() {
+    return query().findList();
+  }
+
+  /**
+   * Creates a query.
+   * <p>
+   * Equivalent to {@link EbeanServer#find(Class)}
+   */
+  public Query<T> query() {
+    return db().find(type);
+  }
+
+}

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

@@ -1,34 +1,34 @@
-package com.avaje.ebean;
-
-import java.util.List;
-import java.util.concurrent.Future;
-
-/**
- * FutureIds represents the result of a background query execution for the Id's.
- * <p>
- * 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>> {
-
-  /**
-   * Returns the original query used to fetch the Id's.
-   */
-  public 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>
-   */
-  public List<Object> getPartialIds();
-}
+package com.avaje.ebean;
+
+import java.util.List;
+import java.util.concurrent.Future;
+
+/**
+ * FutureIds represents the result of a background query execution for the Id's.
+ * <p>
+ * 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>> {
+
+  /**
+   * Returns the original query used to fetch the Id's.
+   */
+  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

@@ -1,76 +1,75 @@
-package com.avaje.ebean;
-
-import javax.persistence.PersistenceException;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-/**
- * FutureList represents the result of a background query execution that will
- * return a list of entities.
- * <p>
- * It extends the java.util.concurrent.Future with the ability to cancel the
- * query, check if it is finished and get the resulting list waiting for the
- * query to finish (ie. the standard features of java.util.concurrent.Future).
- * </p>
- * <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 ... 
- * 
- * 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>> {
-
-  /**
-   * Return the query that is being executed by a background thread.
-   */
-  public Query<T> getQuery();
-
-  /**
-   * Same as {@link #get()} but wraps InterruptedException and ExecutionException in the
-   * unchecked PersistenceException.
-   *
-   * @return The query list result
-   *
-   * @throws PersistenceException when a InterruptedException or ExecutionException occurs.
-   */
-  public List<T> getUnchecked();
-
-  /**
-   * Same as {@link #get(long, java.util.concurrent.TimeUnit)} but wraps InterruptedException
-   * and ExecutionException in the unchecked PersistenceException.
-   *
-   * @return The query list result
-   *
-   * @throws TimeoutException if the wait timed out
-   * @throws PersistenceException if a InterruptedException or ExecutionException occurs.
-   */
-  public List<T> getUnchecked(long timeout, TimeUnit unit) throws TimeoutException;
-
-}
+package com.avaje.ebean;
+
+import javax.persistence.PersistenceException;
+import java.util.List;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * FutureList represents the result of a background query execution that will
+ * return a list of entities.
+ * <p>
+ * It extends the java.util.concurrent.Future with the ability to cancel the
+ * query, check if it is finished and get the resulting list waiting for the
+ * query to finish (ie. the standard features of java.util.concurrent.Future).
+ * </p>
+ * <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 ... 
+ * 
+ * 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>> {
+
+  /**
+   * Return the query that is being executed by a background thread.
+   */
+  Query<T> getQuery();
+
+  /**
+   * Same as {@link #get()} but wraps InterruptedException and ExecutionException in the
+   * unchecked PersistenceException.
+   *
+   * @return The query list result
+   *
+   * @throws PersistenceException when a InterruptedException or ExecutionException occurs.
+   */
+  List<T> getUnchecked();
+
+  /**
+   * Same as {@link #get(long, java.util.concurrent.TimeUnit)} but wraps InterruptedException
+   * and ExecutionException in the unchecked PersistenceException.
+   *
+   * @return The query list result
+   *
+   * @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

@@ -1,15 +1,15 @@
-package com.avaje.ebean;
-
-import java.util.concurrent.Future;
-
-/**
- * Represents the result of a background query execution for the total row count
- * for a query.
- * <p>
- * It extends the java.util.concurrent.Future.
- * </p>
- * 
- * @author rbygrave
- */
-public interface FutureRowCount<T> extends Future<Integer> {
-}
+package com.avaje.ebean;
+
+import java.util.concurrent.Future;
+
+/**
+ * Represents the result of a background query execution for the total row count
+ * for a query.
+ * <p>
+ * It extends the java.util.concurrent.Future.
+ * </p>
+ * 
+ * @author rbygrave
+ */
+public interface FutureRowCount<T> extends Future<Integer> {
+}

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

@@ -1,14 +1,16 @@
 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;
 
-import javax.persistence.MappedSuperclass;
-
 /**
  * A MappedSuperclass base class that provides convenience methods for inserting, updating and
  * deleting beans.
@@ -34,7 +36,7 @@ import javax.persistence.MappedSuperclass;
  *
  * <p>
  * If you choose to use the Model mapped superclass you will probably also chose to additionally add
- * a {@link Finder} as a public static field to complete the active record pattern and provide a
+ * a {@link Find} as a public static field to complete the active record pattern and provide a
  * relatively nice clean way to write queries.
  *
  * <h3>Typical common @MappedSuperclass</h3>
@@ -64,19 +66,15 @@ import javax.persistence.MappedSuperclass;
  *     // Extend the mappedSuperclass
  *
  *     @Entity @Table(name="oto_account")
- *     public class Account extends BaseModel {
+ *     public class Customer extends BaseModel {
  *
- *       // add a static Finder
- *       // ... with Long being the type of our ID property ...
+ *       // 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 Finder<Long,Account> find =
- *             new Finder<Long,Account>(Long.class, Account.class);
+ *       public static final Find<Long,Account> find = new Find<Long,Account>(){};
  *
  *       String name;
- *
- *       @OneToOne(mappedBy = "account",optional = true)
- *       User user;
- *
  *       ...
  *     }
  *
@@ -86,28 +84,28 @@ import javax.persistence.MappedSuperclass;
  * <pre>{@code
  *
  *     // Active record style ... save(), delete() etc
- *     Account account = new Account();
- *     account.setName("AC234");
+ *     Customer customer = new Customer();
+ *     customer.setName("AC234");
  *
  *     // save() method inherited from Model
- *     account.save();
+ *     customer.save();
  *
  * }</pre>
  *
- * <h3>Finder: find byId</h3>
+ * <h3>Find byId</h3>
  * <pre>{@code
  *
  *     // find byId
- *     Account account = Account.find.byId(42);
+ *     Customer customer = Customer.find.byId(42);
  *
  * }</pre>
  *
- * <h3>Finder: find where</h3>
+ * <h3>Find where</h3>
  * <pre>{@code
  *
  *     // find where ...
- *     List<Account> accounts =
- *         Account.find
+ *     List<Customer> customers =
+ *         Customer.find
  *         .where().gt("startDate", lastMonth)
  *         .findList();
  *
@@ -124,7 +122,8 @@ public abstract class Model {
    * 
    * <p>
    * Example:
-   * <pre class="code">
+   * <pre>{@code
+   *
    * Transaction transaction = Customer.db().beginTransaction();
    * try {
    * 
@@ -141,7 +140,7 @@ public abstract class Model {
    *   customer.save();
    * 
    *   Customer otherCustomer = new Customer();
-   *   otherCustomer.setName(&quot;Franko&quot;);
+   *   otherCustomer.setName("Franko");
    *   otherCustomer.save();
    * 
    *   transaction.commit();
@@ -150,10 +149,10 @@ public abstract class Model {
    *   transaction.end();
    * }
    * 
-   * </pre>
+   * }</pre>
    */
   public static EbeanServer db() {
-    return Ebean.getServer(null);
+    return Ebean.getDefaultServer();
   }
 
   /**
@@ -179,7 +178,7 @@ public abstract class Model {
    * An unmodified bean that is saved or updated is normally skipped and this marks the bean as
    * dirty so that it is not skipped.
    * 
-   * <pre class="code">
+   * <pre>{@code
    * 
    * Customer customer = Customer.find.byId(id);
    * 
@@ -188,14 +187,38 @@ public abstract class Model {
    * customer.markAsDirty();
    * customer.save();
    * 
-   * </pre>
+   * }</pre>
    *
    * @see EbeanServer#markAsDirty(Object)
    */
   public void markAsDirty() {
     db().markAsDirty(this);
   }
-  
+
+  /**
+   * 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.
+   * </p>
+   * <pre>{@code
+   *
+   *   // populate an entity bean from JSON or whatever
+   *   User user = ...;
+   *
+   *   // mark the email property as 'unset' so that it is not
+   *   // included in a 'stateless update'
+   *   user.markPropertyUnset("email");
+   *
+   *   user.update();
+   *
+   * }</pre>
+   *
+   * @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);
+  }
+
   /**
    * Insert or update this entity depending on its state.
    * 
@@ -228,12 +251,24 @@ public abstract class Model {
   }
 
   /**
-   * Delete this entity.
+   * Delete this bean.
+   * <p>
+   * This will return true if the bean was deleted successfully or JDBC batch is being used.
+   * </p>
+   * <p>
+   * If there is no current transaction one will be created and committed for
+   * you automatically.
+   * </p>
+   * <p>
+   * If the Bean does not have a version property (or loaded version property) and
+   * the bean does not exist then this returns false indicating that nothing was
+   * deleted. Note that, if JDBC batch mode is used then this always returns true.
+   * </p>
    *
    * @see EbeanServer#delete(Object)
    */
-  public void delete() {
-    db().delete(this);
+  public boolean delete() {
+    return db().delete(this);
   }
 
   /**
@@ -253,8 +288,8 @@ public abstract class Model {
   /**
    * Perform a delete using this entity against the specified server.
    */
-  public void delete(String server) {
-    db(server).delete(this);
+  public boolean delete(String server) {
+    return db(server).delete(this);
   }
 
   /**
@@ -266,47 +301,195 @@ 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 Finder is defined as a public static field on an entity bean class to provide a
+   * 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 bean type
+   *          The entity bean type
    */
-  public static class Finder<I, T> {
+  public static abstract class Find<I, T> {
 
-    private final Class<I> idType;
+    /**
+     * 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 use this constructor to have a static "find" field on each entity bean.
+     * <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>
      */
-    public Finder(Class<I> idType, Class<T> type) {
-      this(null, idType, type);
+    @SuppressWarnings("unchecked")
+    public Find() {
+      this.serverName = null;
+      this.type = (Class<T>)ClassUtil.getSecondArgumentType(getClass());
     }
 
     /**
-     * Creates a finder for entity of type <code>T</code> with ID of type <code>I</code>, using a
-     * specific EbeanServer.
-     * 
-     * <p>
-     * Typically you don't need to use this method.
+     * Construct passing the class literal type of the entity type.
      */
-    public Finder(String serverName, Class<I> idType, Class<T> type) {
-      this.type = type;
-      this.idType = idType;
+    protected Find(String serverName, Class<T> type) {
       this.serverName = serverName;
+      this.type = type;
     }
 
     /**
@@ -335,12 +518,12 @@ public abstract class Model {
 
     /**
      * 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, idType, type);
+      return new Finder<I, T>(server, type);
     }
 
     /**
@@ -368,6 +551,7 @@ public abstract class Model {
      * <p>
      * Equivalent to {@link EbeanServer#find(Class, Object)}
      */
+    @Nullable
     public T byId(I id) {
       return db().find(type, id);
     }
@@ -689,10 +873,10 @@ public abstract class Model {
     }
 
     /**
-     * Create a query with explicit 'Autofetch' use.
+     * Create a query with explicit 'AutoTune' use.
      */
-    public Query<T> setAutofetch(boolean autofetch) {
-      return query().setAutofetch(autofetch);
+    public Query<T> setAutoTune(boolean autoTune) {
+      return query().setAutoTune(autoTune);
     }
 
     /**

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

@@ -1,351 +1,376 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * Represents an Order By for a Query.
- * <p>
- * Is a ordered list of OrderBy.Property objects each specifying a property and
- * whether it is ascending or descending order.
- * </p>
- * <p>
- * Typically you will not construct an OrderBy yourself but use one that exists
- * on the Query object.
- * </p>
- */
-public final class OrderBy<T> implements Serializable {
-
-  private static final long serialVersionUID = 9157089257745730539L;
-
-  private transient Query<T> query;
-
-  private final List<Property> list;
-
-  /**
-   * Create an empty OrderBy with no associated query.
-   */
-  public OrderBy() {
-    this.list = new ArrayList<Property>(2);
-  }
-  
-  private OrderBy(List<Property> list) {
-    this.list = list;
-  }
-
-  /**
-   * Create an orderBy parsing the order by clause.
-   * <p>
-   * The order by clause follows SQL order by clause with comma's between each
-   * property and optionally "asc" or "desc" to represent ascending or
-   * descending order respectively.
-   * </p>
-   */
-  public OrderBy(String orderByClause) {
-    this(null, orderByClause);
-  }
-
-  /**
-   * Construct with a given query and order by clause.
-   */
-  public OrderBy(Query<T> query, String orderByClause) {
-    this.query = query;
-    this.list = new ArrayList<Property>(2);
-    parse(orderByClause);
-  }
-
-  /**
-   * Reverse the ascending/descending order on all the properties.
-   */
-  public void reverse() {
-    for (int i = 0; i < list.size(); i++) {
-      list.get(i).reverse();
-    }
-  }
-
-  /**
-   * Add a property with ascending order to this OrderBy.
-   */
-  public Query<T> asc(String propertyName) {
-
-    list.add(new Property(propertyName, true));
-    return query;
-  }
-
-  /**
-   * Add a property with descending order to this OrderBy.
-   */
-  public Query<T> desc(String propertyName) {
-
-    list.add(new Property(propertyName, false));
-    return query;
-  }
-
-  /**
-   * 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));
-    }
-    return new OrderBy<T>(newList);
-  }
-  
-  /**
-   * Return the properties for this OrderBy.
-   */
-  public List<Property> getProperties() {
-    // not returning an Immutable list at this point
-    return list;
-  }
-
-  /**
-   * Return true if this OrderBy does not have any properties.
-   */
-  public boolean isEmpty() {
-    return list.isEmpty();
-  }
-
-  /**
-   * Return the associated query if there is one.
-   */
-  public Query<T> getQuery() {
-    return query;
-  }
-
-  /**
-   * Associate this OrderBy with a query.
-   */
-  public void setQuery(Query<T> query) {
-    this.query = query;
-  }
-
-  /**
-   * Return a copy of the OrderBy.
-   */
-  public OrderBy<T> copy() {
-
-    OrderBy<T> copy = new OrderBy<T>();
-    for (int i = 0; i < list.size(); i++) {
-      copy.add(list.get(i).copy());
-    }
-    return copy;
-  }
-
-  /**
-   * Add a property to the order by.
-   */
-  public void add(Property p) {
-    list.add(p);
-  }
-
-  public String toString() {
-    return list.toString();
-  }
-
-  /**
-   * Returns the OrderBy in string format.
-   */
-  public String toStringFormat() {
-    if (list.isEmpty()) {
-      return null;
-    }
-    StringBuilder sb = new StringBuilder();
-    for (int i = 0; i < list.size(); i++) {
-      Property property = list.get(i);
-      if (i > 0) {
-        sb.append(", ");
-      }
-      sb.append(property.toStringFormat());
-    }
-    return sb.toString();
-  }
-
-  @Override
-  public boolean equals(Object obj) {
-    if (obj == this) {
-      return true;
-    }
-    if (!(obj instanceof OrderBy<?>)) {
-      return false;
-    }
-    
-    OrderBy<?> e = (OrderBy<?>) obj;
-    return e.list.equals(list);
-  }
-
-  /**
-   * Return a hash value for this OrderBy. This can be to determine logical
-   * equality for OrderBy clauses.
-   */
-  public int hashCode() {
-    return list.hashCode();
-  }
-
-  /**
-   * A property and its ascending descending order.
-   */
-  public static final class Property implements Serializable {
-
-    private static final long serialVersionUID = 1546009780322478077L;
-
-    private String property;
-
-    private boolean ascending;
-
-    public Property(String property, boolean ascending) {
-      this.property = property;
-      this.ascending = ascending;
-    }
-
-    /**
-     * Return a copy of this Property with the path trimmed.
-     */
-    public Property copyWithTrim(String path) {
-      return new Property(property.substring(path.length() + 1), ascending);
-    }
-
-    public int hashCode() {
-      int hc = property.hashCode();
-      hc = hc * 31 + (ascending ? 0 : 1);
-      return hc;
-    }
-    
-    public boolean equals(Object obj) {
-      if (obj == this) {
-        return true;
-      }
-      if (!(obj instanceof Property)) {
-        return false;
-      }
-      
-      Property e = (Property) obj;
-      return e.ascending == ascending 
-          && e.property.equals(property);
-    }
-
-    public String toString() {
-      return toStringFormat();
-    }
-
-    public String toStringFormat() {
-      if (ascending) {
-        return property;
-      } else {
-        return property + " desc";
-      }
-    }
-
-    /**
-     * Reverse the ascending/descending order for this property.
-     */
-    public void reverse() {
-      this.ascending = !ascending;
-    }
-
-    /**
-     * Trim off the pathPrefix.
-     */
-    public void trim(String pathPrefix) {
-      property = property.substring(pathPrefix.length() + 1);
-    }
-
-    /**
-     * Return a copy of this property.
-     */
-    public Property copy() {
-      return new Property(property, ascending);
-    }
-
-    /**
-     * Return the property name.
-     */
-    public String getProperty() {
-      return property;
-    }
-
-    /**
-     * Set the property name.
-     */
-    public void setProperty(String property) {
-      this.property = property;
-    }
-
-    /**
-     * Return true if the order is ascending.
-     */
-    public boolean isAscending() {
-      return ascending;
-    }
-
-    /**
-     * Set to true if the order is ascending.
-     */
-    public void setAscending(boolean ascending) {
-      this.ascending = ascending;
-    }
-
-  }
-
-  private void parse(String orderByClause) {
-
-    if (orderByClause == null) {
-      return;
-    }
-
-    String[] chunks = orderByClause.split(",");
-    for (int i = 0; i < chunks.length; i++) {
-
-      String[] pairs = chunks[i].split(" ");
-      Property p = parseProperty(pairs);
-      if (p != null) {
-        list.add(p);
-      }
-    }
-  }
-
-  private Property parseProperty(String[] pairs) {
-    if (pairs.length == 0) {
-      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]);
-      }
-    }
-    if (wordList.isEmpty()) {
-      return null;
-    }
-    if (wordList.size() == 1) {
-      return new Property(wordList.get(0), true);
-    }
-    if (wordList.size() == 2) {
-      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();
-    throw new RuntimeException(m);
-  }
-
-  private boolean isAscending(String s) {
-    s = s.toLowerCase();
-    if (s.startsWith("asc")) {
-      return true;
-    }
-    if (s.startsWith("desc")) {
-      return false;
-    }
-    String m = "Expecting [" + s + "] to be asc or desc?";
-    throw new RuntimeException(m);
-  }
-
-  private boolean isEmptyString(String s) {
-    return s == null || s.length() == 0;
-  }
-}
+package com.avaje.ebean;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Represents an Order By for a Query.
+ * <p>
+ * Is a ordered list of OrderBy.Property objects each specifying a property and
+ * whether it is ascending or descending order.
+ * </p>
+ * <p>
+ * Typically you will not construct an OrderBy yourself but use one that exists
+ * on the Query object.
+ * </p>
+ */
+public final class OrderBy<T> implements Serializable {
+
+  private static final long serialVersionUID = 9157089257745730539L;
+
+  private transient Query<T> query;
+
+  private final List<Property> list;
+
+  /**
+   * Create an empty OrderBy with no associated query.
+   */
+  public OrderBy() {
+    this.list = new ArrayList<Property>(3);
+  }
+  
+  private OrderBy(List<Property> list) {
+    this.list = list;
+  }
+
+  /**
+   * Create an orderBy parsing the order by clause.
+   * <p>
+   * The order by clause follows SQL order by clause with comma's between each
+   * property and optionally "asc" or "desc" to represent ascending or
+   * descending order respectively.
+   * </p>
+   */
+  public OrderBy(String orderByClause) {
+    this(null, orderByClause);
+  }
+
+  /**
+   * Construct with a given query and order by clause.
+   */
+  public OrderBy(Query<T> query, String orderByClause) {
+    this.query = query;
+    this.list = new ArrayList<Property>(3);
+    parse(orderByClause);
+  }
+
+  /**
+   * Reverse the ascending/descending order on all the properties.
+   */
+  public void reverse() {
+    for (int i = 0; i < list.size(); i++) {
+      list.get(i).reverse();
+    }
+  }
+
+  /**
+   * Add a property with ascending order to this OrderBy.
+   */
+  public Query<T> asc(String propertyName) {
+
+    list.add(new Property(propertyName, true));
+    return query;
+  }
+
+  /**
+   * Add a property with descending order to this OrderBy.
+   */
+  public Query<T> desc(String propertyName) {
+
+    list.add(new Property(propertyName, false));
+    return query;
+  }
+
+  /**
+   * Return true if the property is known to be contained in the order by clause.
+   */
+  public boolean containsProperty(String propertyName) {
+
+    for (int i = 0; i < list.size(); i++) {
+      if (propertyName.equals(list.get(i).getProperty())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * 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));
+    }
+    return new OrderBy<T>(newList);
+  }
+  
+  /**
+   * Return the properties for this OrderBy.
+   */
+  public List<Property> getProperties() {
+    // not returning an Immutable list at this point
+    return list;
+  }
+
+  /**
+   * Return true if this OrderBy does not have any properties.
+   */
+  public boolean isEmpty() {
+    return list.isEmpty();
+  }
+
+  /**
+   * Return the associated query if there is one.
+   */
+  public Query<T> getQuery() {
+    return query;
+  }
+
+  /**
+   * Associate this OrderBy with a query.
+   */
+  public void setQuery(Query<T> query) {
+    this.query = query;
+  }
+
+  /**
+   * Return a copy of the OrderBy.
+   */
+  public OrderBy<T> copy() {
+
+    OrderBy<T> copy = new OrderBy<T>();
+    for (int i = 0; i < list.size(); i++) {
+      copy.add(list.get(i).copy());
+    }
+    return copy;
+  }
+
+  /**
+   * Add a property to the order by.
+   */
+  public void add(Property p) {
+    list.add(p);
+  }
+
+  public String toString() {
+    return list.toString();
+  }
+
+  /**
+   * Returns the OrderBy in string format.
+   */
+  public String toStringFormat() {
+    if (list.isEmpty()) {
+      return null;
+    }
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < list.size(); i++) {
+      Property property = list.get(i);
+      if (i > 0) {
+        sb.append(", ");
+      }
+      sb.append(property.toStringFormat());
+    }
+    return sb.toString();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj == this) {
+      return true;
+    }
+    if (!(obj instanceof OrderBy<?>)) {
+      return false;
+    }
+    
+    OrderBy<?> e = (OrderBy<?>) obj;
+    return e.list.equals(list);
+  }
+
+  /**
+   * Return a hash value for this OrderBy. This can be to determine logical
+   * equality for OrderBy clauses.
+   */
+  public int hashCode() {
+    return list.hashCode();
+  }
+
+  /**
+   * Clear the orderBy removing any current order by properties.
+   * <p>
+   * This is intended to be used when some code creates a query with a
+   * 'default' order by clause and some other code may clear the 'default'
+   * order by clause and replace.
+   * </p>
+   */
+  public void clear() {
+    list.clear();
+  }
+
+  /**
+   * A property and its ascending descending order.
+   */
+  public static final class Property implements Serializable {
+
+    private static final long serialVersionUID = 1546009780322478077L;
+
+    private String property;
+
+    private boolean ascending;
+
+    public Property(String property, boolean ascending) {
+      this.property = property;
+      this.ascending = ascending;
+    }
+
+    /**
+     * Return a copy of this Property with the path trimmed.
+     */
+    public Property copyWithTrim(String path) {
+      return new Property(property.substring(path.length() + 1), ascending);
+    }
+
+    public int hashCode() {
+      int hc = property.hashCode();
+      hc = hc * 31 + (ascending ? 0 : 1);
+      return hc;
+    }
+    
+    public boolean equals(Object obj) {
+      if (obj == this) {
+        return true;
+      }
+      if (!(obj instanceof Property)) {
+        return false;
+      }
+      
+      Property e = (Property) obj;
+      return e.ascending == ascending 
+          && e.property.equals(property);
+    }
+
+    public String toString() {
+      return toStringFormat();
+    }
+
+    public String toStringFormat() {
+      if (ascending) {
+        return property;
+      } else {
+        return property + " desc";
+      }
+    }
+
+    /**
+     * Reverse the ascending/descending order for this property.
+     */
+    public void reverse() {
+      this.ascending = !ascending;
+    }
+
+    /**
+     * Trim off the pathPrefix.
+     */
+    public void trim(String pathPrefix) {
+      property = property.substring(pathPrefix.length() + 1);
+    }
+
+    /**
+     * Return a copy of this property.
+     */
+    public Property copy() {
+      return new Property(property, ascending);
+    }
+
+    /**
+     * Return the property name.
+     */
+    public String getProperty() {
+      return property;
+    }
+
+    /**
+     * Set the property name.
+     */
+    public void setProperty(String property) {
+      this.property = property;
+    }
+
+    /**
+     * Return true if the order is ascending.
+     */
+    public boolean isAscending() {
+      return ascending;
+    }
+
+    /**
+     * Set to true if the order is ascending.
+     */
+    public void setAscending(boolean ascending) {
+      this.ascending = ascending;
+    }
+
+  }
+
+  private void parse(String orderByClause) {
+
+    if (orderByClause == null) {
+      return;
+    }
+
+    String[] chunks = orderByClause.split(",");
+    for (int i = 0; i < chunks.length; i++) {
+
+      String[] pairs = chunks[i].split(" ");
+      Property p = parseProperty(pairs);
+      if (p != null) {
+        list.add(p);
+      }
+    }
+  }
+
+  private Property parseProperty(String[] pairs) {
+    if (pairs.length == 0) {
+      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]);
+      }
+    }
+    if (wordList.isEmpty()) {
+      return null;
+    }
+    if (wordList.size() == 1) {
+      return new Property(wordList.get(0), true);
+    }
+    if (wordList.size() == 2) {
+      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();
+    throw new RuntimeException(m);
+  }
+
+  private boolean isAscending(String s) {
+    s = s.toLowerCase();
+    if (s.startsWith("asc")) {
+      return true;
+    }
+    if (s.startsWith("desc")) {
+      return false;
+    }
+    String m = "Expecting [" + s + "] to be asc or desc?";
+    throw new RuntimeException(m);
+  }
+
+  private boolean isEmptyString(String s) {
+    return s == null || s.length() == 0;
+  }
+}

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

@@ -1,192 +1,197 @@
-package com.avaje.ebean;
-
-import java.util.List;
-import java.util.concurrent.Future;
-
-/**
- * Represents a page of results.
- * <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,
- * 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>
- *
- * <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>
- *
- * <h4>Example: No total row count required</h4>
- * <pre>{@code
- *
- *     // If you are not getting the 'first page' often
- *     // you do not bother getting the total row count again
- *     // so instead just get the page list of data
- *
- *     // fetch and return the list in the foreground thread
- *     List<Order> orders = pagedList.getList();
- *
- * }</pre>
- *
- * @param <T>
- *          the entity bean type
- * 
- * @see Query#findPagedList(int, int)
- */
-public interface PagedList<T> {
-
-  /**
-   * Initiate the loading of the total row count in the background.
-   * <pre>{@code
-   *
-   *     // 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>
-   * 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>
-   */
-  public void loadRowCount();
-
-  /**
-   * Return the Future row count. You might get this if you wish to cancel the total row count query
-   * or specify a timeout for the row count query.
-   * <p>
-   * The loadRowCount() & getTotalRowCount() methods internally make use of this getFutureRowCount() method.
-   * Generally I expect people to prefer loadRowCount() & getTotalRowCount() over getFutureRowCount().
-   * </p>
-   * <pre>{@code
-   *
-   *     // initiate the row count query in the background thread
-   *     Future<Integer> rowCount = pagedList.getFutureRowCount();
-   *
-   *     // fetch and return the list in the foreground thread
-   *     List<Order> orders = pagedList.getList();
-   *
-   *     // now get the total count with a timeout
-   *     Integer totalRowCount = rowCount.get(30, TimeUnit.SECONDS);
-   *
-   *     // or ge the total count without a timeout
-   *     Integer totalRowCountViaFuture = rowCount.get();
-   *
-   *     // which is actually the same as ...
-   *     int totalRowCount = pagedList.getTotalRowCount();
-   *
-   * }</pre>
-   */
-  public Future<Integer> getFutureRowCount();
-
-  /**
-   * Return the list of entities for this page.
-   */
-  public List<T> getList();
-
-  /**
-   * Return the total row count for all pages.
-   * <p>
-   * If loadRowCount() has already been called then the row count query is already executing in a background thread
-   * and this gets the associated Future and gets the value waiting for the future to finish.
-   * </p>
-   * <p>
-   * If loadRowCount() has not been called then this executes the find row count query and returns the result and this
-   * will just occur in the current thread and not use a background thread.
-   * </p>
-   * <pre>{@code
-   *
-   *     // 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 (which was being executed
-   *     // in a background thread if loadRowCount() was used)
-   *     int totalRowCount = pagedList.getTotalRowCount();
-   *
-   * }</pre>
-   */
-  public int getTotalRowCount();
-
-  /**
-   * Return the total number of pages based on the page size and total row count.
-   * <p>
-   * This method requires that the total row count has been fetched and will invoke
-   * the total row count query if it has not already been invoked.
-   * </p>
-   */
-  public int getTotalPageCount();
-
-  /**
-   * Return the index position of this page. Zero based.
-   */
-  public int getPageIndex();
-
-  /**
-   * Return true if there is a next page.
-   * <p>
-   * This method requires that the total row count has been fetched and will invoke
-   * the total row count query if it has not already been invoked.
-   * </p>
-   */
-  public boolean hasNext();
-
-  /**
-   * Return true if there is a previous page.
-   */
-  public boolean hasPrev();
-
-  /**
-   * Helper method to return a "X to Y of Z" string for this page where X is the first row, Y the
-   * last row and Z the total row count.
-   * <p>
-   * This method requires that the total row count has been fetched and will invoke
-   * 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
-   * 
-   * @return String of the format XtoYofZ.
-   */
-  public String getDisplayXtoYofZ(String to, String of);
-}
+package com.avaje.ebean;
+
+import java.util.List;
+import java.util.concurrent.Future;
+
+/**
+ * Represents a page of results.
+ * <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,
+ * 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>
+ *
+ * <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>
+ *
+ * <h4>Example: No total row count required</h4>
+ * <pre>{@code
+ *
+ *     // If you are not getting the 'first page' often
+ *     // you do not bother getting the total row count again
+ *     // so instead just get the page list of data
+ *
+ *     // fetch and return the list in the foreground thread
+ *     List<Order> orders = pagedList.getList();
+ *
+ * }</pre>
+ *
+ * @param <T>
+ *          the entity bean type
+ * 
+ * @see Query#findPagedList(int, int)
+ */
+public interface PagedList<T> {
+
+  /**
+   * Initiate the loading of the total row count in the background.
+   * <pre>{@code
+   *
+   *     // 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>
+   * 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();
+
+  /**
+   * Return the Future row count. You might get this if you wish to cancel the total row count query
+   * or specify a timeout for the row count query.
+   * <p>
+   * The loadRowCount() & getTotalRowCount() methods internally make use of this getFutureRowCount() method.
+   * Generally I expect people to prefer loadRowCount() & getTotalRowCount() over getFutureRowCount().
+   * </p>
+   * <pre>{@code
+   *
+   *     // initiate the row count query in the background thread
+   *     Future<Integer> rowCount = pagedList.getFutureRowCount();
+   *
+   *     // fetch and return the list in the foreground thread
+   *     List<Order> orders = pagedList.getList();
+   *
+   *     // now get the total count with a timeout
+   *     Integer totalRowCount = rowCount.get(30, TimeUnit.SECONDS);
+   *
+   *     // or ge the total count without a timeout
+   *     Integer totalRowCountViaFuture = rowCount.get();
+   *
+   *     // which is actually the same as ...
+   *     int totalRowCount = pagedList.getTotalRowCount();
+   *
+   * }</pre>
+   */
+  Future<Integer> getFutureRowCount();
+
+  /**
+   * Return the list of entities for this page.
+   */
+  List<T> getList();
+
+  /**
+   * Return the total row count for all pages.
+   * <p>
+   * If loadRowCount() has already been called then the row count query is already executing in a background thread
+   * and this gets the associated Future and gets the value waiting for the future to finish.
+   * </p>
+   * <p>
+   * If loadRowCount() has not been called then this executes the find row count query and returns the result and this
+   * will just occur in the current thread and not use a background thread.
+   * </p>
+   * <pre>{@code
+   *
+   *     // 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 (which was being executed
+   *     // in a background thread if loadRowCount() was used)
+   *     int totalRowCount = pagedList.getTotalRowCount();
+   *
+   * }</pre>
+   */
+  int getTotalRowCount();
+
+  /**
+   * Return the total number of pages based on the page size and total row count.
+   * <p>
+   * This method requires that the total row count has been fetched and will invoke
+   * the total row count query if it has not already been invoked.
+   * </p>
+   */
+  int getTotalPageCount();
+
+  /**
+   * Return the index position of this page. Zero based.
+   */
+  int getPageIndex();
+
+  /**
+   * Return the page size used for this query.
+   */
+  int getPageSize();
+
+  /**
+   * Return true if there is a next page.
+   * <p>
+   * This method requires that the total row count has been fetched and will invoke
+   * the total row count query if it has not already been invoked.
+   * </p>
+   */
+  boolean hasNext();
+
+  /**
+   * Return true if there is a previous page.
+   */
+  boolean hasPrev();
+
+  /**
+   * Helper method to return a "X to Y of Z" string for this page where X is the first row, Y the
+   * last row and Z the total row count.
+   * <p>
+   * This method requires that the total row count has been fetched and will invoke
+   * 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
+   * 
+   * @return String of the format XtoYofZ.
+   */
+  String getDisplayXtoYofZ(String to, String of);
+}

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

@@ -34,7 +34,7 @@ class PrimaryServer {
   /**
    * Return the default server name.
    */
-  static synchronized String getPrimaryServerName() {
+  static synchronized String getDefaultServerName() {
     getProperties();
     return defaultServerName;
   }
@@ -46,10 +46,35 @@ class PrimaryServer {
     if (globalProperties == null) {
       globalProperties = PropertyMap.defaultProperties();
     }
-    defaultServerName = globalProperties.getProperty("datasource.default");
     if (defaultServerName == null) {
-      defaultServerName = globalProperties.getProperty("ebean.default.datasource");
+      defaultServerName = determineDefaultServerName();
     }
     return globalProperties;
+
+  }
+
+  /**
+   * Determine and return the default server name checking system environment variables and then global properties.
+   */
+  private static String determineDefaultServerName() {
+
+    String defaultServerName = System.getProperty("datasource.default");
+    if (isEmpty(defaultServerName)) {
+      defaultServerName = System.getProperty("ebean.default.datasource");
+    }
+    if (isEmpty(defaultServerName)) {
+      defaultServerName = globalProperties.getProperty("datasource.default");
+    }
+    if (isEmpty(defaultServerName)) {
+      defaultServerName = globalProperties.getProperty("ebean.default.datasource");
+    }
+    return defaultServerName;
+  }
+
+  /**
+   * Return true if the string is null or empty.
+   */
+  private static boolean isEmpty(String value) {
+    return value == null || value.trim().length() == 0;
   }
 }

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

@@ -1,41 +1,41 @@
-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
-   */
-  public void accept(T bean);
-}
+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 +1,45 @@
-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.
-   */
-  public boolean accept(T bean);
-}
+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

@@ -1,60 +1,60 @@
-package com.avaje.ebean;
-
-import java.util.Iterator;
-
-/**
- * Used to provide iteration over query results.
- * <p>
- * This can be used when you want to process a very large number of results and
- * means that you don't have to hold all the results in memory at once (unlike
- * 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;)
- *     .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
- */
-public interface QueryIterator<T> extends Iterator<T>, java.io.Closeable {
-
-  /**
-   * Returns <tt>true</tt> if the iteration has more elements.
-   */
-  public boolean hasNext();
-
-  /**
-   * Returns the next element in the iteration.
-   */
-  public T next();
-
-  /**
-   * Remove is not allowed.
-   */
-  public void remove();
-
-  /**
-   * Close the underlying resources held by this iterator.
-   */
-  public void close();
-}
+package com.avaje.ebean;
+
+import java.util.Iterator;
+
+/**
+ * Used to provide iteration over query results.
+ * <p>
+ * This can be used when you want to process a very large number of results and
+ * means that you don't have to hold all the results in memory at once (unlike
+ * 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;)
+ *     .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
+ */
+public interface QueryIterator<T> extends Iterator<T>, java.io.Closeable {
+
+  /**
+   * Returns <tt>true</tt> if the iteration has more elements.
+   */
+  boolean hasNext();
+
+  /**
+   * Returns the next element in the iteration.
+   */
+  T next();
+
+  /**
+   * Remove is not allowed.
+   */
+  void remove();
+
+  /**
+   * Close the underlying resources held by this iterator.
+   */
+  void close();
+}

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

@@ -1,49 +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 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.findVisit(new QueryResultVisitor&lt;Customer&gt;() {
- * 
- *   public boolean accept(Customer customer) {
- *     // do something with customer
- *     System.out.println(&quot;-- visit &quot; + customer);
- *     return true;
- *   }
- * });
- * </pre>
- * 
- * @author rbygrave
- * 
- * @param <T>
- *          the type of entity bean being queried.
- */
-public interface QueryResultVisitor<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 or false to stop.
-   */
-  public boolean accept(T bean);
-}

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

@@ -1,132 +1,132 @@
-package com.avaje.ebean;
-
-import java.sql.ResultSet;
-
-import com.avaje.ebean.RawSql.ColumnMapping;
-import com.avaje.ebean.RawSql.Sql;
-
-/**
- * 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 {
-
-  /**
-   * Special property name assigned to a DB column that should be ignored.
-   */
-  public static final String IGNORE_COLUMN = "$$_IGNORE_COLUMN_$$";
-
-  private final ResultSet resultSet;
-  
-  private final Sql sql;
-
-  private final ColumnMapping columnMapping;
-
-  /**
-   * Create and return a RawSql object based on the resultSet and list of properties the columns in
-   * the resultSet map to.
-   * <p>
-   * The properties listed in the propertyNames must be in the same order as the columns in the
-   * resultSet.
-   */
-  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
-   * this query.
-   */
-  public static RawSqlBuilder unparsed(String sql) {
-
-    Sql s = new Sql(sql);
-    return new RawSqlBuilder(s, new ColumnMapping());
-  }
-
-  /**
-   * Return a RawSqlBuilder parsing the sql.
-   * <p>
-   * The sql statement will be parsed so that Ebean can determine where it can
-   * insert additional WHERE or HAVING expressions.
-   * </p>
-   * <p>
-   * Additionally the selected columns are parsed to determine the column
-   * ordering. This also means additional checks can be made with the column
-   * mapping - specifically we can check that all columns are mapped and that
-   * correct column names are entered into the mapping.
-   * </p>
-   */
-  public static RawSqlBuilder parse(String sql) {
-
-    Sql sql2 = DRawSqlParser.parse(sql);
-    String select = sql2.getPreFrom();
-
-    ColumnMapping mapping = DRawSqlColumnsParser.parse(select);
-    return new RawSqlBuilder(sql2, mapping);
-  }
-  
-  private RawSqlBuilder(Sql sql, ColumnMapping columnMapping) {
-    this.sql = sql;
-    this.columnMapping = columnMapping;
-    this.resultSet = null;
-  }
-
-  /**
-   * Set the mapping of a DB Column to a bean property.
-   * <p>
-   * 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.
-   */
-  public RawSqlBuilder columnMapping(String dbColumn, String propertyName) {
-    columnMapping.columnMapping(dbColumn, propertyName);
-    return this;
-  }
-
-  /**
-   * Ignore this DB column. It is not mapped to any bean property.
-   */
-  public RawSqlBuilder columnMappingIgnore(String dbColumn) {
-    return columnMapping(dbColumn, IGNORE_COLUMN);
-  }
-
-  /**
-   * Modify any column mappings with the given table alias to have the path prefix.
-   * <p>
-   * For example modify all mappings with table alias "c" to have the path prefix "customer".
-   * </p>
-   */
-  public RawSqlBuilder tableAliasMapping(String tableAlias, String path) {
-    columnMapping.tableAliasMapping(tableAlias, path);
-    return this;
-  }
-
-  /**
-   * Create the immutable RawSql object. Do this after all the column mapping
-   * has been defined.
-   */
-  public RawSql create() {
-    return new RawSql(resultSet, sql, columnMapping.createImmutableCopy());
-  }
-
-  /**
-   * Return the internal parsed Sql object (for testing).
-   */
-  protected Sql getSql() {
-    return sql;
-  }
-
-
-
-}
+package com.avaje.ebean;
+
+import java.sql.ResultSet;
+
+import com.avaje.ebean.RawSql.ColumnMapping;
+import com.avaje.ebean.RawSql.Sql;
+
+/**
+ * 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 {
+
+  /**
+   * Special property name assigned to a DB column that should be ignored.
+   */
+  public static final String IGNORE_COLUMN = "$$_IGNORE_COLUMN_$$";
+
+  private final ResultSet resultSet;
+  
+  private final Sql sql;
+
+  private final ColumnMapping columnMapping;
+
+  /**
+   * Create and return a RawSql object based on the resultSet and list of properties the columns in
+   * the resultSet map to.
+   * <p>
+   * The properties listed in the propertyNames must be in the same order as the columns in the
+   * resultSet.
+   */
+  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
+   * this query.
+   */
+  public static RawSqlBuilder unparsed(String sql) {
+
+    Sql s = new Sql(sql);
+    return new RawSqlBuilder(s, new ColumnMapping());
+  }
+
+  /**
+   * Return a RawSqlBuilder parsing the sql.
+   * <p>
+   * The sql statement will be parsed so that Ebean can determine where it can
+   * insert additional WHERE or HAVING expressions.
+   * </p>
+   * <p>
+   * Additionally the selected columns are parsed to determine the column
+   * ordering. This also means additional checks can be made with the column
+   * mapping - specifically we can check that all columns are mapped and that
+   * correct column names are entered into the mapping.
+   * </p>
+   */
+  public static RawSqlBuilder parse(String sql) {
+
+    Sql sql2 = DRawSqlParser.parse(sql);
+    String select = sql2.getPreFrom();
+
+    ColumnMapping mapping = DRawSqlColumnsParser.parse(select);
+    return new RawSqlBuilder(sql2, mapping);
+  }
+  
+  private RawSqlBuilder(Sql sql, ColumnMapping columnMapping) {
+    this.sql = sql;
+    this.columnMapping = columnMapping;
+    this.resultSet = null;
+  }
+
+  /**
+   * Set the mapping of a DB Column to a bean property.
+   * <p>
+   * 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.
+   */
+  public RawSqlBuilder columnMapping(String dbColumn, String propertyName) {
+    columnMapping.columnMapping(dbColumn, propertyName);
+    return this;
+  }
+
+  /**
+   * Ignore this DB column. It is not mapped to any bean property.
+   */
+  public RawSqlBuilder columnMappingIgnore(String dbColumn) {
+    return columnMapping(dbColumn, IGNORE_COLUMN);
+  }
+
+  /**
+   * Modify any column mappings with the given table alias to have the path prefix.
+   * <p>
+   * For example modify all mappings with table alias "c" to have the path prefix "customer".
+   * </p>
+   */
+  public RawSqlBuilder tableAliasMapping(String tableAlias, String path) {
+    columnMapping.tableAliasMapping(tableAlias, path);
+    return this;
+  }
+
+  /**
+   * Create the immutable RawSql object. Do this after all the column mapping
+   * has been defined.
+   */
+  public RawSql create() {
+    return new RawSql(resultSet, sql, columnMapping.createImmutableCopy());
+  }
+
+  /**
+   * Return the internal parsed Sql object (for testing).
+   */
+  protected Sql getSql() {
+    return sql;
+  }
+
+
+
+}

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

@@ -1,47 +1,47 @@
-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>> {
-
-  public SqlQuery getQuery();
-
-}
+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

@@ -1,151 +1,151 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Query object for performing native SQL queries that return SqlRow's.
- * <p>
- * Firstly note that you can use your own sql queries with <em>entity beans</em>
- * by using the SqlSelect annotation. This should be your first approach when
- * wanting to use your own SQL queries.
- * </p>
- * <p>
- * If ORM Mapping is too tight and constraining for your problem then SqlQuery
- * could be a good approach.
- * </p>
- * <p>
- * 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>
- * 
- */
-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>
-   */
-  public void cancel();
-
-  /**
-   * Execute the query returning a list.
-   */
-  public List<SqlRow> findList();
-
-  /**
-   * Execute the query returning a set.
-   */
-  public Set<SqlRow> findSet();
-
-  /**
-   * Execute the query returning a map.
-   */
-  public Map<?, SqlRow> findMap();
-
-  /**
-   * Execute the query returning a single row or null.
-   * <p>
-   * If this query finds 2 or more rows then it will throw a
-   * PersistenceException.
-   * </p>
-   */
-  public 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
-   */
-  public SqlFutureList findFutureList();
-
-  /**
-   * The same as bind for named parameters.
-   */
-  public SqlQuery setParameter(String name, Object value);
-
-  /**
-   * The same as bind for positioned parameters.
-   */
-  public 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>
-   */
-  public SqlQuery setListener(SqlQueryListener queryListener);
-
-  /**
-   * Set the index of the first row of the results to return.
-   */
-  public SqlQuery setFirstRow(int firstRow);
-
-  /**
-   * Set the maximum number of query results to return.
-   */
-  public SqlQuery setMaxRows(int maxRows);
-
-  /**
-   * Set the index after which fetching continues in a background thread.
-   */
-  public SqlQuery setBackgroundFetchAfter(int backgroundFetchAfter);
-
-  /**
-   * Set the column to use to determine the keys for a Map.
-   */
-  public SqlQuery setMapKey(String mapKey);
-
-  /**
-   * Set a timeout on this query.
-   * <p>
-   * This will typically result in a call to setQueryTimeout() on a
-   * 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.
-   */
-  public SqlQuery setTimeout(int secs);
-
-  /**
-   * A hint which for JDBC translates to the Statement.fetchSize().
-   * <p>
-   * Gives the JDBC driver a hint as to the number of rows that should be
-   * fetched from the database when more rows are needed for ResultSet.
-   * </p>
-   */
-  public SqlQuery setBufferFetchSizeHint(int bufferFetchSizeHint);
-
-}
+package com.avaje.ebean;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Query object for performing native SQL queries that return SqlRow's.
+ * <p>
+ * Firstly note that you can use your own sql queries with <em>entity beans</em>
+ * by using the SqlSelect annotation. This should be your first approach when
+ * wanting to use your own SQL queries.
+ * </p>
+ * <p>
+ * If ORM Mapping is too tight and constraining for your problem then SqlQuery
+ * could be a good approach.
+ * </p>
+ * <p>
+ * 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>
+ * 
+ */
+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.
+   */
+  Set<SqlRow> findSet();
+
+  /**
+   * Execute the query returning a map.
+   */
+  Map<?, SqlRow> findMap();
+
+  /**
+   * Execute the query returning a single row or null.
+   * <p>
+   * If this query finds 2 or more rows then it will throw a
+   * PersistenceException.
+   * </p>
+   */
+  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.
+   */
+  SqlQuery setParameter(String name, Object value);
+
+  /**
+   * The same as bind for positioned parameters.
+   */
+  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.
+   */
+  SqlQuery setFirstRow(int firstRow);
+
+  /**
+   * Set the maximum number of query results to return.
+   */
+  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>
+   * This will typically result in a call to setQueryTimeout() on a
+   * 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.
+   */
+  SqlQuery setTimeout(int secs);
+
+  /**
+   * A hint which for JDBC translates to the Statement.fetchSize().
+   * <p>
+   * Gives the JDBC driver a hint as to the number of rows that should be
+   * fetched from the database when more rows are needed for ResultSet.
+   * </p>
+   */
+  SqlQuery setBufferFetchSizeHint(int bufferFetchSizeHint);
+
+}

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

@@ -1,33 +1,33 @@
-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>
-   */
-  public void process(SqlRow bean);
-}
+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/SqlRow.java

@@ -1,168 +1,168 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.sql.Date;
-import java.sql.Timestamp;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Used to return raw SQL query results.
- * <p>
- * Refer to {@link SqlQuery} for examples.
- * </p>
- * <p>
- * There are convenience methods such as getInteger(), getBigDecimal() etc. The
- * reason for these methods is that the values put into this map often come
- * straight from the JDBC resultSet. Depending on the JDBC driver it may put a
- * different type into a given property. For example an Integer, BigDecimal,
- * Double could all be put into a property depending on the JDBC driver used.
- * These convenience methods automatically convert the value as required
- * returning the type you expect.
- * </p>
- */
-public interface SqlRow extends Serializable, Map<String, Object> {
-
-  /**
-   * Return the property names (String).
-   * <p>
-   * Internally this uses LinkedHashMap and so the order of the property names
-   * should be predictable and ordered by the use of LinkedHashMap.
-   * </p>
-   */
-  public Iterator<String> keys();
-
-  /**
-   * Remove a property from the map. Returns the value of the removed property.
-   */
-  public Object remove(Object name);
-
-  /**
-   * Return a property value by its name.
-   */
-  public Object get(Object name);
-
-  /**
-   * Set a value to a property.
-   */
-  public Object put(String name, Object value);
-
-  /**
-   * Exactly the same as the put method.
-   * <p>
-   * I added this method because it seems more bean like to have get and set
-   * methods.
-   * </p>
-   */
-  public Object set(String name, Object value);
-
-  /**
-   * Return a property as a Boolean.
-   */
-  public Boolean getBoolean(String name);
-
-  /**
-   * Return a property as a UUID.
-   */
-  public UUID getUUID(String name);
-
-  /**
-   * Return a property as an Integer.
-   */
-  public Integer getInteger(String name);
-
-  /**
-   * Return a property value as a BigDecimal.
-   */
-  public BigDecimal getBigDecimal(String name);
-
-  /**
-   * Return a property value as a Long.
-   */
-  public Long getLong(String name);
-
-  /**
-   * Return the property value as a Double.
-   */
-  public Double getDouble(String name);
-
-  /**
-   * Return the property value as a Float.
-   */
-  public Float getFloat(String name);
-
-  /**
-   * Return a property as a String.
-   */
-  public String getString(String name);
-
-  /**
-   * Return the property as a java.util.Date.
-   */
-  public java.util.Date getUtilDate(String name);
-
-  /**
-   * Return the property as a sql date.
-   */
-  public Date getDate(String name);
-
-  /**
-   * Return the property as a sql timestamp.
-   */
-  public Timestamp getTimestamp(String name);
-
-  /**
-   * String description of the underlying map.
-   */
-  public String toString();
-
-  /**
-   * Clear the map.
-   */
-  public void clear();
-
-  /**
-   * Returns true if the map contains the property.
-   */
-  public boolean containsKey(Object key);
-
-  /**
-   * Returns true if the map contains the value.
-   */
-  public boolean containsValue(Object value);
-
-  /**
-   * Returns the entrySet of the map.
-   */
-  public Set<Map.Entry<String, Object>> entrySet();
-
-  /**
-   * Returns true if the map is empty.
-   */
-  public boolean isEmpty();
-
-  /**
-   * Returns the key set of the map.
-   */
-  public Set<String> keySet();
-
-  /**
-   * Put all the values from t into this map.
-   */
-  public void putAll(Map<? extends String, ? extends Object> t);
-
-  /**
-   * Return the size of the map.
-   */
-  public int size();
-
-  /**
-   * Return the values from this map.
-   */
-  public Collection<Object> values();
-
+package com.avaje.ebean;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.sql.Date;
+import java.sql.Timestamp;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * Used to return raw SQL query results.
+ * <p>
+ * Refer to {@link SqlQuery} for examples.
+ * </p>
+ * <p>
+ * There are convenience methods such as getInteger(), getBigDecimal() etc. The
+ * reason for these methods is that the values put into this map often come
+ * straight from the JDBC resultSet. Depending on the JDBC driver it may put a
+ * different type into a given property. For example an Integer, BigDecimal,
+ * Double could all be put into a property depending on the JDBC driver used.
+ * These convenience methods automatically convert the value as required
+ * returning the type you expect.
+ * </p>
+ */
+public interface SqlRow extends Serializable, Map<String, Object> {
+
+  /**
+   * Return the property names (String).
+   * <p>
+   * Internally this uses LinkedHashMap and so the order of the property names
+   * should be predictable and ordered by the use of LinkedHashMap.
+   * </p>
+   */
+  Iterator<String> keys();
+
+  /**
+   * Remove a property from the map. Returns the value of the removed property.
+   */
+  Object remove(Object name);
+
+  /**
+   * Return a property value by its name.
+   */
+  Object get(Object name);
+
+  /**
+   * Set a value to a property.
+   */
+  Object put(String name, Object value);
+
+  /**
+   * Exactly the same as the put method.
+   * <p>
+   * I added this method because it seems more bean like to have get and set
+   * methods.
+   * </p>
+   */
+  Object set(String name, Object value);
+
+  /**
+   * Return a property as a Boolean.
+   */
+  Boolean getBoolean(String name);
+
+  /**
+   * Return a property as a UUID.
+   */
+  UUID getUUID(String name);
+
+  /**
+   * Return a property as an Integer.
+   */
+  Integer getInteger(String name);
+
+  /**
+   * Return a property value as a BigDecimal.
+   */
+  BigDecimal getBigDecimal(String name);
+
+  /**
+   * Return a property value as a Long.
+   */
+  Long getLong(String name);
+
+  /**
+   * Return the property value as a Double.
+   */
+  Double getDouble(String name);
+
+  /**
+   * Return the property value as a Float.
+   */
+  Float getFloat(String name);
+
+  /**
+   * Return a property as a String.
+   */
+  String getString(String name);
+
+  /**
+   * Return the property as a java.util.Date.
+   */
+  java.util.Date getUtilDate(String name);
+
+  /**
+   * Return the property as a sql date.
+   */
+  Date getDate(String name);
+
+  /**
+   * Return the property as a sql timestamp.
+   */
+  Timestamp getTimestamp(String name);
+
+  /**
+   * String description of the underlying map.
+   */
+  String toString();
+
+  /**
+   * Clear the map.
+   */
+  void clear();
+
+  /**
+   * Returns true if the map contains the property.
+   */
+  boolean containsKey(Object key);
+
+  /**
+   * Returns true if the map contains the value.
+   */
+  boolean containsValue(Object value);
+
+  /**
+   * Returns the entrySet of the map.
+   */
+  Set<Map.Entry<String, Object>> entrySet();
+
+  /**
+   * Returns true if the map is empty.
+   */
+  boolean isEmpty();
+
+  /**
+   * Returns the key set of the map.
+   */
+  Set<String> keySet();
+
+  /**
+   * Put all the values from t into this map.
+   */
+  void putAll(Map<? extends String, ?> t);
+
+  /**
+   * Return the size of the map.
+   */
+  int size();
+
+  /**
+   * Return the values from this map.
+   */
+  Collection<Object> values();
+
 }

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

@@ -1,146 +1,146 @@
-package com.avaje.ebean;
-
-/**
- * A SqlUpdate for executing insert update or delete statements.
- * <p>
- * Provides a simple way to execute raw SQL insert update or delete statements
- * without having to resort to JDBC.
- * </p>
- * <p>
- * Supports the use of positioned or named parameters and can automatically
- * notify Ebean of the table modified so that Ebean can maintain its cache.
- * </p>
- * <p>
- * Note that {@link #setAutoTableMod(boolean)} and
- * Ebean#externalModification(String, boolean, boolean, boolean)} can be to
- * 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;
- * SqlUpdate update = Ebean.createSqlUpdate(s);
- * update.setParameter(&quot;id&quot;, 1);
- * update.setParameter(&quot;count&quot;, 50);
- * 
- * int modifiedCount = Ebean.execute(update);
- * 
- * String msg = &quot;There where &quot; + modifiedCount + &quot;rows updated&quot;
- * </pre>
- * 
- * @see Update
- * @see SqlQuery
- * @see CallableSql
- */
-public interface SqlUpdate {
-
-  /**
-   * Execute the update returning the number of rows modified.
-   * <p>
-   * After you have executed the SqlUpdate you can bind new variables using
-   * {@link #setParameter(String, Object)} etc and then execute the SqlUpdate
-   * again.
-   * </p>
-   * <p>
-   * For JDBC batch processing refer to
-   * {@link Transaction#setBatchMode(boolean)} and
-   * {@link Transaction#setBatchSize(int)}.
-   * </p>
-   * 
-   * @see com.avaje.ebean.Ebean#execute(SqlUpdate)
-   */
-  public int execute();
-
-  /**
-   * Return true if eBean should automatically deduce the table modification
-   * information and process it.
-   * <p>
-   * If this is true then cache invalidation and text index management are aware
-   * of the modification.
-   * </p>
-   */
-  public boolean isAutoTableMod();
-
-  /**
-   * Set this to false if you don't want eBean to automatically deduce the table
-   * modification information and process it.
-   * <p>
-   * Set this to false if you don't want any cache invalidation or text index
-   * management to occur. You may do this when say you update only one column
-   * and you know that it is not important for cached objects or text indexes.
-   * </p>
-   */
-  public SqlUpdate setAutoTableMod(boolean isAutoTableMod);
-
-  /**
-   * Return the label that can be seen in the transaction logs.
-   */
-  public String getLabel();
-
-  /**
-   * Set a descriptive text that can be put into the transaction log.
-   * <p>
-   * Useful when identifying the statement in the transaction log.
-   * </p>
-   */
-  public SqlUpdate setLabel(String label);
-
-  /**
-   * Return the sql statement.
-   */
-  public String getSql();
-
-  /**
-   * Return the generated sql that has named parameters converted to positioned parameters.
-   */
-  public String getGeneratedSql();
-
-  /**
-   * Return the timeout used to execute this statement.
-   */
-  public int getTimeout();
-
-  /**
-   * Set the timeout in seconds. Zero implies no limit.
-   * <p>
-   * This will set the query timeout on the underlying PreparedStatement. If the
-   * timeout expires a SQLException will be throw and wrapped in a
-   * PersistenceException.
-   * </p>
-   */
-  public SqlUpdate setTimeout(int secs);
-
-  /**
-   * Set a parameter via its index position.
-   */
-  public SqlUpdate setParameter(int position, Object value);
-
-  /**
-   * Set a null parameter via its index position. Exactly the same as
-   * {@link #setNull(int, int)}.
-   */
-  public SqlUpdate setNull(int position, int jdbcType);
-
-  /**
-   * Set a null valued parameter using its index position.
-   */
-  public SqlUpdate setNullParameter(int position, int jdbcType);
-
-  /**
-   * Set a named parameter value.
-   */
-  public SqlUpdate setParameter(String name, Object param);
-
-  /**
-   * Set a named parameter that has a null value. Exactly the same as
-   * {@link #setNullParameter(String, int)}.
-   */
-  public SqlUpdate setNull(String name, int jdbcType);
-
-  /**
-   * Set a named parameter that has a null value.
-   */
-  public SqlUpdate setNullParameter(String name, int jdbcType);
-
+package com.avaje.ebean;
+
+/**
+ * A SqlUpdate for executing insert update or delete statements.
+ * <p>
+ * Provides a simple way to execute raw SQL insert update or delete statements
+ * without having to resort to JDBC.
+ * </p>
+ * <p>
+ * Supports the use of positioned or named parameters and can automatically
+ * notify Ebean of the table modified so that Ebean can maintain its cache.
+ * </p>
+ * <p>
+ * Note that {@link #setAutoTableMod(boolean)} and
+ * Ebean#externalModification(String, boolean, boolean, boolean)} can be to
+ * 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;
+ * SqlUpdate update = Ebean.createSqlUpdate(s);
+ * update.setParameter(&quot;id&quot;, 1);
+ * update.setParameter(&quot;count&quot;, 50);
+ * 
+ * int modifiedCount = Ebean.execute(update);
+ * 
+ * String msg = &quot;There where &quot; + modifiedCount + &quot;rows updated&quot;
+ * </pre>
+ * 
+ * @see Update
+ * @see SqlQuery
+ * @see CallableSql
+ */
+public interface SqlUpdate {
+
+  /**
+   * Execute the update returning the number of rows modified.
+   * <p>
+   * After you have executed the SqlUpdate you can bind new variables using
+   * {@link #setParameter(String, Object)} etc and then execute the SqlUpdate
+   * again.
+   * </p>
+   * <p>
+   * For JDBC batch processing refer to
+   * {@link Transaction#setBatchMode(boolean)} and
+   * {@link Transaction#setBatchSize(int)}.
+   * </p>
+   * 
+   * @see com.avaje.ebean.Ebean#execute(SqlUpdate)
+   */
+  int execute();
+
+  /**
+   * Return true if eBean should automatically deduce the table modification
+   * information and process it.
+   * <p>
+   * If this is true then cache invalidation and text index management are aware
+   * of the modification.
+   * </p>
+   */
+  boolean isAutoTableMod();
+
+  /**
+   * Set this to false if you don't want eBean to automatically deduce the table
+   * modification information and process it.
+   * <p>
+   * Set this to false if you don't want any cache invalidation or text index
+   * management to occur. You may do this when say you update only one column
+   * and you know that it is not important for cached objects or text indexes.
+   * </p>
+   */
+  SqlUpdate setAutoTableMod(boolean isAutoTableMod);
+
+  /**
+   * Return the label that can be seen in the transaction logs.
+   */
+  String getLabel();
+
+  /**
+   * Set a descriptive text that can be put into the transaction log.
+   * <p>
+   * Useful when identifying the statement in the transaction log.
+   * </p>
+   */
+  SqlUpdate setLabel(String label);
+
+  /**
+   * Return the sql statement.
+   */
+  String getSql();
+
+  /**
+   * Return the generated sql that has named parameters converted to positioned parameters.
+   */
+  String getGeneratedSql();
+
+  /**
+   * Return the timeout used to execute this statement.
+   */
+  int getTimeout();
+
+  /**
+   * Set the timeout in seconds. Zero implies no limit.
+   * <p>
+   * This will set the query timeout on the underlying PreparedStatement. If the
+   * timeout expires a SQLException will be throw and wrapped in a
+   * PersistenceException.
+   * </p>
+   */
+  SqlUpdate setTimeout(int secs);
+
+  /**
+   * Set a parameter via its index position.
+   */
+  SqlUpdate setParameter(int position, Object value);
+
+  /**
+   * Set a null parameter via its index position. Exactly the same as
+   * {@link #setNull(int, int)}.
+   */
+  SqlUpdate setNull(int position, int jdbcType);
+
+  /**
+   * Set a null valued parameter using its index position.
+   */
+  SqlUpdate setNullParameter(int position, int jdbcType);
+
+  /**
+   * Set a named parameter value.
+   */
+  SqlUpdate setParameter(String name, Object param);
+
+  /**
+   * Set a named parameter that has a null value. Exactly the same as
+   * {@link #setNullParameter(String, int)}.
+   */
+  SqlUpdate setNull(String name, int jdbcType);
+
+  /**
+   * Set a named parameter that has a null value.
+   */
+  SqlUpdate setNullParameter(String name, int jdbcType);
+
 }

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

@@ -1,329 +1,339 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.config.PersistBatch;
-
-import javax.persistence.OptimisticLockException;
-import javax.persistence.PersistenceException;
-import javax.persistence.RollbackException;
-import java.io.Closeable;
-import java.sql.Connection;
-
-/**
- * The Transaction object. Typically representing a JDBC or JTA transaction.
- */
-public interface Transaction extends Closeable {
-
-  /**
-   * Read Committed transaction isolation. Same as
-   * java.sql.Connection.TRANSACTION_READ_COMMITTED.
-   */
-  public static final int READ_COMMITTED = java.sql.Connection.TRANSACTION_READ_COMMITTED;
-
-  /**
-   * Read Uncommitted transaction isolation. Same as
-   * java.sql.Connection.TRANSACTION_READ_UNCOMMITTED.
-   */
-  public static final int READ_UNCOMMITTED = java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
-
-  /**
-   * Repeatable read transaction isolation. Same as
-   * java.sql.Connection.TRANSACTION_REPEATABLE_READ.
-   */
-  public static final int REPEATABLE_READ = java.sql.Connection.TRANSACTION_REPEATABLE_READ;
-
-  /**
-   * Serializable transaction isolation. Same as
-   * java.sql.Connection.TRANSACTION_SERIALIZABLE.
-   */
-  public static final int SERIALIZABLE = java.sql.Connection.TRANSACTION_SERIALIZABLE;
-
-  /**
-   * Register a TransactionCallback with this transaction.
-   */
-  public void register(TransactionCallback callback);
-
-  /**
-   * Return true if this transaction is read only.
-   */
-  public boolean isReadOnly();
-
-  /**
-   * Set whether this transaction should be readOnly.
-   */
-  public void setReadOnly(boolean readOnly);
-
-  /**
-   * Commit the transaction.
-   */
-  public void commit() throws RollbackException;
-
-  /**
-   * Rollback the transaction.
-   */
-  public void rollback() throws PersistenceException;
-
-  /**
-   * Rollback the transaction specifying a throwable that caused the rollback to
-   * occur.
-   * <p>
-   * If you are using transaction logging this will log the throwable in the
-   * transaction logs.
-   * </p>
-   */
-  public void rollback(Throwable e) throws PersistenceException;
-
-  /**
-   * If the transaction is active then perform rollback. Otherwise do nothing.
-   */
-  public void end() throws PersistenceException;
-
-  /**
-   * Return true if the transaction is active.
-   */
-  public boolean isActive();
-
-  /**
-   * 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
-   * rather than Ebean cascading detecting 'dirty/modified' beans etc.
-   * <p>
-   * This is useful if you can getting back entity beans from a layer of code
-   * (potentially remote) and you prefer to have exact control.
-   * </p>
-   * <p>
-   * This may also be useful if you are using jdbc batching with jdbc drivers
-   * that do not support getGeneratedKeys.
-   * </p>
-   */
-  public void setPersistCascade(boolean persistCascade);
-
-  /**
-   * Turn on or off statement batching. Statement batching can be transparent
-   * for drivers and databases that support getGeneratedKeys. Otherwise you may
-   * wish to specifically control when batching is used via this method.
-   * <p>
-   * Refer to <code>java.sql.PreparedStatement.addBatch();</code>
-   * <p>
-   * Note that you may also wish to use the setPersistCascade method to stop
-   * save and delete cascade behaviour. You may do this to have full control
-   * over the order of execution rather than the normal cascading fashion.
-   * </p>
-   * <p>
-   * Note that the <em>execution order</em> in batch mode may be different from
-   * non batch mode execution order. Also note that <em>insert behaviour</em>
-   * may be different depending on the JDBC driver and its support for
-   * getGeneratedKeys. That is, for JDBC drivers that do not support
-   * getGeneratedKeys you may not get back the generated IDs (used for inserting
-   * associated detail beans etc).
-   * </p>
-   * <p>
-   * Calls to save(), delete(), insert() and execute() all support batch
-   * processing. This includes normal beans, MapBean, CallableSql and UpdateSql.
-   * </p>
-   * <p>
-   * The flushing of the batched statements is automatic but you can call
-   * batchFlush when you like. Note that flushing occurs when a query is
-   * executed or when you mix UpdateSql and CallableSql with save and delete of
-   * beans.
-   * </p>
-   * <p>
-   * Example: batch processing executing every 3 rows
-   * </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);
-   * try {
-   *   for (int i = 0; i < da.length;) {
-   *     cs.setParameter(1, da[i]);
-   *     ebeanServer.execute(cs);
-   *   }
-   * 
-   *   // NB: commit implicitly flushes
-   *   txn.commit();
-   * 
-   * } finally {
-   *   txn.end();
-   * }
-   *
-   * }</pre>
-   * 
-   */
-  public void setBatchMode(boolean useBatch);
-
-  /**
-   * The JDBC batch mode to use for this transaction.
-   * <p>
-   * If this is NONE then JDBC batch can still be used for each request - save(), insert(), update() or delete()
-   * and this would be useful if the request cascades to detail beans.
-   * </p>
-   *
-   * @param persistBatchMode the batch mode to use for this transaction
-   *
-   * @see com.avaje.ebean.config.ServerConfig#setPersistBatch(com.avaje.ebean.config.PersistBatch)
-   */
-  public void setBatch(PersistBatch persistBatchMode);
-
-  /**
-   * Return the batch mode at the transaction level.
-   */
-  public PersistBatch getBatch();
-
-  /**
-   * Set the JDBC batch mode to use for a save() or delete() request.
-   * <p>
-   * This only takes effect when batch mode on the transaction has not already meant that
-   * JDBC batch mode is being used.
-   * </p>
-   * <p>
-   * This is useful when the single save() or delete() cascades. For example, inserting a 'master' cascades
-   * and inserts a collection of 'detail' beans. The detail beans can be inserted using JDBC batch.
-   * </p>
-   *
-   * @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)
-   */
-  public void setBatchOnCascade(PersistBatch batchOnCascadeMode);
-
-  /**
-   * Return the batch mode at the request level (for each save(), insert(), update() or delete()).
-   */
-  public PersistBatch getBatchOnCascade();
-
-  /**
-   * Specify the number of statements before a batch is flushed automatically.
-   */
-  public void setBatchSize(int batchSize);
-
-  /**
-   * Return the current batch size.
-   */
-  public int getBatchSize();
-
-  /**
-   * Specify if you want batched inserts to use getGeneratedKeys.
-   * <p>
-   * By default batched inserts will try to use getGeneratedKeys if it is
-   * supported by the underlying jdbc driver and database.
-   * </p>
-   * <p>
-   * You may want to turn getGeneratedKeys off when you are inserting a large
-   * number of objects and you don't care about getting back the ids.
-   * </p>
-   */
-  public void setBatchGetGeneratedKeys(boolean getGeneratedKeys);
-
-  /**
-   * By default when mixing UpdateSql (or CallableSql) with Beans the batch is
-   * automatically flushed when you change (between persisting beans and
-   * executing UpdateSql or CallableSql).
-   * <p>
-   * If you want to execute both WITHOUT having the batch automatically flush
-   * you need to call this with batchFlushOnMixed = false.
-   * </p>
-   * <p>
-   * Note that UpdateSql and CallableSql are ALWAYS executed first (before the
-   * beans are executed). This is because the UpdateSql and CallableSql have
-   * already been bound to their PreparedStatements. The beans on the other hand
-   * have a 2 step process (delayed binding).
-   * </p>
-   */
-  public void setBatchFlushOnMixed(boolean batchFlushOnMixed);
-
-  /**
-   * By default executing a query will automatically flush any batched
-   * statements (persisted beans, executed UpdateSql etc).
-   * <p>
-   * Calling this method with batchFlushOnQuery = false means that you can
-   * execute a query and the batch will not be automatically flushed.
-   * </p>
-   */
-  public void setBatchFlushOnQuery(boolean batchFlushOnQuery);
-
-  /**
-   * Return true if the batch (of persisted beans or executed UpdateSql etc)
-   * should be flushed prior to executing a query.
-   * <p>
-   * The default is for this to be true.
-   * </p>
-   */
-  public boolean isBatchFlushOnQuery();
-
-  /**
-   * The batch will be flushing automatically but you can use this to explicitly
-   * flush the batch if you like.
-   * <p>
-   * Flushing occurs automatically when:
-   * </p>
-   * <ul>
-   * <li>the batch size is reached</li>
-   * <li>A query is executed on the same transaction</li>
-   * <li>UpdateSql or CallableSql are mixed with bean save and delete</li>
-   * <li>Transaction commit occurs</li>
-   * </ul>
-   */
-  public void flushBatch() throws PersistenceException, OptimisticLockException;
-
-  /**
-   * Return the underlying Connection object.
-   * <p>
-   * Useful where a Developer wishes to use the JDBC API directly. Note that the
-   * commit() rollback() and end() methods on the Transaction should still be
-   * used. Calling these methods on the Connection would be a big no no unless
-   * you know what you are doing.
-   * </p>
-   * <p>
-   * Examples of when a developer may wish to use the connection directly are:
-   * Savepoints, advanced CLOB BLOB use and advanced stored procedure calls.
-   * </p>
-   */
-  public Connection getConnection();
-
-  /**
-   * Add table modification information to the TransactionEvent.
-   * <p>
-   * Use this in conjunction with getConnection() and raw JDBC.
-   * </p>
-   * <p>
-   * This effectively informs Ebean of the data that has been changed by the
-   * transaction and this information is normally automatically handled by Ebean
-   * when you save entity beans or use UpdateSql etc.
-   * </p>
-   * <p>
-   * If you use raw JDBC then you can use this method to inform Ebean for the
-   * tables that have been modified. Ebean uses this information to keep its
-   * caches in synch and maintain text indexes.
-   * </p>
-   */
-  public void addModification(String tableName, boolean inserts, boolean updates, boolean deletes);
-
-  /**
-   * 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}.
-   */
-  public void putUserObject(String name, Object value);
-
-  /**
-   * Get an object added with {@link #putUserObject(String, Object)}.
-   */
-  public Object getUserObject(String name);
-}
+package com.avaje.ebean;
+
+import com.avaje.ebean.config.PersistBatch;
+
+import javax.persistence.PersistenceException;
+import javax.persistence.RollbackException;
+import java.io.Closeable;
+import java.sql.Connection;
+
+/**
+ * The Transaction object. Typically representing a JDBC or JTA transaction.
+ */
+public interface Transaction extends Closeable {
+
+  /**
+   * Read Committed transaction isolation. Same as
+   * java.sql.Connection.TRANSACTION_READ_COMMITTED.
+   */
+  int READ_COMMITTED = java.sql.Connection.TRANSACTION_READ_COMMITTED;
+
+  /**
+   * Read Uncommitted transaction isolation. Same as
+   * java.sql.Connection.TRANSACTION_READ_UNCOMMITTED.
+   */
+  int READ_UNCOMMITTED = java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
+
+  /**
+   * Repeatable read transaction isolation. Same as
+   * java.sql.Connection.TRANSACTION_REPEATABLE_READ.
+   */
+  int REPEATABLE_READ = java.sql.Connection.TRANSACTION_REPEATABLE_READ;
+
+  /**
+   * Serializable transaction isolation. Same as
+   * java.sql.Connection.TRANSACTION_SERIALIZABLE.
+   */
+  int SERIALIZABLE = java.sql.Connection.TRANSACTION_SERIALIZABLE;
+
+  /**
+   * Register a TransactionCallback with this transaction.
+   */
+  void register(TransactionCallback callback);
+
+  /**
+   * Return true if this transaction is read only.
+   */
+  boolean isReadOnly();
+
+  /**
+   * Set whether this transaction should be readOnly.
+   */
+  void setReadOnly(boolean readOnly);
+
+  /**
+   * Commit the transaction.
+   */
+  void commit() throws RollbackException;
+
+  /**
+   * Rollback the transaction.
+   */
+  void rollback() throws PersistenceException;
+
+  /**
+   * Rollback the transaction specifying a throwable that caused the rollback to
+   * occur.
+   * <p>
+   * If you are using transaction logging this will log the throwable in the
+   * transaction logs.
+   * </p>
+   */
+  void rollback(Throwable e) throws PersistenceException;
+
+  /**
+   * If the transaction is active then perform rollback. Otherwise do nothing.
+   */
+  void end() throws PersistenceException;
+
+  /**
+   * Return true if the transaction is active.
+   */
+  boolean isActive();
+
+  /**
+   * 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
+   * rather than Ebean cascading detecting 'dirty/modified' beans etc.
+   * <p>
+   * This is useful if you can getting back entity beans from a layer of code
+   * (potentially remote) and you prefer to have exact control.
+   * </p>
+   * <p>
+   * This may also be useful if you are using jdbc batching with jdbc drivers
+   * that do not support getGeneratedKeys.
+   * </p>
+   */
+  void setPersistCascade(boolean persistCascade);
+
+  /**
+   * 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.
+   * </p>
+   */
+  void setUpdateAllLoadedProperties(boolean updateAllLoadedProperties);
+
+  /**
+   * Turn on or off statement batching. Statement batching can be transparent
+   * for drivers and databases that support getGeneratedKeys. Otherwise you may
+   * wish to specifically control when batching is used via this method.
+   * <p>
+   * Refer to <code>java.sql.PreparedStatement.addBatch();</code>
+   * <p>
+   * Note that you may also wish to use the setPersistCascade method to stop
+   * save and delete cascade behaviour. You may do this to have full control
+   * over the order of execution rather than the normal cascading fashion.
+   * </p>
+   * <p>
+   * Note that the <em>execution order</em> in batch mode may be different from
+   * non batch mode execution order. Also note that <em>insert behaviour</em>
+   * may be different depending on the JDBC driver and its support for
+   * getGeneratedKeys. That is, for JDBC drivers that do not support
+   * getGeneratedKeys you may not get back the generated IDs (used for inserting
+   * associated detail beans etc).
+   * </p>
+   * <p>
+   * Calls to save(), delete(), insert() and execute() all support batch
+   * processing. This includes normal beans, MapBean, CallableSql and UpdateSql.
+   * </p>
+   * <p>
+   * The flushing of the batched statements is automatic but you can call
+   * batchFlush when you like. Note that flushing occurs when a query is
+   * executed or when you mix UpdateSql and CallableSql with save and delete of
+   * beans.
+   * </p>
+   * <p>
+   * Example: batch processing executing every 3 rows
+   * </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);
+   * try {
+   *   for (int i = 0; i < da.length;) {
+   *     cs.setParameter(1, da[i]);
+   *     ebeanServer.execute(cs);
+   *   }
+   * 
+   *   // NB: commit implicitly flushes
+   *   txn.commit();
+   * 
+   * } finally {
+   *   txn.end();
+   * }
+   *
+   * }</pre>
+   * 
+   */
+  void setBatchMode(boolean useBatch);
+
+  /**
+   * The JDBC batch mode to use for this transaction.
+   * <p>
+   * If this is NONE then JDBC batch can still be used for each request - save(), insert(), update() or delete()
+   * and this would be useful if the request cascades to detail beans.
+   * </p>
+   *
+   * @param persistBatchMode the batch mode to use for this transaction
+   *
+   * @see com.avaje.ebean.config.ServerConfig#setPersistBatch(com.avaje.ebean.config.PersistBatch)
+   */
+  void setBatch(PersistBatch persistBatchMode);
+
+  /**
+   * Return the batch mode at the transaction level.
+   */
+  PersistBatch getBatch();
+
+  /**
+   * Set the JDBC batch mode to use for a save() or delete() request.
+   * <p>
+   * This only takes effect when batch mode on the transaction has not already meant that
+   * JDBC batch mode is being used.
+   * </p>
+   * <p>
+   * This is useful when the single save() or delete() cascades. For example, inserting a 'master' cascades
+   * and inserts a collection of 'detail' beans. The detail beans can be inserted using JDBC batch.
+   * </p>
+   *
+   * @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);
+
+  /**
+   * Return the batch mode at the request level (for each save(), insert(), update() or delete()).
+   */
+  PersistBatch getBatchOnCascade();
+
+  /**
+   * Specify the number of statements before a batch is flushed automatically.
+   */
+  void setBatchSize(int batchSize);
+
+  /**
+   * Return the current batch size.
+   */
+  int getBatchSize();
+
+  /**
+   * Specify if you want batched inserts to use getGeneratedKeys.
+   * <p>
+   * By default batched inserts will try to use getGeneratedKeys if it is
+   * supported by the underlying jdbc driver and database.
+   * </p>
+   * <p>
+   * You may want to turn getGeneratedKeys off when you are inserting a large
+   * number of objects and you don't care about getting back the ids.
+   * </p>
+   */
+  void setBatchGetGeneratedKeys(boolean getGeneratedKeys);
+
+  /**
+   * By default when mixing UpdateSql (or CallableSql) with Beans the batch is
+   * automatically flushed when you change (between persisting beans and
+   * executing UpdateSql or CallableSql).
+   * <p>
+   * If you want to execute both WITHOUT having the batch automatically flush
+   * you need to call this with batchFlushOnMixed = false.
+   * </p>
+   * <p>
+   * Note that UpdateSql and CallableSql are ALWAYS executed first (before the
+   * beans are executed). This is because the UpdateSql and CallableSql have
+   * already been bound to their PreparedStatements. The beans on the other hand
+   * have a 2 step process (delayed binding).
+   * </p>
+   */
+  void setBatchFlushOnMixed(boolean batchFlushOnMixed);
+
+  /**
+   * By default executing a query will automatically flush any batched
+   * statements (persisted beans, executed UpdateSql etc).
+   * <p>
+   * Calling this method with batchFlushOnQuery = false means that you can
+   * execute a query and the batch will not be automatically flushed.
+   * </p>
+   */
+  void setBatchFlushOnQuery(boolean batchFlushOnQuery);
+
+  /**
+   * Return true if the batch (of persisted beans or executed UpdateSql etc)
+   * should be flushed prior to executing a query.
+   * <p>
+   * The default is for this to be true.
+   * </p>
+   */
+  boolean isBatchFlushOnQuery();
+
+  /**
+   * The batch will be flushing automatically but you can use this to explicitly
+   * flush the batch if you like.
+   * <p>
+   * Flushing occurs automatically when:
+   * </p>
+   * <ul>
+   * <li>the batch size is reached</li>
+   * <li>A query is executed on the same transaction</li>
+   * <li>UpdateSql or CallableSql are mixed with bean save and delete</li>
+   * <li>Transaction commit occurs</li>
+   * </ul>
+   */
+  void flushBatch() throws PersistenceException;
+
+  /**
+   * Return the underlying Connection object.
+   * <p>
+   * Useful where a Developer wishes to use the JDBC API directly. Note that the
+   * commit() rollback() and end() methods on the Transaction should still be
+   * used. Calling these methods on the Connection would be a big no no unless
+   * you know what you are doing.
+   * </p>
+   * <p>
+   * Examples of when a developer may wish to use the connection directly are:
+   * Savepoints, advanced CLOB BLOB use and advanced stored procedure calls.
+   * </p>
+   */
+  Connection getConnection();
+
+  /**
+   * Add table modification information to the TransactionEvent.
+   * <p>
+   * Use this in conjunction with getConnection() and raw JDBC.
+   * </p>
+   * <p>
+   * This effectively informs Ebean of the data that has been changed by the
+   * transaction and this information is normally automatically handled by Ebean
+   * when you save entity beans or use UpdateSql etc.
+   * </p>
+   * <p>
+   * If you use raw JDBC then you can use this method to inform Ebean for the
+   * tables that have been modified. Ebean uses this information to keep its
+   * caches in synch and maintain text indexes.
+   * </p>
+   */
+  void addModification(String tableName, boolean inserts, boolean updates, boolean deletes);
+
+  /**
+   * 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}.
+   */
+  void putUserObject(String name, Object value);
+
+  /**
+   * Get an object added with {@link #putUserObject(String, Object)}.
+   */
+  Object getUserObject(String name);
+}

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

@@ -1,45 +1,45 @@
-package com.avaje.ebean;
-
-/**
- * Execute a TxCallable in a Transaction scope.
- * <p>
- * Use this with the {@link Ebean#execute(TxCallable)} method.
- * </p>
- * <p>
- * Note that this is basically the same as TxRunnable except that it returns an
- * Object (and you specify the return type via generics).
- * </p>
- * <p>
- * See also {@link TxRunnable}.
- * </p>
- * 
- * <pre class="code">
- * Ebean.execute(new TxCallable&lt;String&gt;() {
- *   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;);
- * 
- *     Ebean.save(u1);
- *     Ebean.save(u2);
- * 
- *     return u1.getEmail();
- *   }
- * });
- * </pre>
- * 
- * @see TxRunnable
- */
-public interface TxCallable<T> {
-
-  /**
-   * Execute the method within a transaction scope returning the result.
-   * <p>
-   * If you do not want to return a result you should look to use TxRunnable
-   * instead.
-   * </p>
-   */
-  public T call();
-}
+package com.avaje.ebean;
+
+/**
+ * Execute a TxCallable in a Transaction scope.
+ * <p>
+ * Use this with the {@link Ebean#execute(TxCallable)} method.
+ * </p>
+ * <p>
+ * Note that this is basically the same as TxRunnable except that it returns an
+ * Object (and you specify the return type via generics).
+ * </p>
+ * <p>
+ * See also {@link TxRunnable}.
+ * </p>
+ * 
+ * <pre class="code">
+ * Ebean.execute(new TxCallable&lt;String&gt;() {
+ *   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;);
+ * 
+ *     Ebean.save(u1);
+ *     Ebean.save(u2);
+ * 
+ *     return u1.getEmail();
+ *   }
+ * });
+ * </pre>
+ * 
+ * @see TxRunnable
+ */
+public interface TxCallable<T> {
+
+  /**
+   * Execute the method within a transaction scope returning the result.
+   * <p>
+   * If you do not want to return a result you should look to use TxRunnable
+   * instead.
+   * </p>
+   */
+  T call();
+}

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

@@ -1,100 +1,100 @@
-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;
-
-  private 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);
-    }
-
-  }
-}
+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

@@ -1,39 +1,39 @@
-package com.avaje.ebean;
-
-/**
- * Execute a TxRunnable in a Transaction scope.
- * <p>
- * Use this with the {@link Ebean#execute(TxRunnable)} method.
- * </p>
- * <p>
- * See also {@link TxCallable}.
- * </p>
- * 
- * <pre class="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;);
- * 
- *     Ebean.save(u1);
- *     Ebean.save(u2);
- *   }
- * });
- * </pre>
- * 
- * @see TxCallable
- */
-public interface TxRunnable {
-
-  /**
-   * Run the method in a transaction sope.
-   */
-  public void run();
-}
+package com.avaje.ebean;
+
+/**
+ * Execute a TxRunnable in a Transaction scope.
+ * <p>
+ * Use this with the {@link Ebean#execute(TxRunnable)} method.
+ * </p>
+ * <p>
+ * See also {@link TxCallable}.
+ * </p>
+ * 
+ * <pre class="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;);
+ * 
+ *     Ebean.save(u1);
+ *     Ebean.save(u2);
+ *   }
+ * });
+ * </pre>
+ * 
+ * @see TxCallable
+ */
+public interface TxRunnable {
+
+  /**
+   * Run the method in a transaction sope.
+   */
+  void run();
+}

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

@@ -46,5 +46,5 @@ public enum TxType {
    * If there is an existing transaction throws an Exception. Method runs
    * without a transaction.
    */
-  NEVER;
+  NEVER
 }

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

@@ -54,7 +54,7 @@ public interface Update<T> {
   /**
    * Return the name if it is a named update.
    */
-  public String getName();
+  String getName();
 
   /**
    * Set this to false if you do not want the cache to invalidate related
@@ -64,7 +64,7 @@ public interface Update<T> {
    * parts of the "L2" server cache.
    * </p>
    */
-  public Update<T> setNotifyCache(boolean notifyCache);
+  Update<T> setNotifyCache(boolean notifyCache);
 
   /**
    * Set a timeout for statement execution.
@@ -77,12 +77,12 @@ public interface Update<T> {
    * @param secs
    *          the timeout in seconds. Zero implies unlimited.
    */
-  public Update<T> setTimeout(int secs);
+  Update<T> setTimeout(int secs);
 
   /**
    * Execute the statement returning the number of rows modified.
    */
-  public int execute();
+  int execute();
 
   /**
    * Set an ordered bind parameter.
@@ -98,7 +98,7 @@ public interface Update<T> {
    * @param value
    *          the parameter value to bind.
    */
-  public Update<T> set(int position, Object value);
+  Update<T> set(int position, Object value);
 
   /**
    * Set and ordered bind parameter (same as bind).
@@ -108,7 +108,7 @@ public interface Update<T> {
    * @param value
    *          the parameter value to bind.
    */
-  public Update<T> setParameter(int position, Object value);
+  Update<T> setParameter(int position, Object value);
 
   /**
    * Set an ordered parameter that is null. The JDBC type of the null must be
@@ -117,12 +117,12 @@ public interface Update<T> {
    * position starts at value 1 (not 0) to be consistent with PreparedStatement.
    * </p>
    */
-  public Update<T> setNull(int position, int jdbcType);
+  Update<T> setNull(int position, int jdbcType);
 
   /**
    * Set an ordered parameter that is null (same as bind).
    */
-  public Update<T> setNullParameter(int position, int jdbcType);
+  Update<T> setNullParameter(int position, int jdbcType);
 
   /**
    * Set a named parameter. Named parameters have a colon to prefix the name.
@@ -135,12 +135,12 @@ public interface Update<T> {
    * @param value
    *          the parameter value.
    */
-  public Update<T> set(String name, Object value);
+  Update<T> set(String name, Object value);
 
   /**
    * Bind a named parameter (same as bind).
    */
-  public Update<T> setParameter(String name, Object param);
+  Update<T> setParameter(String name, Object param);
 
   /**
    * Set a named parameter that is null. The JDBC type of the null must be
@@ -154,16 +154,16 @@ public interface Update<T> {
    * @param jdbcType
    *          the type of the property being bound.
    */
-  public Update<T> setNull(String name, int jdbcType);
+  Update<T> setNull(String name, int jdbcType);
 
   /**
    * Bind a named parameter that is null (same as bind).
    */
-  public Update<T> setNullParameter(String name, int jdbcType);
+  Update<T> setNullParameter(String name, int jdbcType);
 
   /**
    * Return the sql that is actually executed.
    */
-  public String getGeneratedSql();
+  String getGeneratedSql();
 
 }

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

@@ -1,50 +1,57 @@
-package com.avaje.ebean;
-
-/**
- * Holds two values as the result of a difference comparison.
- */
-public class ValuePair {
-
-  private final Object newValue;
-
-  private final Object oldValue;
-
-  public ValuePair(Object newValue, Object oldValue) {
-    this.newValue = newValue;
-    this.oldValue = oldValue;
-  }
-
-  /**
-   * Return the new value.
-   */
-  public Object getNewValue() {
-    return newValue;
-  }
-  
-  /**
-   * Return the old value.
-   */
-  public Object getOldValue() {
-    return oldValue;
-  }
-  
-  /**
-   * Return the new value.
-   */
-  @Deprecated
-  public Object getValue1() {
-    return newValue;
-  }
-
-  /**
-   * Return the old value.
-   */
-  @Deprecated
-  public Object getValue2() {
-    return oldValue;
-  }
-
-  public String toString() {
-    return newValue + "," + oldValue;
-  }
-}
+package com.avaje.ebean;
+
+/**
+ * Holds two values as the result of a difference comparison.
+ */
+public class ValuePair {
+
+  protected Object newValue;
+
+  protected Object oldValue;
+
+  /**
+   * Default constructor for JSON tools.
+   */
+  public ValuePair() {
+  }
+
+  /**
+   * Construct with the pair of new and old values.
+   */
+  public ValuePair(Object newValue, Object oldValue) {
+    this.newValue = newValue;
+    this.oldValue = oldValue;
+  }
+
+  /**
+   * Return the new value.
+   */
+  public Object getNewValue() {
+    return newValue;
+  }
+  
+  /**
+   * Return the old value.
+   */
+  public Object getOldValue() {
+    return oldValue;
+  }
+
+  /**
+   * Set the new value.
+   */
+  public void setNewValue(Object newValue) {
+    this.newValue = newValue;
+  }
+
+  /**
+   * Set the old value.
+   */
+  public void setOldValue(Object oldValue) {
+    this.oldValue = oldValue;
+  }
+
+  public String toString() {
+    return newValue + "," + oldValue;
+  }
+}

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

@@ -0,0 +1,101 @@
+package com.avaje.ebean;
+
+import java.sql.Timestamp;
+import java.util.Map;
+
+/**
+ * Wraps a version of a @History bean.
+ */
+public class Version<T> {
+
+  /**
+   * The version of the bean.
+   */
+  protected T bean;
+
+  /**
+   * The effective start date time of this version.
+   */
+  protected Timestamp start;
+
+  /**
+   * The effective end date time of this version.
+   */
+  protected Timestamp end;
+
+  /**
+   * The map of changed properties.
+   */
+  protected Map<String, ValuePair> diff;
+
+  /**
+   * Construct with bean and an effective date time range.
+   */
+  public Version(T bean, Timestamp start, Timestamp end) {
+    this.bean = bean;
+    this.start = start;
+    this.end = end;
+  }
+
+  /**
+   * Default constructor - useful for JSON tools such as Jackson.
+   */
+  public Version() {
+  }
+
+  /**
+   * Return the bean instance for this version.
+   */
+  public T getBean() {
+    return bean;
+  }
+
+  /**
+   * Set the bean instance for this version.
+   */
+  public void setBean(T bean) {
+    this.bean = bean;
+  }
+
+  /**
+   * Return the effective start date time of this version.
+   */
+  public Timestamp getStart() {
+    return start;
+  }
+
+  /**
+   * Set the effective start date time of this version.
+   */
+  public void setStart(Timestamp start) {
+    this.start = start;
+  }
+
+  /**
+   * Return the effective end date time of this version.
+   */
+  public Timestamp getEnd() {
+    return end;
+  }
+
+  /**
+   * Set the effective end date time of this version.
+   */
+  public void setEnd(Timestamp end) {
+    this.end = end;
+  }
+
+  /**
+   * Set the map of differences from this bean to the prior version.
+   */
+  public void setDiff(Map<String, ValuePair> diff) {
+    this.diff = diff;
+  }
+
+  /**
+   * Return the map of differences from this bean to the prior version.
+   */
+  public Map<String, ValuePair> getDiff() {
+    return diff;
+  }
+}

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

@@ -1,58 +1,58 @@
-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 "";
-
-};
+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,47 +1,55 @@
-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;
-};
+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

@@ -0,0 +1,34 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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

@@ -0,0 +1,22 @@
+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/CreatedTimestamp.java

@@ -1,31 +1,38 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * For a timestamp property that is set to the datetime when the entity is
- * created/inserted.
- * <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>
- * 
- * <pre class="code">
- * &#064;Column(insertable = false, updateable = false)
- * Timestamp cretimestamp;
- * </pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface CreatedTimestamp {
-
-};
+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/DbEnumType.java

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,32 @@
+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

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

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

@@ -0,0 +1,20 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a 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

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a 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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,20 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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 +1,31 @@
-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 "";
-
-};
+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 +1,24 @@
-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;
-};
+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/EnumMapping.java

@@ -1,90 +1,90 @@
-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;
-};
+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,46 +1,48 @@
-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 class="code">
- * public enum Status {
- *   &#064;EnumValue(&quot;N&quot;)
- *   NEW,
- * 
- *   &#064;EnumValue(&quot;A&quot;)
- *   ACTIVE,
- * 
- *   &#064;EnumValue(&quot;I&quot;)
- *   INACTIVE,
- * }
- * 
- * </pre>
- * <p>
- * This is an alternative to using the JPA standard approach or Ebean's
- * {@link EnumMapping} 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();
-};
+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

@@ -12,17 +12,17 @@ import java.lang.annotation.Target;
 @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}.
-     */
-    public boolean serialize() default true;
+  /**
+   * 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}.
-     */
-    public boolean deserialize() 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,103 +1,106 @@
-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;
-
-/**
- * Assign to a property to be based on a SQL formula.
- * <p>
- * This is typically a SQL Literal value, SQL case statement, SQL function or
- * similar.
- * </p>
- * <p>
- * Any property based on a formula becomes a read only property.
- * </p>
- * <p>
- * You may also put use the Transient annotation with the Formula annotation.
- * The effect of the Transient annotation in this case is that the formula will
- * <b>NOT</b> be included in queries by default - you have to explicitly include
- * it via {@link Query#select(String)} or {@link Query#fetch(String, String, com.avaje.ebean.FetchConfig)}.
- * 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
- * // ... 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;)
- * Double totalAmount;
- * 
- * </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 class="code">
- * // find by Id
- * Order o1 = Ebean.find(Order.class)
- *     .select(&quot;id, totalAmount&quot;)
- *     .setId(1).findUnique();
- * 
- * // find list ... using totalAmount in the where clause
- * List&lt;Order&gt; list = Ebean.find(Order.class)
- *     .select(&quot;id, totalAmount&quot;)
- *     .where()
- *     .eq(&quot;status&quot;, Order.Status.NEW)
- *     .gt(&quot;totalAmount&quot;, 10)
- *     .findList();
- * 
- * // as a join from customer
- * List&lt;Customer&gt; l0 = Ebean.find(Customer.class)
- *     .select(&quot;id, name&quot;)
- *     .join(&quot;orders&quot;, &quot;status, totalAmount&quot;)
- *     .where()
- *     .gt(&quot;id&quot;, 0)
- *     .gt(&quot;orders.totalAmount&quot;, 10)
- *     .findList();
- * 
- * </pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Formula {
-
-  /**
-   * The SQL to be used in the SELECT part of the SQL to populate a property.
-   */
-  String select();
-
-  /**
-   * OPTIONAL - the SQL to be used in the JOIN part of the SQL to support the
-   * formula.
-   * <p>
-   * This is commonly used to join a 'dynamic view' to support aggregation such
-   * as count, sum etc.
-   * </p>
-   * <p>
-   * The join string should start with either "left outer 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
-   * bean).
-   * </p>
-   * <p>
-   * The example below is used to support a total count of topics created by a
-   * user.
-   * </p>
-   * 
-   * <pre class="code">
-   * join (select user_id, count(*) as topic_count from f_topic group by user_id) as _tc on _tc.user_id = ${ta}.id
-   * </pre>
-   */
-  String join() default "";
-
-};
+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;
+
+/**
+ * Assign to a property to be based on a SQL formula.
+ * <p>
+ * This is typically a SQL Literal value, SQL case statement, SQL function or
+ * similar.
+ * </p>
+ * <p>
+ * Any property based on a formula becomes a read only property.
+ * </p>
+ * <p>
+ * You may also put use the Transient annotation with the Formula annotation.
+ * The effect of the Transient annotation in this case is that the formula will
+ * <b>NOT</b> be included in queries by default - you have to explicitly include
+ * it via {@link Query#select(String)} or {@link Query#fetch(String, String, com.avaje.ebean.FetchConfig)}.
+ * 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
+ * // ... 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;)
+ * Double totalAmount;
+ * 
+ * </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")
+ *     .where()
+ *     .eq("status", Order.Status.NEW)
+ *     .gt("totalAmount", 10)
+ *     .findList();
+ * 
+ * // as a join from customer
+ * List<Customer> l0 = Ebean.find(Customer.class)
+ *     .select("id, name")
+ *     .fetch("orders", "status, totalAmount")
+ *     .where()
+ *     .gt("id", 0)
+ *     .gt("orders.totalAmount", 10)
+ *     .findList();
+ * 
+ * }</pre>
+ */
+@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Formula {
+
+  /**
+   * The SQL to be used in the SELECT part of the SQL to populate a property.
+   */
+  String select();
+
+  /**
+   * OPTIONAL - the SQL to be used in the JOIN part of the SQL to support the
+   * formula.
+   * <p>
+   * This is commonly used to join a 'dynamic view' to support aggregation such
+   * as count, sum etc.
+   * </p>
+   * <p>
+   * The join string should start with either "left outer 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
+   * bean).
+   * </p>
+   * <p>
+   * The example below is used to support a total count of topics created by a
+   * user.
+   * </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
+   *
+   * }</pre>
+   */
+  String join() default "";
+
+}

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

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks 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

@@ -0,0 +1,25 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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

@@ -10,15 +10,24 @@ import java.lang.annotation.Target;
  *
  * @author rvbiljouw
  */
-@Target({ElementType.FIELD})
+@Target({ElementType.TYPE, ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Index {
 
-    /**
-     * Name of the index
-     *
-     * @return index name
-     */
-    String value() default "";
+  /**
+   * 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

@@ -0,0 +1,32 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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 +1,37 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 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;
-
-};
+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 +1,20 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 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();
-
-};
+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 +1,34 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 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;
-
-};
+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

@@ -6,10 +6,10 @@ 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)
-@Target(ElementType.FIELD)
-public @interface ColumnHstore {
+public @interface ReadAudit {
 
-}
+}

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

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

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

@@ -1,24 +1,24 @@
-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 };
-
-};
+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 +1,298 @@
-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;
-};
+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

@@ -125,4 +125,4 @@ public @interface Transactional {
    */
   Class<? extends Throwable>[] noRollbackFor() default {};
 
-};
+}

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

@@ -1,34 +1,34 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 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;
-
-};
+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,16 +1,20 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * For a timestamp property that is set to the datetime when the entity was last
- * updated.
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface UpdatedTimestamp {
-
-};
+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

@@ -0,0 +1,38 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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,51 +1,54 @@
-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;
-
-/**
- * Add an Literal to add to the where clause when a many property (List, Set or
- * Map) is loaded or refreshed.
- * 
- * <pre class="code">
- * // on a OneToMany property...
- * 
- * &#064;OneToMany
- * &#064;Where(clause = &quot;deleted='y'&quot;)
- * List&lt;Topic&gt; 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 class="code">
- * // ... including the ${ta} table alias placeholder...
- * 
- * &#064;OneToMany
- * &#064;Where(clause = &quot;${ta}.deleted='y'&quot;)
- * List&lt;Topic&gt; 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 })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Where {
-
-  /**
-   * The clause added to the lazy load query.
-   * <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>
-   */
-  String clause();
-
-};
+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;
+
+/**
+ * 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 })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Where {
+
+  /**
+   * The clause added to the lazy load query.
+   * <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>
+   */
+  String clause();
+
+}

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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,29 @@
+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/bean/BeanCollection.java

@@ -1,193 +1,211 @@
-package com.avaje.ebean.bean;
-
-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>
- * This also includes the ability to listen for additions and removals to or
- * from the Map Set or List. The purpose of gathering the additions and removals
- * is to support persisting ManyToMany objects. The additions and removals
- * become inserts and deletes from the intersection table.
- * </p>
- * <p>
- * Technically this is <em>NOT</em> an extension of
- * <em>java.util.Collection</em>. The reason being that java.util.Map is not a
- * Collection. I realise this makes this name confusing so I apologise for that.
- * </p>
- */
-public interface BeanCollection<E> extends Serializable {
-
-  public enum ModifyListenMode {
-    /** The common mode */
-    NONE,
-    /** Mode used for PrivateOwned */
-    REMOVALS,
-    /** Mode used for ManyToMany relationships */
-    ALL
-  }
-
-  /**
-   * Reset the collection back to an empty state ready for reloading.
-   * <p>
-   * This is done as part of bean refresh.
-   */
-  public 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.
-   */
-  public boolean isEmptyAndUntouched();
-
-  /**
-   * Return the bean that owns this collection.
-   */
-  public EntityBean getOwnerBean();
-
-  /**
-   * Return the bean property name this collection represents.
-   */
-  public String getPropertyName();
-
-  /**
-   * Check after the lazy load that the underlying collection is not null
-   * (handle case where join to many not outer).
-   * <p>
-   * That is, if the collection was not loaded due to filterMany predicates etc
-   * then make sure the collection is set to empty.
-   * </p>
-   */
-  public boolean checkEmptyLazyLoad();
-
-  /**
-   * Return the filter (if any) that was used in building this collection.
-   * <p>
-   * This is so that the filter can be applied on refresh.
-   * </p>
-   */
-  public ExpressionList<?> getFilterMany();
-
-  /**
-   * Set the filter that was used in building this collection.
-   */
-  public void setFilterMany(ExpressionList<?> filterMany);
-
-  /**
-   * Set a listener to be notified when the BeanCollection is first touched.
-   */
-  public void setBeanCollectionTouched(BeanCollectionTouched notify);
-
-  /**
-   * Set the loader that will be used to lazy/query load this collection.
-   */
-  public void setLoader(int beanLoaderIndex, BeanCollectionLoader beanLoader);
-
-  /**
-   * Set to true if you want the BeanCollection to be treated as read only. This
-   * means no elements can be added or removed etc.
-   */
-  public void setReadOnly(boolean readOnly);
-
-  /**
-   * Return true if the collection should be treated as readOnly and no elements
-   * can be added or removed etc.
-   */
-  public boolean isReadOnly();
-
-  /**
-   * Add the bean to the collection.
-   * <p>
-   * This is disallowed for BeanMap.
-   * </p>
-   */
-  public void internalAdd(Object bean);
-
-  /**
-   * Return the number of elements in the List Set or Map.
-   */
-  public int size();
-
-  /**
-   * Return true if the List Set or Map is empty.
-   */
-  public boolean isEmpty();
-
-  /**
-   * Returns the underlying collection of beans from the Set, Map or List.
-   */
-  public Collection<E> getActualDetails();
-
-  /**
-   * Returns the underlying entries so for Maps this is a collection of
-   * Map.Entry.
-   * <p>
-   * For maps this returns the entrySet as we need the keys of the map.
-   * </p>
-   */
-  public Collection<?> getActualEntries();
-
-  /**
-   * return true if there are real rows held. Return false is this is using
-   * Deferred fetch to lazy load the rows and the rows have not yet been
-   * fetched.
-   */
-  public boolean isPopulated();
-
-  /**
-   * Return true if this is a reference (lazy loading) bean collection. This is
-   * the same as !isPopulated();
-   */
-  public boolean isReference();
-
-  /**
-   * Set modify listening on or off. This is used to keep track of objects that
-   * have been added to or removed from the list set or map.
-   * <p>
-   * This is required only for ManyToMany collections. The additions and
-   * deletions are used to insert or delete entries from the intersection table.
-   * Otherwise modifyListening is false.
-   * </p>
-   */
-  public void setModifyListening(ModifyListenMode modifyListenMode);
-
-  /**
-   * Add an object to the additions list.
-   * <p>
-   * This will potentially end up as an insert into a intersection table for a
-   * ManyToMany.
-   * </p>
-   */
-  public void modifyAddition(E bean);
-
-  /**
-   * Add an object to the deletions list.
-   * <p>
-   * This will potentially end up as an delete from an intersection table for a
-   * ManyToMany.
-   * </p>
-   */
-  public void modifyRemoval(Object bean);
-
-  /**
-   * Return the list of objects added to the list set or map. These will used to
-   * insert rows into the intersection table of a ManyToMany.
-   */
-  public Set<E> getModifyAdditions();
-
-  /**
-   * Return the list of objects removed from the list set or map. These will
-   * used to delete rows from the intersection table of a ManyToMany.
-   */
-  public Set<E> getModifyRemovals();
-
-  /**
-   * Reset the set of additions and deletions. This is called after the
-   * additions and removals have been processed.
-   */
-  public void modifyReset();
-}
+package com.avaje.ebean.bean;
+
+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>
+ * This also includes the ability to listen for additions and removals to or
+ * from the Map Set or List. The purpose of gathering the additions and removals
+ * is to support persisting ManyToMany objects. The additions and removals
+ * become inserts and deletes from the intersection table.
+ * </p>
+ * <p>
+ * Technically this is <em>NOT</em> an extension of
+ * <em>java.util.Collection</em>. The reason being that java.util.Map is not a
+ * Collection. I realise this makes this name confusing so I apologise for that.
+ * </p>
+ */
+public interface BeanCollection<E> extends Serializable {
+
+  enum ModifyListenMode {
+    /** The common mode */
+    NONE,
+    /** Mode used for PrivateOwned */
+    REMOVALS,
+    /** Mode used for ManyToMany relationships */
+    ALL
+  }
+
+  /**
+   * Add a bean to the list/set with modifyListen notification.
+   */
+  void addBean(E bean);
+
+  /**
+   * Remove a bean to the list/set with modifyListen notification.
+   */
+  void removeBean(E bean);
+
+  /**
+   * Reset the collection back to an empty state ready for reloading.
+   * <p>
+   * This is done as part of bean refresh.
+   */
+  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.
+   */
+  boolean isEmptyAndUntouched();
+
+  /**
+   * Return the bean that owns this collection.
+   */
+  EntityBean getOwnerBean();
+
+  /**
+   * Return the bean property name this collection represents.
+   */
+  String getPropertyName();
+
+  /**
+   * Check after the lazy load that the underlying collection is not null
+   * (handle case where join to many not outer).
+   * <p>
+   * That is, if the collection was not loaded due to filterMany predicates etc
+   * then make sure the collection is set to empty.
+   * </p>
+   */
+  boolean checkEmptyLazyLoad();
+
+  /**
+   * Return the filter (if any) that was used in building this collection.
+   * <p>
+   * This is so that the filter can be applied on refresh.
+   * </p>
+   */
+  ExpressionList<?> getFilterMany();
+
+  /**
+   * Set the filter that was used in building this collection.
+   */
+  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.
+   */
+  boolean isRegisteredWithLoadContext();
+
+  /**
+   * Set the loader that will be used to lazy/query load this collection.
+   * <p>
+   * This is effectively the batch loading context this collection is registered with.
+   * </p>
+   */
+  void setLoader(BeanCollectionLoader beanLoader);
+
+  /**
+   * Set to true if you want the BeanCollection to be treated as read only. This
+   * means no elements can be added or removed etc.
+   */
+  void setReadOnly(boolean readOnly);
+
+  /**
+   * Return true if the collection should be treated as readOnly and no elements
+   * can be added or removed etc.
+   */
+  boolean isReadOnly();
+
+  /**
+   * Add the bean to the collection.
+   * <p>
+   * This is disallowed for BeanMap.
+   * </p>
+   */
+  void internalAdd(Object bean);
+
+  /**
+   * Return the number of elements in the List Set or Map.
+   */
+  int size();
+
+  /**
+   * Return true if the List Set or Map is empty.
+   */
+  boolean isEmpty();
+
+  /**
+   * Returns the underlying collection of beans from the Set, Map or List.
+   */
+  Collection<E> getActualDetails();
+
+  /**
+   * Returns the underlying entries so for Maps this is a collection of
+   * Map.Entry.
+   * <p>
+   * For maps this returns the entrySet as we need the keys of the map.
+   * </p>
+   */
+  Collection<?> getActualEntries();
+
+  /**
+   * return true if there are real rows held. Return false is this is using
+   * Deferred fetch to lazy load the rows and the rows have not yet been
+   * fetched.
+   */
+  boolean isPopulated();
+
+  /**
+   * Return true if this is a reference (lazy loading) bean collection. This is
+   * the same as !isPopulated();
+   */
+  boolean isReference();
+
+  /**
+   * Set modify listening on or off. This is used to keep track of objects that
+   * have been added to or removed from the list set or map.
+   * <p>
+   * This is required only for ManyToMany collections. The additions and
+   * deletions are used to insert or delete entries from the intersection table.
+   * Otherwise modifyListening is false.
+   * </p>
+   */
+  void setModifyListening(ModifyListenMode modifyListenMode);
+
+  /**
+   * Add an object to the additions list.
+   * <p>
+   * This will potentially end up as an insert into a intersection table for a
+   * ManyToMany.
+   * </p>
+   */
+  void modifyAddition(E bean);
+
+  /**
+   * Add an object to the deletions list.
+   * <p>
+   * This will potentially end up as an delete from an intersection table for a
+   * ManyToMany.
+   * </p>
+   */
+  void modifyRemoval(Object bean);
+
+  /**
+   * Return the list of objects added to the list set or map. These will used to
+   * insert rows into the intersection table of a ManyToMany.
+   */
+  Set<E> getModifyAdditions();
+
+  /**
+   * Return the list of objects removed from the list set or map. These will
+   * used to delete rows from the intersection table of a ManyToMany.
+   */
+  Set<E> getModifyRemovals();
+
+  /**
+   * Reset the set of additions and deletions. This is called after the
+   * additions and removals have been processed.
+   */
+  void modifyReset();
+}

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

@@ -1,16 +1,16 @@
-package com.avaje.ebean.bean;
-
-/**
- * Interface to define the addition of a bean to the underlying collection.
- * <p>
- * For maps this takes into account the map key. For List and Set this simply
- * adds the bean to the underlying list or set.
- * </p>
- */
-public interface BeanCollectionAdd {
-
-  /**
-   * Add a loaded bean to the collection.
-   */
-  public void addBean(EntityBean bean);
-}
+package com.avaje.ebean.bean;
+
+/**
+ * Interface to define the addition of a bean to the underlying collection.
+ * <p>
+ * For maps this takes into account the map key. For List and Set this simply
+ * adds the bean to the underlying list or set.
+ * </p>
+ */
+public interface BeanCollectionAdd {
+
+  /**
+   * Add a loaded bean to the collection.
+   */
+  void addEntityBean(EntityBean bean);
+}

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

@@ -1,21 +1,21 @@
-package com.avaje.ebean.bean;
-
-/**
- * Loads a entity bean collection.
- * <p>
- * Typically invokes lazy loading for a single or batch of collections.
- * </p>
- */
-public interface BeanCollectionLoader {
-
-  /**
-   * Return the name of the associated EbeanServer.
-   */
-  public String getName();
-
-  /**
-   * Invoke the lazy loading for this bean collection.
-   */
-  public void loadMany(BeanCollection<?> collection, boolean onlyIds);
-
-}
+package com.avaje.ebean.bean;
+
+/**
+ * Loads a entity bean collection.
+ * <p>
+ * Typically invokes lazy loading for a single or batch of collections.
+ * </p>
+ */
+public interface BeanCollectionLoader {
+
+  /**
+   * Return the name of the associated EbeanServer.
+   */
+  String getName();
+
+  /**
+   * Invoke the lazy loading for this bean collection.
+   */
+  void loadMany(BeanCollection<?> collection, boolean onlyIds);
+
+}

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

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

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

@@ -1,21 +1,21 @@
-package com.avaje.ebean.bean;
-
-/**
- * Loads a entity bean.
- * <p>
- * Typically invokes lazy loading for a single or batch of entity beans.
- * </p>
- */
-public interface BeanLoader {
-
-  /**
-   * Return the name of the associated EbeanServer.
-   */
-  public String getName();
-
-  /**
-   * Invoke the lazy loading for this bean.
-   */
-  public void loadBean(EntityBeanIntercept ebi);
-
-}
+package com.avaje.ebean.bean;
+
+/**
+ * Loads a entity bean.
+ * <p>
+ * Typically invokes lazy loading for a single or batch of entity beans.
+ * </p>
+ */
+public interface BeanLoader {
+
+  /**
+   * Return the name of the associated EbeanServer.
+   */
+  String getName();
+
+  /**
+   * Invoke the lazy loading for this bean.
+   */
+  void loadBean(EntityBeanIntercept ebi);
+
+}

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

@@ -1,118 +1,125 @@
-package com.avaje.ebean.bean;
-
-import java.io.Serializable;
-import java.util.Arrays;
-
-/**
- * Represent the call stack (stack trace elements).
- * <p>
- * Used with a query to identify a CallStackQuery for AutoFetch automatic query
- * tuning.
- * </p>
- * <p>
- * This is used so that a single query called from different methods can be
- * tuned for each different call stack.
- * </p>
- * <p>
- * Note the call stack is trimmed to remove the common ebean internal elements.
- * </p>
- */
-public final class CallStack implements Serializable {
-
-  private static final long serialVersionUID = -8590644046907438579L;
-
-  private final String zeroHash;
-  private final String pathHash;
-
-  private final StackTraceElement[] callStack;
-
-  public CallStack(StackTraceElement[] callStack) {
-    this.callStack = callStack;
-    this.zeroHash = enc(callStack[0].hashCode());
-    int hc = 0;
-    for (int i = 1; i < callStack.length; i++) {
-      hc = 31 * hc + callStack[i].hashCode();
-    }
-    this.pathHash = enc(hc);
-  }
-  
-  public int hashCode() {
-    int hc = 0;
-    for (int i = 0; i < callStack.length; i++) {
-      hc = 31 * hc + callStack[i].hashCode();
-    }
-    return hc;
-  }
-  
-  public boolean equals(Object obj) {
-    if (obj == this) {
-      return true;
-    }
-    if (!(obj instanceof CallStack)) {
-      return false;
-    }
-    CallStack e = (CallStack) obj;
-    return Arrays.equals(callStack, e.callStack);
-  }
-
-  /**
-   * Return the first element of the call stack.
-   */
-  public StackTraceElement getFirstStackTraceElement() {
-    return callStack[0];
-  }
-
-  /**
-   * Return the call stack.
-   */
-  public StackTraceElement[] getCallStack() {
-    return callStack;
-  }
-
-  /**
-   * Return the hash for the first stack element.
-   */
-  public String getZeroHash() {
-    return zeroHash;
-  }
-
-  /**
-   * Return the hash for the stack elements (excluding first stack element).
-   */
-  public String getPathHash() {
-    return pathHash;
-  }
-
-  public String toString() {
-    return zeroHash + ":" + pathHash + ":" + callStack[0];
-  }
-
-  public String getOriginKey(int queryHash) {
-    return zeroHash + "." + enc(queryHash) + "." + pathHash;
-  }
-
-  private static final int radix = 1 << 6;
-  private static final int mask = radix - 1;
-
-  /**
-   * Convert the integer to unsigned base 64.
-   */
-  public static String enc(int i) {
-    char[] buf = new char[32];
-    int charPos = 32;
-    do {
-      buf[--charPos] = intToBase64[i & mask];
-      i >>>= 6;
-    } while (i != 0);
-
-    return new String(buf, charPos, (32 - charPos));
-  }
-
-  private static final char intToBase64[] = {
-      'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-      'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-      'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-      'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'
-  };
-}
+package com.avaje.ebean.bean;
+
+import java.io.Serializable;
+import java.util.Arrays;
+
+/**
+ * Represent the call stack (stack trace elements).
+ * <p>
+ * Used with a query to identify a CallStackQuery for AutoTune automatic query
+ * tuning.
+ * </p>
+ * <p>
+ * This is used so that a single query called from different methods can be
+ * tuned for each different call stack.
+ * </p>
+ * <p>
+ * Note the call stack is trimmed to remove the common ebean internal elements.
+ * </p>
+ */
+public final class CallStack implements Serializable {
+
+  private static final long serialVersionUID = -8590644046907438579L;
+
+  private final String zeroHash;
+  private final String pathHash;
+
+  private final StackTraceElement[] callStack;
+
+  public CallStack(StackTraceElement[] callStack, int zeroHash, int pathHash) {
+    this.callStack = callStack;
+    this.zeroHash = enc(zeroHash);
+    this.pathHash = enc(pathHash);
+  }
+
+  public int hashCode() {
+    int hc = 0;
+    for (int i = 0; i < callStack.length; i++) {
+      hc = 31 * hc + callStack[i].hashCode();
+    }
+    return hc;
+  }
+  
+  public boolean equals(Object obj) {
+    if (obj == this) {
+      return true;
+    }
+    if (!(obj instanceof CallStack)) {
+      return false;
+    }
+    CallStack e = (CallStack) obj;
+    return Arrays.equals(callStack, e.callStack);
+  }
+
+  /**
+   * Return the first element of the call stack.
+   */
+  public StackTraceElement getFirstStackTraceElement() {
+    return callStack[0];
+  }
+
+  /**
+   * Return the call stack.
+   */
+  public StackTraceElement[] getCallStack() {
+    return callStack;
+  }
+
+  /**
+   * Return the hash for the first stack element.
+   */
+  public String getZeroHash() {
+    return zeroHash;
+  }
+
+  /**
+   * Return the hash for the stack elements (excluding first stack element).
+   */
+  public String getPathHash() {
+    return pathHash;
+  }
+
+  public String toString() {
+    return zeroHash + ":" + pathHash + ":" + callStack[0];
+  }
+
+  /**
+   * Return the call stack lines appended with the given newLine string.
+   */
+  public String description(String newLine) {
+    StringBuilder sb = new StringBuilder(400);
+    for (int i = 0; i < callStack.length; i++) {
+      sb.append(callStack[i].toString()).append(newLine);
+    }
+    return sb.toString();
+  }
+
+  public String getOriginKey(int queryHash) {
+    return enc(queryHash)+ "." + zeroHash + "." + pathHash;
+  }
+
+  private static final int radix = 1 << 6;
+  private static final int mask = radix - 1;
+
+  /**
+   * Convert the integer to unsigned base 64.
+   */
+  public static String enc(int i) {
+    char[] buf = new char[32];
+    int charPos = 32;
+    do {
+      buf[--charPos] = intToBase64[i & mask];
+      i >>>= 6;
+    } while (i != 0);
+
+    return new String(buf, charPos, (32 - charPos));
+  }
+
+  private static final char intToBase64[] = {
+      'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+      'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+      'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+      'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'
+  };
+}

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

@@ -1,114 +1,114 @@
-package com.avaje.ebean.bean;
-
-import java.beans.PropertyChangeListener;
-import java.io.Serializable;
-
-/**
- * Bean that is aware of EntityBeanIntercept.
- * <p>
- * This interface and implementation of these methods is added to Entity Beans
- * via instrumentation. These methods have a funny _ebean_ prefix to avoid any
- * clash with normal methods these beans would have. These methods are not for
- * general application consumption.
- * </p>
- */
-public interface EntityBean extends Serializable {
-
-  public String[] _ebean_getPropertyNames();
-  
-  public String _ebean_getPropertyName(int pos);
-  
-  /**
-   * Return the enhancement marker value.
-   * <p>
-   * This is the class name of the enhanced class and used to check that all
-   * entity classes are enhanced (specifically not just a super class).
-   * </p>
-   */
-  public String _ebean_getMarker();
-
-  /**
-   * Create and return a new entity bean instance.
-   */
-  public Object _ebean_newInstance();
-
-  /**
-   * Add a PropertyChangeListener to this bean.
-   */
-  public void addPropertyChangeListener(PropertyChangeListener listener);
-
-  /**
-   * Remove a PropertyChangeListener from this bean.
-   */
-  public void removePropertyChangeListener(PropertyChangeListener listener);
-
-  /**
-   * Generated method that sets the loaded state on all the embedded beans on
-   * this entity bean by using EntityBeanIntercept.setEmbeddedLoaded(Object o);
-   */
-  public void _ebean_setEmbeddedLoaded();
-
-  /**
-   * Return true if any embedded beans are new or dirty.
-   */
-  public boolean _ebean_isEmbeddedNewOrDirty();
-
-  /**
-   * Return the intercept for this object.
-   */
-  public EntityBeanIntercept _ebean_getIntercept();
-
-  /**
-   * Similar to _ebean_getIntercept() except it checks to see if the intercept
-   * field is null and will create it if required.
-   * <p>
-   * This is really only required when transientInternalFields=true as an
-   * enhancement option. In this case the intercept field is transient and will
-   * be null after a bean has been deserialised.
-   * </p>
-   * <p>
-   * This transientInternalFields=true option was to support some serialization
-   * frameworks that can't take into account our ebean fields.
-   * </p>
-   */
-  public EntityBeanIntercept _ebean_intercept();
-
-  /**
-   * Create a copy of this entity bean.
-   * <p>
-   * This occurs when a bean is changed. The copy represents the bean as it was
-   * initially (oldValues) before any changes where made. This is used for
-   * optimistic concurrency control.
-   * </p>
-   */
-  public Object _ebean_createCopy();
-
-  /**
-   * Set the value of a field of an entity bean of this type.
-   * <p>
-   * Note that using this method bypasses any interception that otherwise occurs
-   * on entity beans. That means lazy loading and oldValues creation.
-   * </p>
-   */
-  public void _ebean_setField(int fieldIndex, Object value);
-
-  /**
-   * Set the field value with interception.
-   */
-  public void _ebean_setFieldIntercept(int fieldIndex, Object value);
-
-  /**
-   * Return the value of a field from an entity bean of this type.
-   * <p>
-   * Note that using this method bypasses any interception that otherwise occurs
-   * on entity beans. That means lazy loading.
-   * </p>
-   */
-  public Object _ebean_getField(int fieldIndex);
-
-  /**
-   * Return the field value with interception.
-   */
-  public Object _ebean_getFieldIntercept(int fieldIndex);
-
-}
+package com.avaje.ebean.bean;
+
+import java.beans.PropertyChangeListener;
+import java.io.Serializable;
+
+/**
+ * Bean that is aware of EntityBeanIntercept.
+ * <p>
+ * This interface and implementation of these methods is added to Entity Beans
+ * via instrumentation. These methods have a funny _ebean_ prefix to avoid any
+ * clash with normal methods these beans would have. These methods are not for
+ * general application consumption.
+ * </p>
+ */
+public interface EntityBean extends Serializable {
+
+  String[] _ebean_getPropertyNames();
+  
+  String _ebean_getPropertyName(int pos);
+  
+  /**
+   * Return the enhancement marker value.
+   * <p>
+   * This is the class name of the enhanced class and used to check that all
+   * entity classes are enhanced (specifically not just a super class).
+   * </p>
+   */
+  String _ebean_getMarker();
+
+  /**
+   * Create and return a new entity bean instance.
+   */
+  Object _ebean_newInstance();
+
+  /**
+   * Add a PropertyChangeListener to this bean.
+   */
+  void addPropertyChangeListener(PropertyChangeListener listener);
+
+  /**
+   * Remove a PropertyChangeListener from this bean.
+   */
+  void removePropertyChangeListener(PropertyChangeListener listener);
+
+  /**
+   * Generated method that sets the loaded state on all the embedded beans on
+   * this entity bean by using EntityBeanIntercept.setEmbeddedLoaded(Object o);
+   */
+  void _ebean_setEmbeddedLoaded();
+
+  /**
+   * Return true if any embedded beans are new or dirty.
+   */
+  boolean _ebean_isEmbeddedNewOrDirty();
+
+  /**
+   * Return the intercept for this object.
+   */
+  EntityBeanIntercept _ebean_getIntercept();
+
+  /**
+   * Similar to _ebean_getIntercept() except it checks to see if the intercept
+   * field is null and will create it if required.
+   * <p>
+   * This is really only required when transientInternalFields=true as an
+   * enhancement option. In this case the intercept field is transient and will
+   * be null after a bean has been deserialised.
+   * </p>
+   * <p>
+   * This transientInternalFields=true option was to support some serialization
+   * frameworks that can't take into account our ebean fields.
+   * </p>
+   */
+  EntityBeanIntercept _ebean_intercept();
+
+  /**
+   * Create a copy of this entity bean.
+   * <p>
+   * This occurs when a bean is changed. The copy represents the bean as it was
+   * initially (oldValues) before any changes where made. This is used for
+   * optimistic concurrency control.
+   * </p>
+   */
+  Object _ebean_createCopy();
+
+  /**
+   * Set the value of a field of an entity bean of this type.
+   * <p>
+   * Note that using this method bypasses any interception that otherwise occurs
+   * on entity beans. That means lazy loading and oldValues creation.
+   * </p>
+   */
+  void _ebean_setField(int fieldIndex, Object value);
+
+  /**
+   * Set the field value with interception.
+   */
+  void _ebean_setFieldIntercept(int fieldIndex, Object value);
+
+  /**
+   * Return the value of a field from an entity bean of this type.
+   * <p>
+   * Note that using this method bypasses any interception that otherwise occurs
+   * on entity beans. That means lazy loading.
+   * </p>
+   */
+  Object _ebean_getField(int fieldIndex);
+
+  /**
+   * Return the field value with interception.
+   */
+  Object _ebean_getFieldIntercept(int fieldIndex);
+
+}

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

@@ -1,126 +1,126 @@
-package com.avaje.ebean.bean;
-
-import java.lang.ref.WeakReference;
-import java.util.HashSet;
-
-/**
- * Collects profile information for a bean (or reference/proxy bean) at a given
- * AutoFetchNode.
- * <p>
- * The AutoFetchNode identifies the location of the bean in the object graph.
- * </p>
- * <p>
- * It has to use a weak reference so as to ensure that it does not stop the
- * associated bean from being garbage collected.
- * </p>
- */
-public final class NodeUsageCollector {
-
-  /**
-   * The point in the object graph for a specific query and call stack point.
-   */
-  private final ObjectGraphNode node;
-
-  /**
-   * Weak to allow garbage collection.
-   */
-  private final WeakReference<NodeUsageListener> managerRef;
-
-  /**
-   * The properties used at this profile point.
-   */
-  private final HashSet<String> used = new HashSet<String>();
-
-  /**
-   * set to true if the bean is modified (setter called)
-   */
-  private boolean modified;
-
-  /**
-   * The property that cause a reference to lazy load.
-   */
-  private String loadProperty;
-
-  public NodeUsageCollector(ObjectGraphNode node, WeakReference<NodeUsageListener> managerRef) {
-    this.node = node;
-    // weak to allow garbage collection.
-    this.managerRef = managerRef;
-  }
-
-  /**
-   * The bean has been modified by a setter method.
-   */
-  public void setModified() {
-    modified = true;
-  }
-
-  /**
-   * Add the name of a property that has been used.
-   */
-  public void addUsed(String property) {
-    used.add(property);
-  }
-
-  /**
-   * The property that invoked a lazy load.
-   */
-  public void setLoadProperty(String loadProperty) {
-    this.loadProperty = loadProperty;
-  }
-
-  /**
-   * Publish the usage info to the manager.
-   */
-  private void publishUsageInfo() {
-    NodeUsageListener manager = managerRef.get();
-    if (manager != null) {
-      manager.collectNodeUsage(this);
-    }
-  }
-
-  /**
-   * publish the collected usage information when garbage collection occurs.
-   */
-  @Override
-  protected void finalize() throws Throwable {
-    publishUsageInfo();
-    super.finalize();
-  }
-
-  /**
-   * Return the associated node which identifies the location in the object
-   * graph of the bean/reference.
-   */
-  public ObjectGraphNode getNode() {
-    return node;
-  }
-
-  /**
-   * Return true if no properties where used.
-   */
-  public boolean isEmpty() {
-    return used.isEmpty();
-  }
-
-  /**
-   * Return the set of used properties.
-   */
-  public HashSet<String> getUsed() {
-    return used;
-  }
-
-  /**
-   * Return true if the bean was modified by a setter.
-   */
-  public boolean isModified() {
-    return modified;
-  }
-
-  public String getLoadProperty() {
-    return loadProperty;
-  }
-
-  public String toString() {
-    return node + " read:" + used + " modified:" + modified;
-  }
-}
+package com.avaje.ebean.bean;
+
+import java.lang.ref.WeakReference;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * Collects profile information for a bean (or reference/proxy bean) at a given node.
+ * <p>
+ * The node identifies the location of the bean in the object graph.
+ * </p>
+ * <p>
+ * It has to use a weak reference so as to ensure that it does not stop the
+ * associated bean from being garbage collected.
+ * </p>
+ */
+public final class NodeUsageCollector {
+
+  /**
+   * The point in the object graph for a specific query and call stack point.
+   */
+  private final ObjectGraphNode node;
+
+  /**
+   * Weak to allow garbage collection.
+   */
+  private final WeakReference<NodeUsageListener> managerRef;
+
+  /**
+   * The properties used at this profile point.
+   */
+  private final Set<String> used = new LinkedHashSet<String>();
+
+  /**
+   * set to true if the bean is modified (setter called)
+   */
+  private boolean modified;
+
+  /**
+   * The property that cause a reference to lazy load.
+   */
+  private String loadProperty;
+
+  public NodeUsageCollector(ObjectGraphNode node, WeakReference<NodeUsageListener> managerRef) {
+    this.node = node;
+    // weak to allow garbage collection.
+    this.managerRef = managerRef;
+  }
+
+  /**
+   * The bean has been modified by a setter method.
+   */
+  public void setModified() {
+    modified = true;
+  }
+
+  /**
+   * Add the name of a property that has been used.
+   */
+  public void addUsed(String property) {
+    used.add(property);
+  }
+
+  /**
+   * The property that invoked a lazy load.
+   */
+  public void setLoadProperty(String loadProperty) {
+    this.loadProperty = loadProperty;
+  }
+
+  /**
+   * Publish the usage info to the manager.
+   */
+  private void publishUsageInfo() {
+    NodeUsageListener manager = managerRef.get();
+    if (manager != null) {
+      manager.collectNodeUsage(this);
+    }
+  }
+
+  /**
+   * publish the collected usage information when garbage collection occurs.
+   */
+  @Override
+  protected void finalize() throws Throwable {
+    publishUsageInfo();
+    super.finalize();
+  }
+
+  /**
+   * Return the associated node which identifies the location in the object
+   * graph of the bean/reference.
+   */
+  public ObjectGraphNode getNode() {
+    return node;
+  }
+
+  /**
+   * Return true if no properties where used.
+   */
+  public boolean isEmpty() {
+    return used.isEmpty();
+  }
+
+  /**
+   * Return the set of used properties.
+   */
+  public Set<String> getUsed() {
+    return used;
+  }
+
+  /**
+   * Return true if the bean was modified by a setter.
+   */
+  public boolean isModified() {
+    return modified;
+  }
+
+  public String getLoadProperty() {
+    return loadProperty;
+  }
+
+  public String toString() {
+    return node + " read:" + used + " modified:" + modified;
+  }
+}

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

@@ -1,16 +1,16 @@
-package com.avaje.ebean.bean;
-
-/**
- * Collects the profile information.
- */
-public interface NodeUsageListener {
-
-  /**
-   * Collect node usage "profiling" information.
-   * <p>
-   * This is the properties that are used for a given bean in the object graph.
-   * This information is used by autoFetch to tune queries.
-   * </p>
-   */
-  public void collectNodeUsage(NodeUsageCollector collector);
-}
+package com.avaje.ebean.bean;
+
+/**
+ * Collects the profile information.
+ */
+public interface NodeUsageListener {
+
+  /**
+   * Collect node usage "profiling" information.
+   * <p>
+   * This is the properties that are used for a given bean in the object graph.
+   * This information is used by autoTune to tune queries.
+   * </p>
+   */
+  void collectNodeUsage(NodeUsageCollector collector);
+}