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

Backport fix for #154 - @OrderBy on a @OneToMany property is not used when lazy loading

.gitignore

@@ -6,12 +6,6 @@
 target/
 logs/
 log/
-/db
 /mydb.db
-
-
-# Intellij project files
 *.iml
-*.ipr
-*.iws
-.idea/
+.idea

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
 ==============
 
+Main EbeanORM artifact
+
 Maven Dependency
 ----------------
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm</artifactId>
-      <version>4.3.0</version>
+      <version>3.3.2</version>
     </dependency>
     
+    

pom.xml

@@ -9,7 +9,7 @@
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>4.3.0</version>
+  <version>3.4.2</version>
   <packaging>jar</packaging>
 
   <name>avaje-ebeanorm</name>
@@ -48,18 +48,6 @@
       <artifactId>persistence-api</artifactId>
       <version>1.0</version>
     </dependency>
-
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-api</artifactId>
-      <version>1.7.7</version>
-    </dependency>
-
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-core</artifactId>
-      <version>2.4.3</version>
-    </dependency>
     
     <dependency>
       <groupId>javax.transaction</groupId>
@@ -89,6 +77,13 @@
       <scope>provided</scope>
     </dependency>
 
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.2</version>
+      <scope>provided</scope>
+    </dependency>
+
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-agentloader</artifactId>
@@ -99,7 +94,7 @@
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.1.9</version>
+      <version>3.2.2</version>
       <scope>test</scope>
     </dependency>
         
@@ -141,16 +136,9 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.11</version>
+      <version>4.8.2</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>
@@ -182,7 +170,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.2</version>
+        <version>3.1</version>
         <configuration>
           <source>1.6</source>
           <target>1.6</target>
@@ -191,9 +179,20 @@
       <plugin>
         <groupId>org.avaje.ebeanorm</groupId>
         <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.1.9</version>
+        <version>3.3.2</version>
         <executions>
-          <!--   Not going to enhance Model bean -->
+           <execution>
+            <id>main</id>
+            <phase>process-classes</phase>
+            <configuration>
+              <classSource>target/classes</classSource>
+              <packages>com.avaje.ebean.meta.**</packages>
+              <transformArgs>debug=1</transformArgs>
+            </configuration>
+            <goals>
+              <goal>enhance</goal>
+            </goals>
+          </execution>
           <execution>
             <id>test</id>
             <phase>process-test-classes</phase>
@@ -223,38 +222,9 @@
           </includes>
         </configuration>
       </plugin>
- 	 <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-jar-plugin</artifactId>
-        <version>2.5</version>
-        <configuration>
-          <archive>
-            <manifestFile>src/main/resources/META-INF/MANIFEST.MF</manifestFile>
-          </archive>
-        </configuration>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-javadoc-plugin</artifactId>
-        <version>2.9.1</version>
-        <configuration>
-          <doctitle>Ebean 4</doctitle>
-          <overview>src/main/java/com/avaje/ebean/overview.html</overview>
-         <!-- <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames> -->
-          <additionalparam>-Xdoclint:none</additionalparam>
-        </configuration>
-        <executions>
-          <execution>
-            <id>attach-javadocs</id>
-            <phase>site</phase>
-            <goals>
-              <goal>aggregate</goal>
-            </goals>
-          </execution>
-        </executions>
-      </plugin>
+
     </plugins>
 
   </build>
- 
+
 </project>

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

@@ -1,7 +1,6 @@
 package com.avaje.ebean;
 
 import java.beans.PropertyChangeListener;
-import java.util.Map;
 import java.util.Set;
 
 /**
@@ -47,11 +46,6 @@ public interface BeanState {
    */
   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>
@@ -75,6 +69,16 @@ public interface BeanState {
    */
   public void removePropertyChangeListener(PropertyChangeListener listener);
 
+  /**
+   * Advanced - Used to programmatically build a reference object.
+   * <p>
+   * You can create a new EntityBean (
+   * {@link EbeanServer#createEntityBean(Class)}, set its Id property and then
+   * call this setReference() method.
+   * </p>
+   */
+  public void setReference();
+
   /**
    * Advanced - Used to programmatically build a partially or fully loaded
    * entity bean. First create an entity bean via
@@ -86,5 +90,5 @@ public interface BeanState {
    *          the properties that where loaded or null for a fully loaded entity
    *          bean.
    */
-  public void setLoaded();
+  public void setLoaded(Set<String> loadedProperties);
 }

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

@@ -7,7 +7,6 @@ import java.util.Map;
 import java.util.Set;
 
 import javax.persistence.OptimisticLockException;
-import javax.persistence.PersistenceException;
 
 import com.avaje.ebean.annotation.CacheStrategy;
 import com.avaje.ebean.cache.ServerCacheManager;
@@ -49,18 +48,18 @@ import com.avaje.ebean.text.json.JsonContext;
  * Example: Get a EbeanServer
  * </p>
  * 
- * <pre>{@code
+ * <pre class="code">
  * // Get access to the Human Resources EbeanServer/Database
- * EbeanServer hrServer = Ebean.getServer("HR");
+ * EbeanServer hrServer = Ebean.getServer(&quot;HR&quot;);
  * 
  * 
  * // fetch contact 3 from the HR database Contact contact =
  * hrServer.find(Contact.class, new Integer(3));
  * 
- * contact.setStatus("INACTIVE"); ...
+ * contact.setStatus(&quot;INACTIVE&quot;); ...
  * 
  * // save the contact back to the HR database hrServer.save(contact);
- * }</pre>
+ * </pre>
  * 
  * <p>
  * <b>EbeanServer has more API than Ebean</b><br/>
@@ -86,12 +85,9 @@ import com.avaje.ebean.text.json.JsonContext;
 public interface EbeanServer {
 
   /**
-   * Shutdown the EbeanServer programmatically.
+   * Shutdown the EbeanServer.
    * <p>
-   * This method is not normally required. Ebean registers a shutdown hook and shuts down cleanly.
-   * </p>
-   * <p>
-   * If the under underlying DataSource is the Ebean implementation then you
+   * If the under underlying DataSource is the EbeanORM implementation then you
    * also have the option of shutting down the DataSource and deregistering the
    * JDBC driver.
    * </p>
@@ -128,6 +124,7 @@ public interface EbeanServer {
    */
   public MetaInfoManager getMetaInfoManager();
 
+
   /**
    * Return the BeanState for a given entity bean.
    * <p>
@@ -191,15 +188,15 @@ public interface EbeanServer {
    * moved to {@link #createNamedQuery(Class, String)}.
    * </p>
    * 
-   * <pre>{@code
+   * <pre class="code">
    *  EbeanServer ebeanServer = ... ;
    *  String q = "find order fetch details where status = :st";
    *  
-   *  List<Order> newOrders
+   *  List&lt;Order&gt; newOrders 
    *        = ebeanServer.createQuery(Order.class, q)
    *             .setParameter("st", Order.Status.NEW)
    *             .findList();
-   * }</pre>
+   * </pre>
    * 
    * @param query
    *          the object query
@@ -207,14 +204,16 @@ public interface EbeanServer {
   public <T> Query<T> createQuery(Class<T> beanType, String query);
 
   /**
-   * Create a query for an entity bean (refer {@link Ebean#createQuery(Class)}).
+   * Create a query for an entity bean (refer {@link Ebean#createQuery(Class)}
+   * ).
    * 
    * @see Ebean#createQuery(Class)
    */
   public <T> Query<T> createQuery(Class<T> beanType);
 
   /**
-   * Create a query for a type of entity bean (the same as {@link EbeanServer#createQuery(Class)}).
+   * Create a query for a type of entity bean (the same as
+   * {@link EbeanServer#createQuery(Class)}).
    */
   public <T> Query<T> find(Class<T> beanType);
 
@@ -270,7 +269,8 @@ public interface EbeanServer {
   public SqlQuery createSqlQuery(String sql);
 
   /**
-   * Create a named sql query (refer {@link Ebean#createNamedSqlQuery(String)}).
+   * Create a named sql query (refer {@link Ebean#createNamedSqlQuery(String)}
+   * ).
    * <p>
    * The query statement will be defined in a deployment orm xml file.
    * </p>
@@ -280,7 +280,8 @@ public interface EbeanServer {
   public SqlQuery createNamedSqlQuery(String namedQuery);
 
   /**
-   * Create a sql update for executing native dml statements (refer {@link Ebean#createSqlUpdate(String)}).
+   * Create a sql update for executing native dml statements (refer
+   * {@link Ebean#createSqlUpdate(String)}).
    * 
    * @see Ebean#createSqlUpdate(String)
    */
@@ -292,7 +293,8 @@ public interface EbeanServer {
   public CallableSql createCallableSql(String callableSql);
 
   /**
-   * Create a named sql update (refer {@link Ebean#createNamedSqlUpdate(String)}).
+   * Create a named sql update (refer {@link Ebean#createNamedSqlUpdate(String)}
+   * ).
    * <p>
    * The statement (an Insert Update or Delete statement) will be defined in a
    * deployment orm xml file.
@@ -302,17 +304,6 @@ public interface EbeanServer {
    */
   public SqlUpdate createNamedSqlUpdate(String namedQuery);
 
-  /**
-   * Register a TransactionCallback on the currently active transaction.
-   * <p/>
-   * If there is no currently active transaction then a PersistenceException is thrown.
-   *
-   * @param transactionCallback The transaction callback to be registered with the current transaction.
-   *
-   * @throws PersistenceException If there is no currently active transaction
-   */
-  public void register(TransactionCallback transactionCallback) throws PersistenceException;
-
   /**
    * Create a new transaction that is not held in TransactionThreadLocal.
    * <p>
@@ -344,7 +335,8 @@ public interface EbeanServer {
   public Transaction beginTransaction(TxIsolation isolation);
 
   /**
-   * Returns the current transaction or null if there is no current transaction in scope.
+   * Returns the current transaction or null if there is no current transaction
+   * in scope.
    */
   public Transaction currentTransaction();
 
@@ -372,19 +364,15 @@ public interface EbeanServer {
    * <p>
    * Code example:
    * 
-   * <pre>{@code
-   *   ebeanServer.startTransaction();
-   *   try {
-   *     // do some fetching and or persisting ...
+   * <pre class="code">
+   * Ebean.startTransaction(); try { // do some fetching
+   * and or persisting
    * 
-   *     // commit at the end
-   *     ebeanServer.commitTransaction();
+   * // commit at the end Ebean.commitTransaction();
    * 
-   *   } finally {
-   *     // if commit didn't occur then rollback the transaction
-   *     ebeanServer.endTransaction();
-   *   }
-   * }</pre>
+   * } finally { // if commit didn't occur then rollback the transaction
+   * Ebean.endTransaction(); }
+   * </pre>
    * 
    * </p>
    * 
@@ -422,27 +410,14 @@ public interface EbeanServer {
   public <T> T find(Class<T> beanType, Object uid);
 
   /**
-   * Get a reference bean (see {@link Ebean#getReference(Class, Object)}.
+   * Get a reference Object (see {@link Ebean#getReference(Class, Object)}.
    * <p>
    * This will not perform a query against the database.
    * </p>
-   * <pre>{@code
-   * Product product = Ebean.getReference(Product.class, 1);
    * 
-   * // You can get the id without causing a fetch/lazy load
-   * Integer productId = product.getId();
-   * 
-   * // If you try to get any other property a fetch/lazy loading will occur
-   * // This will cause a query to execute...
-   * String name = product.getName();
-   * }</pre>
-   * 
-   * @param beanType
-   *          the type of entity bean
-   * @param id
-   *          the id value
+   * @see Ebean#getReference(Class, Object)
    */
-  public <T> T getReference(Class<T> beanType, Object id);
+  public <T> T getReference(Class<T> beanType, Object uid);
 
   /**
    * Return the number of 'top level' or 'root' entities this query should
@@ -453,45 +428,21 @@ public interface EbeanServer {
   /**
    * Return the Id values of the query as a List.
    */
-  public <T> List<Object> findIds(Query<T> query, Transaction transaction);
+  public <T> List<Object> findIds(Query<T> query, Transaction t);
 
   /**
    * Return a QueryIterator for the query. This is similar to findVisit in that
    * not all the result beans need to be held in memory at the same time and as
    * such is go for processing large queries.
    */
-  public <T> QueryIterator<T> findIterate(Query<T> query, Transaction transaction);
+  public <T> QueryIterator<T> findIterate(Query<T> query, Transaction t);
 
   /**
    * Execute the query visiting the results. This is similar to findIterate in
    * that not all the result beans need to be held in memory at the same time
    * and as such is go for processing large queries.
-   *
-   * @see Query#findEach(QueryEachConsumer)
    */
-  public <T> void findEach(Query<T> query, QueryEachConsumer<T> consumer, Transaction transaction);
-
-  /**
-   * Execute the query visiting the results. This is similar to findIterate in
-   * that not all the result beans need to be held in memory at the same time
-   * and as such is go for processing large queries.
-   *
-   * @see Query#findEachWhile(QueryEachWhileConsumer)
-   */
-  public <T> void findEachWhile(Query<T> query, QueryEachWhileConsumer<T> consumer, Transaction transaction);
-
-  /**
-   * Deprecated in favor of #findEachWhile which is functionally exactly the same
-   * but has a much better name.
-   * <p>
-   * Execute the query visiting the results. This is similar to findIterate in
-   * that not all the result beans need to be held in memory at the same time
-   * and as such is go for processing large queries.
-   * </p>
-   *
-   * @deprecated
-   */
-  public <T> void findVisit(Query<T> query, QueryResultVisitor<T> visitor, Transaction transaction);
+  public <T> void findVisit(Query<T> query, QueryResultVisitor<T> visitor, Transaction t);
 
   /**
    * Execute a query returning a list of beans.
@@ -522,11 +473,11 @@ public interface EbeanServer {
    * 
    * @param query
    *          the query to execute the row count on
-   * @param transaction
+   * @param t
    *          the transaction (can be null).
    * @return a Future object for the row count query
    */
-  public <T> FutureRowCount<T> findFutureRowCount(Query<T> query, Transaction transaction);
+  public <T> FutureRowCount<T> findFutureRowCount(Query<T> query, Transaction t);
 
   /**
    * Execute find Id's query in a background thread.
@@ -538,11 +489,11 @@ public interface EbeanServer {
    * 
    * @param query
    *          the query to execute the fetch Id's on
-   * @param transaction
+   * @param t
    *          the transaction (can be null).
    * @return a Future object for the list of Id's
    */
-  public <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction);
+  public <T> FutureIds<T> findFutureIds(Query<T> query, Transaction t);
 
   /**
    * Execute find list query in a background thread.
@@ -554,12 +505,11 @@ public interface EbeanServer {
    * 
    * @param query
    *          the query to execute in the background
-   * @param transaction
+   * @param t
    *          the transaction (can be null).
    * @return a Future object for the list result of the query
-   * @deprecated
    */
-  public <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction);
+  public <T> FutureList<T> findFutureList(Query<T> query, Transaction t);
 
   /**
    * Execute find list SQL query in a background thread.
@@ -571,40 +521,16 @@ public interface EbeanServer {
    * 
    * @param query
    *          the query to execute in the background
-   * @param transaction
+   * @param t
    *          the transaction (can be null).
    * @return a Future object for the list result of the query
-   * @deprecated 
    */
-  public SqlFutureList findFutureList(SqlQuery query, Transaction transaction);
+  public SqlFutureList findFutureList(SqlQuery query, Transaction t);
 
   /**
    * Find using a PagingList with explicit transaction and pageSize.
-   * Deprecated in favour of findPagedList().
-   * @deprecated 
-   */  
-  public <T> PagingList<T> findPagingList(Query<T> query, Transaction transaction, int pageSize);
-
-  /**
-   * Return a PagedList for this query.
-   * <p>
-   * The benefit of using this over just using the normal {@link Query#setFirstRow(int)} and
-   * {@link Query#setMaxRows(int)} is that it additionally wraps an optional call to
-   * {@link Query#findFutureRowCount()} to determine total row count, total page count etc.
-   * </p>
-   * <p>
-   * Internally this works using {@link Query#setFirstRow(int)} and {@link Query#setMaxRows(int)} on
-   * the query. This translates into SQL that uses limit offset, rownum or row_number
-   * function to limit the result set.
-   * </p>
-   * 
-   * @param pageIndex
-   *          The zero based index of the page.
-   * @param pageSize
-   *          The number of beans to return per page.
-   * @return The PagedList
    */
-  public <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction, int pageIndex, int pageSize);
+  public <T> PagingList<T> findPagingList(Query<T> query, Transaction t, int pageSize);
 
   /**
    * Execute the query returning a set of entity beans.
@@ -751,7 +677,7 @@ public interface EbeanServer {
   /**
    * Save all the beans in the collection.
    */
-  public int save(Collection<?> beans) throws OptimisticLockException;
+  public int save(Collection<?> it) throws OptimisticLockException;
 
   /**
    * Delete the bean.
@@ -778,7 +704,7 @@ public interface EbeanServer {
   /**
    * Delete the bean given its type and id with an explicit transaction.
    */
-  public int delete(Class<?> beanType, Object id, Transaction transaction);
+  public int delete(Class<?> beanType, Object id, Transaction t);
 
   /**
    * Delete several beans given their type and id values.
@@ -789,7 +715,7 @@ public interface EbeanServer {
    * Delete several beans given their type and id values with an explicit
    * transaction.
    */
-  public void delete(Class<?> beanType, Collection<?> ids, Transaction transaction);
+  public void delete(Class<?> beanType, Collection<?> ids, Transaction t);
 
   /**
    * Execute a SQL Update Delete or Insert statement using the current
@@ -858,129 +784,205 @@ public interface EbeanServer {
   /**
    * Insert or update a bean with an explicit transaction.
    */
-  public void save(Object bean, Transaction transaction) throws OptimisticLockException;
+  public void save(Object bean, Transaction t) throws OptimisticLockException;
 
   /**
    * Save all the beans in the iterator with an explicit transaction.
    */
-  public int save(Iterator<?> it, Transaction transaction) throws OptimisticLockException;
+  public int save(Iterator<?> it, Transaction t) throws OptimisticLockException;
 
   /**
-   * Save all the beans in the collection with an explicit transaction.
+   * Force an update using the bean.
+   * <p>
+   * You can use this method to FORCE an update to occur (even on a bean that
+   * has not been fetched but say built from JSON or XML). When
+   * {@link EbeanServer#save(Object)} is used Ebean determines whether to use an
+   * insert or an update based on the state of the bean. Using this method will
+   * force an update to occur.
+   * </p>
+   * <p>
+   * It is expected that this method is most useful in stateless REST services
+   * or web applications where you have the values you wish to update but no
+   * existing bean.
+   * </p>
+   * <p>
+   * For updates against beans that have not been fetched (say built from JSON
+   * or XML) this will treat deleteMissingChildren=true and will delete any
+   * 'missing children'. Refer to
+   * {@link EbeanServer#update(Object, Set, Transaction, boolean, boolean)}.
+   * </p>
+   * 
+   * <pre class="code">
+   * 
+   * Customer c = new Customer();
+   * c.setId(7);
+   * c.setName(&quot;ModifiedNameNoOCC&quot;);
+   * 
+   * // generally you should set the version property
+   * // so that Optimistic Concurrency Checking is used.
+   * // If a version property is not set then no Optimistic
+   * // Concurrency Checking occurs for the update
+   * // c.setLastUpdate(lastUpdateTime);
+   * 
+   * // by default the Non-null properties
+   * // are included in the update
+   * ebeanServer.update(c);
+   * 
+   * </pre>
    */
-  public int save(Collection<?> beans, Transaction transaction) throws OptimisticLockException;
+  public void update(Object bean);
 
   /**
-   * Marks the entity bean as dirty.
+   * Force an update of the non-null properties of the bean with an explicit
+   * transaction.
    * <p>
-   * This is used so that when a bean that is otherwise unmodified is updated the version
-   * property is updated.
+   * You can use this method to FORCE an update to occur (even on a bean that
+   * has not been fetched but say built from JSON or XML). When
+   * {@link EbeanServer#save(Object)} is used Ebean determines whether to use an
+   * insert or an update based on the state of the bean. Using this method will
+   * force an update to occur.
+   * </p>
    * <p>
-   * An unmodified bean that is saved or updated is normally skipped and this marks the bean as
-   * dirty so that it is not skipped.
-   * 
-   * <pre>{@code
-   * 
-   * Customer customer = ebeanServer.find(Customer, id);
-   * 
-   * // mark the bean as dirty so that a save() or update() will
-   * // increment the version property
-   * ebeanServer.markAsDirty(customer);
-   * ebeanServer.save(customer);
-   * 
-   * }</pre>
+   * It is expected that this method is most useful in stateless REST services
+   * or web applications where you have the values you wish to update but no
+   * existing bean.
+   * </p>
+   * <p>
+   * For updates against beans that have not been fetched (say built from JSON
+   * or XML) this will treat deleteMissingChildren=true and will delete any
+   * 'missing children'. Refer to
+   * {@link EbeanServer#update(Object, Set, Transaction, boolean, boolean)}.
+   * </p>
    */
-  public void markAsDirty(Object bean);
-  
-  /**
-   * Saves the bean using an update. If you know you are updating a bean then it is preferrable to
-   * use this update() method rather than save().
-   * <p>
-   * <b>Stateless updates:</b> Note that the bean does not have to be previously fetched to call
-   * update().You can create a new instance and set some of its properties programmatically for via
-   * JSON/XML marshalling etc. This is described as a 'stateless update'.
-   * </p>
-   * <p>
-   * <b>Optimistic Locking: </b> Note that if the version property is not set when update() is
-   * called then no optimistic locking is performed (internally ConcurrencyMode.NONE is used).
-   * </p>
-   * <p>
-   * <b>{@link ServerConfig#setUpdatesDeleteMissingChildren(boolean)}: </b> When cascade saving to a
-   * OneToMany or ManyToMany the updatesDeleteMissingChildren setting controls if any other children
-   * that are in the database but are not in the collection are deleted.
-   * </p>
-   * <p>
-   * <b>{@link ServerConfig#setUpdateChangesOnly(boolean)}: </b> The updateChangesOnly setting
-   * controls if only the changed properties are included in the update or if all the loaded
-   * properties are included instead.
-   * </p>
-   * 
-   * <pre>{@code
-   * 
-   * // A 'stateless update' example
-   * Customer customer = new Customer();
-   * customer.setId(7);
-   * customer.setName("ModifiedNameNoOCC");
-   * ebeanServer.update(customer);
-   * 
-   * }</pre>
-   * 
-   * @see ServerConfig#setUpdatesDeleteMissingChildren(boolean)
-   * @see ServerConfig#setUpdateChangesOnly(boolean)
-   */
-  public void update(Object bean) throws OptimisticLockException;
+  public void update(Object bean, Transaction t);
 
   /**
-   * Update a bean additionally specifying a transaction.
+   * Force an update using the bean explicitly stating the properties to update.
+   * <p>
+   * You can use this method to FORCE an update to occur (even on a bean that
+   * has not been fetched but say built from JSON or XML). When
+   * {@link EbeanServer#save(Object)} is used Ebean determines whether to use an
+   * insert or an update based on the state of the bean. Using this method will
+   * force an update to occur.
+   * </p>
+   * <p>
+   * It is expected that this method is most useful in stateless REST services
+   * or web applications where you have the values you wish to update but no
+   * existing bean.
+   * </p>
+   * <p>
+   * For updates against beans that have not been fetched (say built from JSON
+   * or XML) this will treat deleteMissingChildren=true and will delete any
+   * 'missing children'. Refer to
+   * {@link EbeanServer#update(Object, Set, Transaction, boolean, boolean)}.
+   * </p>
+   * 
+   * <pre class="code">
+   * 
+   * Customer c = new Customer();
+   * c.setId(7);
+   * c.setName(&quot;ModifiedNameNoOCC&quot;);
+   * 
+   * // generally you should set the version property
+   * // so that Optimistic Concurrency Checking is used.
+   * // If a version property is not set then no Optimistic
+   * // Concurrency Checking occurs for the update
+   * // c.setLastUpdate(lastUpdateTime);
+   * 
+   * // by default the Non-null properties
+   * // are included in the update
+   * ebeanServer.update(c);
+   * 
+   * </pre>
    */
-  public void update(Object bean, Transaction t) throws OptimisticLockException;
+  public void update(Object bean, Set<String> updateProps);
 
   /**
-   * Update a bean additionally specifying a transaction and the deleteMissingChildren setting.
+   * Force an update of the specified properties of the bean with an explicit
+   * transaction.
+   * <p>
+   * You can use this method to FORCE an update to occur (even on a bean that
+   * has not been fetched but say built from JSON or XML). When
+   * {@link EbeanServer#save(Object)} is used Ebean determines whether to use an
+   * insert or an update based on the state of the bean. Using this method will
+   * force an update to occur.
+   * </p>
+   * <p>
+   * It is expected that this method is most useful in stateless REST services
+   * or web applications where you have the values you wish to update but no
+   * existing bean.
+   * </p>
+   * <p>
+   * For updates against beans that have not been fetched (say built from JSON
+   * or XML) this will treat deleteMissingChildren=true and will delete any
+   * 'missing children'. Refer to
+   * {@link EbeanServer#update(Object, Set, Transaction, boolean, boolean)}.
+   * </p>
+   */
+  public void update(Object bean, Set<String> updateProps, Transaction t);
+
+  /**
+   * Force an update additionally specifying whether to 'deleteMissingChildren'
+   * when the update cascades to a OneToMany or ManyToMany.
+   * <p>
+   * By default the deleteMissingChildren is true and it is assumed that when
+   * cascade saving a O2M or M2M relationship that the relationship is 'fully
+   * loaded' and any child beans that are no longer on the relationship will be
+   * deleted.
+   * </p>
+   * <p>
+   * You can use this method to FORCE an update to occur (even on a bean that
+   * has not been fetched but say built from JSON or XML). When
+   * {@link EbeanServer#save(Object)} is used Ebean determines whether to use an
+   * insert or an update based on the state of the bean. Using this method will
+   * force an update to occur.
+   * </p>
+   * <p>
+   * It is expected that this method is most useful in stateless REST services
+   * or web applications where you have the values you wish to update but no
+   * existing bean.
+   * </p>
    * 
    * @param bean
    *          the bean to update
-   * @param transaction
-   *          the transaction to use (can be null).
+   * @param updateProps
+   *          optionally you can specify the properties to update (can be null).
+   * @param t
+   *          optionally you can specify the transaction to use (can be null).
    * @param deleteMissingChildren
    *          specify false if you do not want 'missing children' of a OneToMany
    *          or ManyToMany to be automatically deleted.
-
+   * @param updateNullProperties
+   *          specify true if by default you want properties with null values to
+   *          be included in the update and false if those properties should be
+   *          treated as 'unloaded' and excluded from the update. This only
+   *          takes effect if the updateProps is null.
    */
-  public void update(Object bean, Transaction transaction, boolean deleteMissingChildren) throws OptimisticLockException;
+  public void update(Object bean, Set<String> updateProps, Transaction t,
+      boolean deleteMissingChildren, boolean updateNullProperties);
 
   /**
-   * Update a collection of beans. If there is no current transaction one is created and used to
-   * update all the beans in the collection.
-   */
-  public void update(Collection<?> beans) throws OptimisticLockException;
-
-  /**
-   * Update a collection of beans with an explicit transaction.
-   */
-  public void update(Collection<?> beans, Transaction transaction) throws OptimisticLockException;
-  
-  /**
-   * Insert the bean.
+   * Force the bean to be saved with an explicit insert.
+   * <p>
+   * Typically you would use save() and let Ebean determine if the bean should
+   * be inserted or updated. This can be useful when you are transferring data
+   * between databases and want to explicitly insert a bean into a different
+   * database that it came from.
+   * </p>
    */
   public void insert(Object bean);
 
   /**
-   * Insert the bean with a transaction.
+   * Force the bean to be saved with an explicit insert.
+   * <p>
+   * Typically you would use save() and let Ebean determine if the bean should
+   * be inserted or updated. This can be useful when you are transferring data
+   * between databases and want to explicitly insert a bean into a different
+   * database that it came from.
+   * </p>
    */
   public void insert(Object bean, Transaction t);
 
-  /**
-   * Insert a collection of beans. If there is no current transaction one is created and used to
-   * insert all the beans in the collection.
-   */
-  public void insert(Collection<?> beans);
-
-  /**
-   * Insert a collection of beans with an explicit transaction.
-   */
-  public void insert(Collection<?> beans, Transaction t);
-
   /**
    * Delete the associations (from the intersection table) of a ManyToMany given
    * the owner bean and the propertyName of the ManyToMany collection.
@@ -1152,14 +1154,8 @@ public interface EbeanServer {
   public void runCacheWarming(Class<?> beanType);
 
   /**
-   * Return the JsonContext for reading/writing JSON.
-   * @deprecated Please use #json instead.
+   * Create a JsonContext that will use the default configuration options.
    */
   public JsonContext createJsonContext();
 
-  /**
-   * Return the JsonContext for reading/writing JSON.
-   */
-  public JsonContext json();
-
 }

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

@@ -6,6 +6,8 @@ import com.avaje.ebean.common.BootupEbeanManager;
 import com.avaje.ebean.config.GlobalProperties;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.util.ClassUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Creates EbeanServer instances.
@@ -24,9 +26,14 @@ import com.avaje.ebean.util.ClassUtil;
  * methods on the Ebean singleton such as {@link Ebean#find(Class)} are just a
  * convenient way of using the 'default/primary' EbeanServer.
  * </p>
+ * 
+ * @author Rob Bygrave
+ * 
  */
 public class EbeanServerFactory {
 
+  private static final Logger logger = LoggerFactory.getLogger(EbeanServerFactory.class);
+
   private static BootupEbeanManager serverFactory = createServerFactory();
 
   /**
@@ -62,10 +69,27 @@ public class EbeanServerFactory {
 
   private static BootupEbeanManager createServerFactory() {
 
+    // String d___ =
+    // com.avaje.ebean.server.core.DefaultServerFactory.class.getName();
     String dflt = "com.avaje.ebeaninternal.server.core.DefaultServerFactory";
-    String implClassName = System.getProperty("ebean.serverfactory", dflt);
+    String implClassName = GlobalProperties.get("ebean.serverfactory", dflt);
 
+    int delaySecs = GlobalProperties.getInt("ebean.start.delay", 0);
+    if (delaySecs > 0) {
+      try {
+        // perhaps useful to delay the startup to give time to
+        // attach a debugger when running in a server like tomcat.
+        String m = "Ebean sleeping " + delaySecs + " seconds due to ebean.start.delay";
+        logger.info(m);
+        Thread.sleep(delaySecs * 1000);
+
+      } catch (InterruptedException e) {
+        String m = "Interrupting debug.start.delay of " + delaySecs;
+        logger.error(m, e);
+      }
+    }
     try {
+      // use a client side implementation?
       return (BootupEbeanManager) ClassUtil.newInstance(implClassName);
     } catch (Exception ex) {
       throw new RuntimeException(ex);

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

@@ -1,7 +1,5 @@
 package com.avaje.ebean;
 
-import com.avaje.ebean.text.PathProperties;
-
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.List;
@@ -89,11 +87,6 @@ public interface ExpressionList<T> extends Serializable {
    */
   public Query<T> setOrderBy(String orderBy);
 
-  /**
-   * Apply the path properties to the query replacing the select and fetch clauses.
-   */
-  public Query<T> apply(PathProperties pathProperties);
-
   /**
    * Execute the query iterating over the results.
    * 
@@ -102,25 +95,9 @@ public interface ExpressionList<T> extends Serializable {
   public QueryIterator<T> findIterate();
 
   /**
-   * Execute the query process the beans one at a time.
-   *
-   * @see Query#findEach(QueryEachConsumer)
-   */
-  public void findEach(QueryEachConsumer<T> consumer);
-
-  /**
-   * Execute the query processing the beans one at a time with the ability to
-   * stop processing before reading all the beans.
-   *
-   * @see Query#findEachWhile(QueryEachWhileConsumer)
-   */
-  public void findEachWhile(QueryEachWhileConsumer<T> consumer);
-
-  /**
-   * Deprecated in favor of #findEachWhile which is functionally exactly the same
-   * but has a much better name.
-   *
-   * @deprecated
+   * Execute the query visiting the results.
+   * 
+   * @see Query#findVisit(QueryResultVisitor)
    */
   public void findVisit(QueryResultVisitor<T> visitor);
 
@@ -223,34 +200,10 @@ public interface ExpressionList<T> extends Serializable {
    * 
    * @param pageSize
    *          the number of beans fetched per Page
-   * @deprecated
+   * 
    */
   public PagingList<T> findPagingList(int pageSize);
 
-  /**
-   * Return a PagedList for this query.
-   * <p>
-   * The benefit of using this over just using the normal {@link Query#setFirstRow(int)} and
-   * {@link Query#setMaxRows(int)} is that it additionally wraps an optional call to
-   * {@link Query#findFutureRowCount()} to determine total row count, total page count etc.
-   * </p>
-   * <p>
-   * Internally this works using {@link Query#setFirstRow(int)} and {@link Query#setMaxRows(int)} on
-   * the query. This translates into SQL that uses limit offset, rownum or row_number
-   * function to limit the result set.
-   * </p>
-   * 
-   * @param pageIndex
-   *          The zero based index of the page.
-   * @param pageSize
-   *          The number of beans to return per page.
-   * @return The PagedList
-   */
-  public PagedList<T> findPagedList(int pageIndex, int pageSize);
-
-  /**
-   * Add some filter predicate expressions to the many property.
-   */
   public ExpressionList<T> filterMany(String prop);
 
   /**
@@ -261,6 +214,22 @@ public interface ExpressionList<T> extends Serializable {
    */
   public Query<T> select(String properties);
 
+  /**
+   * Specify a property (associated bean) to join and <em>fetch</em> including
+   * all its properties.
+   * 
+   * @see Query#join(String)
+   */
+  public Query<T> join(String assocProperties);
+
+  /**
+   * Specify a property (associated bean) to join and <em>fetch</em> with its
+   * specific properties to include (aka partial object).
+   * 
+   * @see Query#join(String,String)
+   */
+  public Query<T> join(String assocProperty, String assocProperties);
+
   /**
    * Set the first row to fetch.
    * 

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

@@ -1,634 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.text.PathProperties;
-
-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.
- * 
- * <p>
- * By having your entity beans extend this it provides a 'Active Record' style programming model for
- * Ebean users.
- * 
- * <p>
- * Note that there is a avaje-ebeanorm-mocker project that enables you to use Mockito or similar
- * tools to still mock out the underlying 'default EbeanServer' for testing purposes.
- * 
- * <p>
- * You may choose not use this Model mapped superclass if you don't like the 'Active Record' style
- * or if you believe it 'pollutes' your entity beans.
- * 
- * <p>
- * 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
- * relatively nice clean way to write queries.
- */
-@MappedSuperclass
-public abstract class Model {
-
-  /**
-   * Return the underlying 'default' EbeanServer.
-   * 
-   * <p>
-   * This provides full access to the API such as explicit transaction demarcation etc.
-   * 
-   * <p>
-   * Example:
-   * <pre class="code">
-   * Transaction transaction = Customer.db().beginTransaction();
-   * try {
-   * 
-   *   // turn off cascade persist for this transaction
-   *   transaction.setPersistCascade(false);
-   * 
-   *   // extra control over jdbc batching for this transaction
-   *   transaction.setBatchGetGeneratedKeys(false);
-   *   transaction.setBatchMode(true);
-   *   transaction.setBatchSize(20);
-   * 
-   *   Customer customer = new Customer();
-   *   customer.setName(&quot;Roberto&quot;);
-   *   customer.save();
-   * 
-   *   Customer otherCustomer = new Customer();
-   *   otherCustomer.setName(&quot;Franko&quot;);
-   *   otherCustomer.save();
-   * 
-   *   transaction.commit();
-   * 
-   * } finally {
-   *   transaction.end();
-   * }
-   * 
-   * </pre>
-   */
-  public static EbeanServer db() {
-    return Ebean.getServer(null);
-  }
-
-  /**
-   * Return a named EbeanServer that is typically different to the default server.
-   * 
-   * <p>
-   * If you are using multiple databases then each database has a name and maps to a single
-   * EbeanServer. You can use this method to get an EbeanServer for another database.
-   * 
-   * @param server
-   *          The name of the EbeanServer. If this is null then the default EbeanServer is returned.
-   */
-  public static EbeanServer db(String server) {
-    return Ebean.getServer(server);
-  }
-
-  /**
-   * Marks the entity bean as dirty.
-   * <p>
-   * This is used so that when a bean that is otherwise unmodified is updated the version
-   * property is updated.
-   * <p>
-   * An unmodified bean that is saved or updated is normally skipped and this marks the bean as
-   * dirty so that it is not skipped.
-   * 
-   * <pre class="code">
-   * 
-   * Customer customer = Customer.find.byId(id);
-   * 
-   * // mark the bean as dirty so that a save() or update() will
-   * // increment the version property
-   * customer.markAsDirty();
-   * customer.save();
-   * 
-   * </pre>   
-   */
-  public void markAsDirty() {
-    db().markAsDirty(this);
-  }
-  
-  /**
-   * Insert or update this entity depending on its state.
-   * 
-   * <p>
-   * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
-   * insert or an update based on that.
-   */
-  public void save() {
-    db().save(this);
-  }
-
-  /**
-   * Update this entity.
-   */
-  public void update() {
-    db().update(this);
-  }
-
-  /**
-   * Insert this entity.
-   */
-  public void insert() {
-    db().insert(this);
-  }
-
-  /**
-   * Delete this entity.
-   */
-  public void delete() {
-    db().delete(this);
-  }
-
-  /**
-   * Perform an update using this entity against the specified server.
-   */
-  public void update(String server) {
-    db(server).update(this);
-  }
-
-  /**
-   * Perform an insert using this entity against the specified server.
-   */
-  public void insert(String server) {
-    db(server).insert(this);
-  }
-
-  /**
-   * Perform a delete using this entity against the specified server.
-   */
-  public void delete(String server) {
-    db(server).delete(this);
-  }
-
-  /**
-   * Refreshes this entity from the database.
-   */
-  public void refresh() {
-    db().refresh(this);
-  }
-
-  /**
-   * Helper object for performing queries.
-   * 
-   * <p>
-   * Typically a Finder is defined as a public static field on an entity bean class to provide a
-   * nice way to write queries.
-   * 
-   * @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
-   */
-  public static class Finder<I, T> {
-
-    private final Class<I> idType;
-    private final Class<T> type;
-    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.
-     */
-    public Finder(Class<I> idType, Class<T> type) {
-      this(null, idType, type);
-    }
-
-    /**
-     * 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.
-     */
-    public Finder(String serverName, Class<I> idType, Class<T> type) {
-      this.type = type;
-      this.idType = idType;
-      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 equivilent to {@link Ebean#getServer(String)}
-     * 
-     * @param server
-     *          The name of the EbeanServer. If this is null then the default EbeanServer is
-     *          returned.
-     */
-    public EbeanServer db(String server) {
-      return Ebean.getServer(server);
-    }
-
-    /**
-     * Creates a Finder for the named EbeanServer.
-     * 
-     * <p>
-     * Create and return a new Finder for a different server.
-     */
-    public Finder<I, T> on(String server) {
-      return new Finder<I, T>(server, idType, type);
-    }
-
-    // Does not exist yet but I think should
-    // public void deleteById(I id) {
-    // return db().deleteById(type, id);
-    // }
-
-    /**
-     * Retrieves all entities of the given type.
-     * 
-     * <p>
-     * This is the same as (synonym for) {@link #findList()}
-     */
-    public List<T> all() {
-      return findList();
-    }
-
-    /**
-     * Retrieves an entity by ID.
-     * 
-     * <p>
-     * Equivalent to {@link EbeanServer#find(Class, Object)}
-     */
-    public T byId(I id) {
-      return db().find(type, id);
-    }
-
-    /**
-     * Creates an entity reference for this ID.
-     * 
-     * <p>
-     * Equivalent to {@link EbeanServer#getReference(Class, Object)}
-     */
-    public T ref(I id) {
-      return db().getReference(type, id);
-    }
-
-    /**
-     * Creates a filter for sorting and filtering lists of entities locally without going back to
-     * the database.
-     * <p>
-     * Equivalent to {@link EbeanServer#filter(Class)}
-     */
-    public Filter<T> filter() {
-      return db().filter(type);
-    }
-
-    /**
-     * Creates a query.
-     * <p>
-     * Equivalent to {@link EbeanServer#find(Class)}
-     */
-    public Query<T> query() {
-      return db().find(type);
-    }
-
-    /**
-     * Creates a query applying the path properties to set the select and fetch clauses.
-     */
-    public Query<T> apply(PathProperties pathProperties) {
-      return db().find(type).apply(pathProperties);
-    }
-
-    /**
-     * Returns the next identity value.
-     * 
-     * @see EbeanServer#nextId(Class)
-     */
-    @SuppressWarnings("unchecked")
-    public I nextId() {
-      return (I) db().nextId(type);
-    }
-
-    /**
-     * Executes a query and returns the results as a list of IDs.
-     * <p>
-     * Equivalent to {@link Query#findIds()}
-     */
-    public List<Object> findIds() {
-      return query().findIds();
-    }
-
-    /**
-     * Execute the query consuming each bean one at a time.
-     * <p>
-     * This is generally used to process large queries where unlike findList
-     * you do not want to hold all the results in memory at once but instead
-     * process them one at a time (requiring far less memory).
-     * </p>
-     * Equivalent to {@link Query#findEach(QueryEachConsumer)}
-     */
-    public void findEach(QueryEachConsumer<T> consumer) {
-      query().findEach(consumer);
-    }
-
-    /**
-     * Execute the query consuming each bean one at a time.
-     * <p>
-     * This is similar to #findEach except that you return boolean
-     * true to continue processing beans and return false to stop
-     * processing early.
-     * </p>
-     * <p>
-     * This is generally used to process large queries where unlike findList
-     * you do not want to hold all the results in memory at once but instead
-     * process them one at a time (requiring far less memory).
-     * </p>
-     * Equivalent to {@link Query#findEachWhile(QueryEachWhileConsumer)}
-     */
-    public void findEachWhile(QueryEachWhileConsumer<T> consumer) {
-      query().findEachWhile(consumer);
-    }
-
-    /**
-     * Retrieves all entities of the given type.
-     * <p>
-     * The same as {@link #all()}
-     * <p>
-     * Equivalent to {@link Query#findList()}
-     */
-    public List<T> findList() {
-      return query().findList();
-    }
-
-    /**
-     * Returns all the entities of the given type as a set.
-     * <p>
-     * Equivalent to {@link Query#findSet()}
-     */
-    public Set<T> findSet() {
-      return query().findSet();
-    }
-
-    /**
-     * Retrieves all entities of the given type as a map of objects.
-     * <p>
-     * Equivalent to {@link Query#findMap()}
-     */
-    public Map<?, T> findMap() {
-      return query().findMap();
-    }
-
-    /**
-     * Executes the query and returns the results as a map of the objects specifying the map key
-     * property.
-     * <p>
-     * Equivalent to {@link Query#findMap(String, Class)}
-     */
-    public <K> Map<K, T> findMap(String keyProperty, Class<K> keyType) {
-      return query().findMap(keyProperty, keyType);
-    }
-
-    /**
-     * Return a PagedList of all entities of the given type (use where() to specify predicates as
-     * needed).
-     * <p>
-     * Equivalent to {@link Query#findPagedList(int, int)}
-     */
-    public PagedList<T> findPagedList(int pageIndex, int pageSize) {
-      return query().findPagedList(pageIndex, pageSize);
-    }
-
-    /**
-     * Executes a find row count query in a background thread.
-     * <p>
-     * Equivalent to {@link Query#findFutureRowCount()}
-     */
-    public FutureRowCount<T> findFutureRowCount() {
-      return query().findFutureRowCount();
-    }
-
-    /**
-     * Returns the total number of entities for this type. *
-     * <p>
-     * Equivalent to {@link Query#findRowCount()}
-     */
-    public int findRowCount() {
-      return query().findRowCount();
-    }
-
-    /**
-     * Returns the <code>ExpressionFactory</code> used by this query.
-     */
-    public ExpressionFactory getExpressionFactory() {
-      return query().getExpressionFactory();
-    }
-
-    /**
-     * Explicitly sets a comma delimited list of the properties to fetch on the 'main' entity bean,
-     * to load a partial object.
-     * <p>
-     * Equivalent to {@link Query#select(String)}
-     */
-    public Query<T> select(String fetchProperties) {
-      return query().select(fetchProperties);
-    }
-
-    /**
-     * Specifies a path to load including all its properties.
-     * <p>
-     * Equivalent to {@link Query#fetch(String)}
-     */
-    public Query<T> fetch(String path) {
-      return query().fetch(path);
-    }
-
-    /**
-     * Additionally specifies a <code>FetchConfig</code> to specify a 'query join' and/or define the
-     * lazy loading query.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, FetchConfig)}
-     */
-    public Query<T> fetch(String path, FetchConfig joinConfig) {
-      return query().fetch(path, joinConfig);
-    }
-
-    /**
-     * Specifies a path to fetch with a specific list properties to include, to load a partial
-     * object.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, String)}
-     */
-    public Query<T> fetch(String path, String fetchProperties) {
-      return query().fetch(path, fetchProperties);
-    }
-
-    /**
-     * Additionally specifies a <code>FetchConfig</code> to use a separate query or lazy loading to
-     * load this path.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, String, FetchConfig)}
-     */
-    public Query<T> fetch(String assocProperty, String fetchProperties, FetchConfig fetchConfig) {
-      return query().fetch(assocProperty, fetchProperties, fetchConfig);
-    }
-
-    /**
-     * Adds expressions to the <code>where</code> clause with the ability to chain on the
-     * <code>ExpressionList</code>.
-     * <p>
-     * Equivalent to {@link Query#where()}
-     */
-    public ExpressionList<T> where() {
-      return query().where();
-    }
-
-    /**
-     * Returns the <code>order by</code> clause so that you can append an ascending or descending
-     * property to the <code>order by</code> clause.
-     * <p>
-     * This is exactly the same as {@link #orderBy}.
-     * <p>
-     * Equivalent to {@link Query#order()}
-     */
-    public OrderBy<T> order() {
-      return query().order();
-    }
-
-    /**
-     * Sets the <code>order by</code> clause, replacing the existing <code>order by</code> clause if
-     * there is one.
-     * <p>
-     * This is exactly the same as {@link #orderBy(String)}.
-     */
-    public Query<T> order(String orderByClause) {
-      return query().order(orderByClause);
-    }
-
-    /**
-     * Returns the <code>order by</code> clause so that you can append an ascending or descending
-     * property to the <code>order by</code> clause.
-     * <p>
-     * This is exactly the same as {@link #order}.
-     * <p>
-     * Equivalent to {@link Query#orderBy()}
-     */
-    public OrderBy<T> orderBy() {
-      return query().orderBy();
-    }
-
-    /**
-     * Set the <code>order by</code> clause replacing the existing <code>order by</code> clause if
-     * there is one.
-     * <p>
-     * This is exactly the same as {@link #order(String)}.
-     */
-    public Query<T> orderBy(String orderByClause) {
-      return query().orderBy(orderByClause);
-    }
-
-    /**
-     * Sets the first row to return for this query.
-     * <p>
-     * Equivalent to {@link Query#setFirstRow(int)}
-     */
-    public Query<T> setFirstRow(int firstRow) {
-      return query().setFirstRow(firstRow);
-    }
-
-    /**
-     * Sets the maximum number of rows to return in the query.
-     * <p>
-     * Equivalent to {@link Query#setMaxRows(int)}
-     */
-    public Query<T> setMaxRows(int maxRows) {
-      return query().setMaxRows(maxRows);
-    }
-
-    /**
-     * Sets the ID value to query.
-     * 
-     * <p>
-     * Use this to perform a find byId query but with additional control over the query such as
-     * using select and fetch to control what parts of the object graph are returned.
-     * <p>
-     * Equivalent to {@link Query#setId(Object)}
-     */
-    public Query<T> setId(Object id) {
-      return query().setId(id);
-    }
-
-    /**
-     * Create and return a new query using the OQL.
-     * <p>
-     * Equivalent to {@link EbeanServer#createQuery(Class, String)}
-     */
-    public Query<T> setQuery(String oql) {
-      return db().createQuery(type, oql);
-    }
-
-    /**
-     * Create and return a new query based on the <code>RawSql</code>.
-     * <p>
-     * Equivalent to {@link Query#setRawSql(RawSql)}
-     */
-    public Query<T> setRawSql(RawSql rawSql) {
-      return query().setRawSql(rawSql);
-    }
-
-    /**
-     * Create a query with explicit 'Autofetch' use.
-     */
-    public Query<T> setAutofetch(boolean autofetch) {
-      return query().setAutofetch(autofetch);
-    }
-
-    /**
-     * Create a query with the select with "for update" specified.
-     * 
-     * <p>
-     * This will typically create row level database locks on the selected rows.
-     */
-    public Query<T> setForUpdate(boolean forUpdate) {
-      return query().setForUpdate(forUpdate);
-    }
-
-    /**
-     * Create a query specifying whether the returned beans will be read-only.
-     */
-    public Query<T> setReadOnly(boolean readOnly) {
-      return query().setReadOnly(readOnly);
-    }
-
-    /**
-     * Create a query specifying if the beans should be loaded into the L2 cache.
-     */
-    public Query<T> setLoadBeanCache(boolean loadBeanCache) {
-      return query().setLoadBeanCache(loadBeanCache);
-    }
-
-    /**
-     * Create a query specifying if the L2 bean cache should be used.
-     */
-    public Query<T> setUseCache(boolean useBeanCache) {
-      return query().setUseCache(useBeanCache);
-    }
-
-    /**
-     * Create a query specifying if the L2 query cache should be used.
-     */
-    public Query<T> setUseQueryCache(boolean useQueryCache) {
-      return query().setUseQueryCache(useQueryCache);
-    }
-
-  }
-}

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

@@ -1,80 +0,0 @@
-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>
- * 
- * @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.
-   */
-  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 that query.
-   */
-  public Future<Integer> getFutureRowCount();
-
-  /**
-   * Return the list of entities for this page.
-   */
-  public List<T> getList();
-
-  /**
-   * Return the total row count for all pages.
-   */
-  public int getTotalRowCount();
-
-  /**
-   * Return the total number of pages based on the page size and total row count.
-   */
-  public int getTotalPageCount();
-
-  /**
-   * Return the index position of this page. Zero based.
-   */
-  public int getPageIndex();
-
-  /**
-   * Return true if there is a next page.
-   */
-  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.
-   * 
-   * @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);
-}

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

@@ -1,35 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Defines the scope for PersistenceContext.
- * <p/>
- * Ebean has traditionally used Transaction scope for the PersistenceContext. This is used to change the scope to
- * use (by default) and explicitly set the scope to use for an individual query.
- *
- * @see com.avaje.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)
- * @see com.avaje.ebean.Query#setPersistenceContextScope(PersistenceContextScope)
- */
-public enum PersistenceContextScope {
-
-  /**
-   * PersistenceContext is scoped to the transaction.
-   * <p/>
-   * If a transaction spans 2 or more queries that fetch the same bean in terms of same type
-   * and same Id value then they share the same bean instance.
-   * <p/>
-   * You may want to change to use QUERY scope when you want a query executing in a transaction to effectively
-   * ignore beans that have already been loaded (by other queries in the same transaction) and instead get a
-   * 'fresh copy' of the bean.
-   */
-  TRANSACTION,
-
-  /**
-   * PersistenceContext is scoped to the query.
-   * <p/>
-   * This means that for this query running in an existing transaction then it will effectively ignore any beans
-   * that have already been queried/loaded by prior queries in the same transaction.
-   * <p/>
-   * You may use QUERY scope on a query that is executed in a transaction and you want to get a 'fresh copy' of the bean.
-   */
-  QUERY
-}

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

@@ -1,7 +1,5 @@
 package com.avaje.ebean;
 
-import com.avaje.ebean.text.PathProperties;
-
 import java.io.Serializable;
 import java.util.List;
 import java.util.Map;
@@ -301,21 +299,6 @@ public interface Query<T> extends Serializable {
    */
   public Query<T> copy();
 
-  /**
-   * Specify the PersistenceContextScope to use for this query.
-   * <p/>
-   * When this is not set the 'default' configured on {@link com.avaje.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)}
-   * is used - this value defaults to {@link com.avaje.ebean.PersistenceContextScope#TRANSACTION}.
-   * <p/>
-   * Note that the same persistence Context is used for subsequent lazy loading and query join queries.
-   * <p/>
-   * Note that #findEach uses a 'per object graph' PersistenceContext so this scope is ignored for
-   * queries executed as #findIterate, #findEach, #findEachWhile.
-   *
-   * @param scope The scope to use for this query and subsequent lazy loading.
-   */
-  public Query<T> setPersistenceContextScope(PersistenceContextScope scope);
-
   /**
    * Return the ExpressionFactory used by this query.
    */
@@ -340,32 +323,22 @@ public interface Query<T> extends Serializable {
    */
   public Query<T> setAutofetch(boolean autofetch);
 
-  /**
-   * Set the default lazy loading batch size to use.
-   * <p>
-   * When lazy loading is invoked on beans loaded by this query then this sets the
-   * batch size used to load those beans.
-   *
-   * @param lazyLoadBatchSize the number of beans to lazy load in a single batch
-   */
-  public Query<T> setLazyLoadBatchSize(int lazyLoadBatchSize);
-
   /**
    * Explicitly set a comma delimited list of the properties to fetch on the
    * 'main' entity bean (aka partial object). Note that '*' means all
    * properties.
-   *
+   * 
    * <pre class="code">
    * Query&lt;Customer&gt; query = Ebean.createQuery(Customer.class);
-   *
+   * 
    * // Only fetch the customer id, name and status.
    * // This is described as a &quot;Partial Object&quot;
    * query.select(&quot;name, status&quot;);
    * query.where(&quot;lower(name) like :custname&quot;).setParameter(&quot;custname&quot;, &quot;rob%&quot;);
-   *
+   * 
    * List&lt;Customer&gt; customerList = query.findList();
    * </pre>
-   *
+   * 
    * @param fetchProperties
    *          the properties to fetch for this bean (* = all properties).
    */
@@ -440,14 +413,6 @@ public interface Query<T> extends Serializable {
    */
   public Query<T> fetch(String path, FetchConfig joinConfig);
 
-  /**
-   * Apply the path properties replacing the select and fetch clauses.
-   * <p>
-   * This is typically used when the PathProperties is applied to both the query and the JSON output.
-   * </p>
-   */
-  public Query<T> apply(PathProperties pathProperties);
-
   /**
    * Execute the query returning the list of Id's.
    * <p>
@@ -471,89 +436,37 @@ public interface Query<T> extends Serializable {
    */
   public QueryIterator<T> findIterate();
 
-  /**
-   * This is deprecated in favor of #findEachWhile.
-   * <p>
-   * This is functionally exactly the same as #findEachWhile.  It is
-   * replaced by findEachWhile because the method name is much better.
-   * </p>
-   *
-   * @param visitor
-   *          the visitor used to process the queried beans.
-   *
-   * @deprecated
-   */
-  public void findVisit(QueryResultVisitor<T> visitor);
-
-  /**
-   * Execute the query processing the beans one at a time.
-   * <p>
-   * This method is appropriate to process very large query results as the
-   * beans are consumed one at a time and do not need to be held in memory
-   * (unlike #findList #findSet etc)
-   * </p>
-   * <p>
-   * Compared with #findEachWhile this will always process all the beans where as
-   * #findEachWhile provides a way to stop processing the query result early before
-   * all the beans have been read.
-   * </p>
-   * <p>
-   * This method is functionally equivalent to findIterate() but instead of using an
-   * iterator uses the QueryEachConsumer (SAM) interface which is better suited to use
-   * with Java8 closures.
-   * </p>
-   *
-   * <pre class="code">
-   *
-   * Query&lt;Customer&gt; query = server.find(Customer.class)
-   *     .where().gt(&quot;id&quot;, 0)
-   *     .orderBy(&quot;id&quot;)
-   *     .setMaxRows(2);
-   *
-   * query.findVisit((Customer customer) -> {
-   *
-   *     // do something with customer
-   *     System.out.println(&quot;-- visit &quot; + customer);
-   * });
-   * </pre>
-   *
-   * @param consumer
-   *          the consumer used to process the queried beans.
-   */
-  public void findEach(QueryEachConsumer<T> consumer);
-
   /**
    * Execute the query using callbacks to a visitor to process the resulting
    * beans one at a time.
    * <p>
-   * This method is functionally equivalent to findIterate() but instead of using an
-   * iterator uses the QueryEachWhileConsumer (SAM) interface which is better suited to use
-   * with Java8 closures.
+   * Similar to findIterate() this query method does not require all the result
+   * beans to be all held in memory at once and as such is 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.findEachWhile((Customer customer) -> {
-   *
+   * 
+   * 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 to continue processing or false to stop
-   *     return (customer.getId() < 40);
+   *     return true;
+   *   }
    * });
    * </pre>
-   *
-   * @param consumer
-   *          the consumer used to process the queried beans.
+   * 
+   * @param visitor
+   *          the visitor used to process the queried beans.
    */
-  public void findEachWhile(QueryEachWhileConsumer<T> consumer);
+  public void findVisit(QueryResultVisitor<T> visitor);
 
   /**
    * Execute the query returning the list of objects.
@@ -676,42 +589,34 @@ public interface Query<T> extends Serializable {
   /**
    * Execute find list query in a background thread.
    * <p>
-   * Deprecated with a view to simplifying internals.
+   * 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 FutureList<T> findFutureList();
 
   /**
-   * This is being deprecated in favour of the simplier {@link Query#findPagedList(int, int)}.
+   * Return a PagingList for this query.
+   * <p>
+   * This can be used to break up a query into multiple queries to fetch the
+   * data a page at a time.
+   * </p>
+   * <p>
+   * This typically works by using a query per page and setting
+   * {@link Query#setFirstRow(int)} and and {@link Query#setMaxRows(int)} on the
+   * query. This usually would translate into SQL that uses limit offset, rownum
+   * or row_number function to limit the result set.
+   * </p>
+   * 
+   * @param pageSize
+   *          the number of beans fetched per Page
    * 
-   * @deprecated
    */
   public PagingList<T> findPagingList(int pageSize);
 
-  /**
-   * Return a PagedList for this query.
-   * <p>
-   * The benefit of using this over just using the normal {@link Query#setFirstRow(int)} and
-   * {@link Query#setMaxRows(int)} is that it additionally wraps an optional call to
-   * {@link Query#findFutureRowCount()} to determine total row count, total page count etc.
-   * </p>
-   * <p>
-   * Internally this works using {@link Query#setFirstRow(int)} and {@link Query#setMaxRows(int)} on
-   * the query. This translates into SQL that uses limit offset, rownum or row_number function to
-   * limit the result set.
-   * </p>
-   * 
-   * @param pageIndex
-   *          The zero based index of the page.
-   * @param pageSize
-   *          The number of beans to return per page.
-   * @return The PagedList
-   */
-  public PagedList<T> findPagedList(int pageIndex, int pageSize);
-
   /**
    * Set a named bind parameter. Named parameters have a colon to prefix the
    * name.

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

@@ -1,41 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to process a query result one bean at a time via a callback to this
- * visitor.
- * <p>
- * If you wish to stop further processing return false from the accept method.
- * </p>
- * <p>
- * Unlike findList() and findSet() using a QueryResultVisitor does not require
- * all the beans in the query result to be held in memory at once. This makes
- * QueryResultVisitor useful for processing large queries.
- * </p>
- *
- * <pre class="code">
- *
- * Query&lt;Customer&gt; query = server.find(Customer.class)
- *     .where().gt(&quot;id&quot;, 0)
- *     .orderBy(&quot;id&quot;)
- *     .setMaxRows(2);
- *
- * query.findVisit((Customer customer) -> {
- *
- *     // do something with customer
- *     System.out.println(&quot;-- visit &quot; + 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);
-}

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

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

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

@@ -0,0 +1,43 @@
+package com.avaje.ebean;
+
+/**
+ * Deprecated, please migrate to using {@link #findIterate()} or {@link #findVisit(QueryResultVisitor)}
+ * <p>
+ * Provides a mechanism for processing a query one bean at a time.
+ * </p>
+ * <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 whole all of the beans in
+ * memory at once.
+ * </p>
+ * 
+ * <pre class="code">
+ * QueryListener&lt;Order&gt; listener = ...;
+ *    
+ * Query&lt;Order&gt; query  = Ebean.createQuery(Order.class);
+ *    
+ * // set the listener that will process each order 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>
+ * 
+ * @param <T>
+ *          the type of entity bean
+ * @deprecated Please migrate to using {@link #findIterate()} or
+ *             {@link #findVisit(QueryResultVisitor)}
+ */
+public interface QueryListener<T> {
+
+  /**
+   * Process the bean that has just been read.
+   * <p>
+   * This bean will not be added to the List Set or Map and nor will it be put
+   * into the PersistenceContext. This is what makes this a good way to process
+   * a large result set (which could normally use a lot of memory).
+   * </p>
+   */
+  public void process(T bean);
+}

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

@@ -1,7 +1,6 @@
 package com.avaje.ebean;
 
 import java.io.Serializable;
-import java.sql.ResultSet;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -136,33 +135,18 @@ import com.avaje.ebean.util.CamelCaseHelper;
  * Note that lazy loading also works with object graphs built with RawSql.
  * </p>
  * 
+ * @author rbygrave
+ * 
  */
 public final class RawSql implements Serializable {
 
   private static final long serialVersionUID = 1L;
 
-  private final ResultSet resultSet;
-  
   private final Sql sql;
 
   private final ColumnMapping columnMapping;
 
-  /**
-   * Construct with a ResultSet and properties that the columns map to.
-   * <p>
-   * The properties listed in the propertyNames must be in the same order as the columns in the
-   * resultSet.
-   * <p>
-   * When a query executes this RawSql object then it will close the resultSet.
-   */
-  public RawSql(ResultSet resultSet, String... propertyNames) {
-    this.resultSet = resultSet;
-    this.sql = null;
-    this.columnMapping = new ColumnMapping(propertyNames);
-  }
-  
-  protected RawSql(ResultSet resultSet, Sql sql, ColumnMapping columnMapping) {
-    this.resultSet = resultSet;
+  protected RawSql(Sql sql, ColumnMapping columnMapping) {
     this.sql = sql;
     this.columnMapping = columnMapping;
   }
@@ -174,14 +158,6 @@ public final class RawSql implements Serializable {
     return sql;
   }
 
-  
-  /**
-   * Return the resultSet if this is a ResultSet based RawSql.
-   */
-  public ResultSet getResultSet() {
-    return resultSet;
-  }
-
   /**
    * Return the column mapping for the SQL columns to bean properties.
    */
@@ -193,9 +169,6 @@ public final class RawSql implements Serializable {
    * Return the hash for this query.
    */
   public int queryHash() {
-    if (resultSet != null) {
-      return 31 * columnMapping.queryHash();
-    }
     return 31 * sql.queryHash() + columnMapping.queryHash();
   }
 
@@ -356,7 +329,6 @@ public final class RawSql implements Serializable {
     private final LinkedHashMap<String, Column> dbColumnMap;
 
     private final Map<String, String> propertyMap;
-    
     private final Map<String, Column> propertyColumnMap;
 
     private final boolean parsed;
@@ -392,26 +364,6 @@ public final class RawSql implements Serializable {
       this.propertyColumnMap = null;
       this.dbColumnMap = new LinkedHashMap<String, Column>();
     }
-    
-    /**
-     * Construct for ResultSet use.
-     */
-    protected ColumnMapping(String... propertyNames) {
-      this.immutable = false;
-      this.parsed = false;
-      this.propertyMap = null;
-      //this.propertyColumnMap = null;
-      this.dbColumnMap = new LinkedHashMap<String, Column>();
-      
-      int hc = 31;
-      int pos = 0;
-      for (String prop : propertyNames) {
-        hc = 31 * hc + prop.hashCode();
-        dbColumnMap.put(prop, new Column(pos++, prop, null, prop));
-      }
-      propertyColumnMap = dbColumnMap;
-      this.queryHashCode = hc;
-    }
 
     /**
      * Construct an immutable ColumnMapping based on collected information.

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

@@ -1,7 +1,5 @@
 package com.avaje.ebean;
 
-import java.sql.ResultSet;
-
 import com.avaje.ebean.RawSql.ColumnMapping;
 import com.avaje.ebean.RawSql.Sql;
 
@@ -12,6 +10,8 @@ import com.avaje.ebean.RawSql.Sql;
  * named query.
  * </p>
  * 
+ * @author rbygrave
+ * 
  * @see RawSql
  */
 public class RawSqlBuilder {
@@ -21,23 +21,10 @@ public class RawSqlBuilder {
    */
   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
@@ -71,17 +58,9 @@ public class RawSqlBuilder {
     return new RawSqlBuilder(sql2, mapping);
   }
 
-  
-  private RawSqlBuilder(ResultSet resultSet, ColumnMapping columnMapping) {
-    this.resultSet = resultSet;
-    this.columnMapping = columnMapping;
-    this.sql = null;
-  }
-  
   private RawSqlBuilder(Sql sql, ColumnMapping columnMapping) {
     this.sql = sql;
     this.columnMapping = columnMapping;
-    this.resultSet = null;
   }
 
   /**
@@ -113,7 +92,7 @@ public class RawSqlBuilder {
    * has been defined.
    */
   public RawSql create() {
-    return new RawSql(resultSet, sql, columnMapping.createImmutableCopy());
+    return new RawSql(sql, columnMapping.createImmutableCopy());
   }
 
   /**
@@ -122,6 +101,4 @@ public class RawSqlBuilder {
   protected Sql getSql() {
     return sql;
   }
-  
-
 }

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

@@ -1,6 +1,6 @@
 package com.avaje.ebean;
 
-class SimpleTextParser {
+public class SimpleTextParser {
 
   private final String oql;
   private final char[] chars;
@@ -10,7 +10,9 @@ class SimpleTextParser {
   private String word;
   private String lowerWord;
 
-  SimpleTextParser(String oql) {
+  private int openParenthesisCount;
+
+  public SimpleTextParser(String oql) {
     this.oql = oql;
     this.chars = oql.toCharArray();
     this.eof = oql.length();
@@ -20,6 +22,10 @@ class SimpleTextParser {
     return pos;
   }
 
+  public String getOql() {
+    return oql;
+  }
+
   public String getWord() {
     return word;
   }
@@ -98,7 +104,7 @@ class SimpleTextParser {
   private void moveToClose() {
 
     pos++;
-    int openParenthesisCount = 0;
+    openParenthesisCount = 0;
 
     for (; pos < eof; pos++) {
       char c = chars[pos];
@@ -137,7 +143,11 @@ class SimpleTextParser {
     if (isOperator(c)) {
       return !isOperator;
     }
-    return c == '(' || isOperator;
+    if (c == '(') {
+      return true;
+    }
+
+    return isOperator;
   }
 
   private boolean isOperator(char c) {

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

@@ -79,7 +79,6 @@ public interface SqlQuery extends Serializable {
    * </p>
    * 
    * @return a Future object for the list result of the query
-   * @deprecated
    */
   public SqlFutureList findFutureList();
 

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

@@ -91,11 +91,6 @@ public interface SqlUpdate {
    */
   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.
    */

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

@@ -35,11 +35,6 @@ public interface Transaction extends Closeable {
    */
   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.
    */

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

@@ -1,34 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Provides a callback that can be registered with a Transaction.
- * <p/>
- * The callback methods are called just prior to and after the transaction performs a commit or rollback.
- * <p/>
- * A typical use of TransactionCallback would be to clean up non-transactional resources like files. For example,
- * when processing files on postCommit/postRollback clean up the associated files. As another example when
- * on postCommit of a delete remove associated resources from the file system or remote service.
- */
-public interface TransactionCallback {
-
-  /**
-   * Perform processing just prior to the transaction commit.
-   */
-  void preCommit();
-
-  /**
-   * Perform processing just after the transaction commit.
-   */
-  void postCommit();
-
-  /**
-   * Perform processing just prior to the transaction rollback.
-   */
-  void preRollback();
-
-  /**
-   * Perform processing just after the transaction rollback.
-   */
-  void postRollback();
-
-}

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

@@ -1,42 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Adapter that can be extended for easier implementation of TransactionCallback.
- * <p/>
- * Provides 'no operation' implementation for each of the TransactionCallback methods. It is expected that this
- * class is extended and override the methods you need to.
- */
-public abstract class TransactionCallbackAdapter implements TransactionCallback {
-
-  /**
-   * Perform processing just prior to the transaction commit.
-   */
-  @Override
-  public void preCommit() {
-    // do nothing - override as necessary
-  }
-
-  /**
-   * Perform processing just after the transaction commit.
-   */
-  @Override
-  public void postCommit() {
-    // do nothing - override as necessary
-  }
-
-  /**
-   * Perform processing just prior to the transaction rollback.
-   */
-  @Override
-  public void preRollback() {
-    // do nothing - override as necessary
-  }
-
-  /**
-   * Perform processing just after the transaction rollback.
-   */
-  @Override
-  public void postRollback() {
-    // do nothing - override as necessary
-  }
-}

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

@@ -5,46 +5,30 @@ package com.avaje.ebean;
  */
 public class ValuePair {
 
-  private final Object newValue;
+  final Object value1;
 
-  private final Object oldValue;
+  final Object value2;
 
-  public ValuePair(Object newValue, Object oldValue) {
-    this.newValue = newValue;
-    this.oldValue = oldValue;
+  public ValuePair(Object value1, Object value2) {
+    this.value1 = value1;
+    this.value2 = value2;
   }
 
   /**
-   * Return the new value.
+   * Return the first 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 value1;
   }
 
   /**
-   * Return the old value.
+   * Return the second value.
    */
-  @Deprecated
   public Object getValue2() {
-    return oldValue;
+    return value2;
   }
 
   public String toString() {
-    return newValue + "," + oldValue;
+    return value1 + "," + value2;
   }
 }

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

@@ -1,15 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface ColumnHstore {
-
-}

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

@@ -13,5 +13,10 @@ public enum ConcurrencyMode {
 	/**
 	 * Use a version column.
 	 */
-	VERSION
+	VERSION,
+	
+	/**
+	 * Use all the columns (except Lobs).
+	 */
+	ALL
 }

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

@@ -1,24 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * An annotation for declaring an index on a single column.
- *
- * @author rvbiljouw
- */
-@Target({ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Index {
-
-    /**
-     * Name of the index
-     *
-     * @return index name
-     */
-    String value() default "";
-
-}

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

@@ -55,6 +55,21 @@ import com.avaje.ebean.TxType;
  *    Ebean.save(order);
  *  }
  * </pre>
+ * 
+ * <p>
+ * During development and testing you can set a debug level which will log the
+ * transaction begin, commit and rollback events so that you can easily confirm
+ * it is behaving as you would expect.
+ * </p>
+ * 
+ * <pre class="code">
+ *  ## in ebean.properties file
+ *  
+ *  ## Log transaction begins and ends etc
+ *  ## (0=NoLogging 1=minimal ... 9=logAll)
+ *  ebean.debug.transaction=3
+ * 
+ * </pre>
  */
 @Target({ ElementType.METHOD, ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)

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

@@ -3,8 +3,11 @@ package com.avaje.ebean.bean;
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Set;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 import com.avaje.ebean.ExpressionList;
+import com.avaje.ebean.Query;
 
 /**
  * Lazy loading capable Maps, Lists and Sets.
@@ -31,29 +34,24 @@ public interface BeanCollection<E> extends Serializable {
     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();
+  public Object getOwnerBean();
 
   /**
    * Return the bean property name this collection represents.
    */
   public String getPropertyName();
 
+  /**
+   * Return the index position of this collection in the lazy/query loader.
+   * <p>
+   * Used for batch loading of collections.
+   * </p>
+   */
+  public int getLoaderIndex();
+
   /**
    * Check after the lazy load that the underlying collection is not null
    * (handle case where join to many not outer).
@@ -77,6 +75,30 @@ public interface BeanCollection<E> extends Serializable {
    */
   public void setFilterMany(ExpressionList<?> filterMany);
 
+  /**
+   * Set when this collection is being loaded via a background thread.
+   * <p>
+   * Refer to {@link Query#setBackgroundFetchAfter(int)}
+   * </p>
+   */
+  public void setBackgroundFetch(Future<Integer> future);
+
+  /**
+   * Wait for the fetch to complete with a given timeout.
+   * <p>
+   * Refer to {@link Query#setBackgroundFetchAfter(int)}
+   * </p>
+   */
+  public void backgroundFetchWait(long wait, TimeUnit timeUnit);
+
+  /**
+   * Wait for the fetch to complete.
+   * <p>
+   * Refer to {@link Query#setBackgroundFetchAfter(int)}
+   * </p>
+   */
+  public void backgroundFetchWait();
+
   /**
    * Set a listener to be notified when the BeanCollection is first touched.
    */
@@ -107,6 +129,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   public void internalAdd(Object bean);
 
+  /**
+   * Returns the underlying List Set or Map object.
+   */
+  public Object getActualCollection();
+
   /**
    * Return the number of elements in the List Set or Map.
    */
@@ -131,6 +158,34 @@ public interface BeanCollection<E> extends Serializable {
    */
   public Collection<?> getActualEntries();
 
+  /**
+   * Set to true if maxRows was hit and there are actually more rows available.
+   * <p>
+   * Can be used by client code that is paging through results using
+   * setFirstRow() setMaxRows(). If this returns true then the client can
+   * display a 'next' button etc.
+   * </p>
+   */
+  public boolean hasMoreRows();
+
+  /**
+   * Set to true when maxRows is hit but there are actually more rows available.
+   * This is set so that client code knows that there is more data available.
+   */
+  public void setHasMoreRows(boolean hasMoreRows);
+
+  /**
+   * Returns true if the fetch has finished. False if the fetch is continuing in
+   * a background thread.
+   */
+  public boolean isFinishedFetch();
+
+  /**
+   * Set to true when a fetch has finished. Used when a fetch continues in the
+   * background.
+   */
+  public void setFinishedFetch(boolean finishedFetch);
+
   /**
    * 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

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

@@ -12,5 +12,5 @@ public interface BeanCollectionAdd {
   /**
    * Add a loaded bean to the collection.
    */
-  public void addBean(EntityBean bean);
+  public void addBean(Object bean);
 }

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

@@ -14,10 +14,6 @@ import java.io.Serializable;
  */
 public interface EntityBean extends Serializable {
 
-  public String[] _ebean_getPropertyNames();
-  
-  public String _ebean_getPropertyName(int pos);
-  
   /**
    * Return the enhancement marker value.
    * <p>
@@ -83,19 +79,31 @@ public interface EntityBean extends Serializable {
    */
   public Object _ebean_createCopy();
 
+  /**
+   * Return the fields in their index order.
+   */
+  public String[] _ebean_getFieldNames();
+
   /**
    * 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>
+   * 
+   * @param fieldIndex
+   *          the index of the field
+   * @param entityBean
+   *          the entityBean of this type to modify
+   * @param value
+   *          the value to set
    */
-  public void _ebean_setField(int fieldIndex, Object value);
+  public void _ebean_setField(int fieldIndex, Object entityBean, Object value);
 
   /**
    * Set the field value with interception.
    */
-  public void _ebean_setFieldIntercept(int fieldIndex, Object value);
+  public void _ebean_setFieldIntercept(int fieldIndex, Object entityBean, Object value);
 
   /**
    * Return the value of a field from an entity bean of this type.
@@ -103,12 +111,17 @@ public interface EntityBean extends Serializable {
    * Note that using this method bypasses any interception that otherwise occurs
    * on entity beans. That means lazy loading.
    * </p>
+   * 
+   * @param fieldIndex
+   *          the index of the field
+   * @param entityBean
+   *          the entityBean to get the value from
    */
-  public Object _ebean_getField(int fieldIndex);
+  public Object _ebean_getField(int fieldIndex, Object entityBean);
 
   /**
    * Return the field value with interception.
    */
-  public Object _ebean_getFieldIntercept(int fieldIndex);
+  public Object _ebean_getFieldIntercept(int fieldIndex, Object entityBean);
 
 }

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

@@ -1,6 +1,8 @@
 package com.avaje.ebean.common;
 
 import java.util.Set;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 import javax.persistence.PersistenceException;
 
@@ -10,6 +12,7 @@ import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.BeanCollectionLoader;
 import com.avaje.ebean.bean.BeanCollectionTouched;
 import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebean.bean.EntityBeanIntercept;
 
 /**
  * Base class for List Set and Map implementations of BeanCollection.
@@ -35,15 +38,30 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
 
   protected transient BeanCollectionTouched beanCollectionTouched;
 
+  protected transient Future<Integer> fetchFuture;
+
   /**
    * The owning bean (used for lazy fetch).
    */
-  protected EntityBean ownerBean;
+  protected final Object ownerBean;
 
   /**
    * The name of this property in the owning bean (used for lazy fetch).
    */
-  protected String propertyName;
+  protected final String propertyName;
+
+  /**
+   * Can be false when a background thread is used to continue the fetch the
+   * rows. It will set this to true when it is finished. If no background thread
+   * is used then this should already be true.
+   */
+  protected boolean finishedFetch = true;
+
+  /**
+   * Flag set to true if rows are limited by firstRow maxRows and more rows
+   * exist. For use by client to enable 'next' for paging.
+   */
+  protected boolean hasMoreRows;
 
   protected ModifyHolder<E> modifyHolder;
 
@@ -52,30 +70,30 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   protected boolean modifyRemoveListening;
   protected boolean modifyListening;
 
-  /**
-   * Flag used to tell if empty collections have been cleared etc or just
-   * uninitialised.
-   */
-  protected boolean touched;
-
   /**
    * Constructor not non-lazy loading collection.
    */
   public AbstractBeanCollection() {
+    this.ownerBean = null;
+    this.propertyName = null;
   }
 
   /**
    * Used to create deferred fetch proxy.
    */
-  public AbstractBeanCollection(BeanCollectionLoader loader, EntityBean ownerBean, String propertyName) {
+  public AbstractBeanCollection(BeanCollectionLoader loader, Object ownerBean, String propertyName) {
     this.loader = loader;
     this.ebeanServerName = loader.getName();
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
-    this.readOnly = ownerBean._ebean_getIntercept().isReadOnly();
+
+    if (ownerBean instanceof EntityBean) {
+      EntityBeanIntercept ebi = ((EntityBean) ownerBean)._ebean_getIntercept();
+      this.readOnly = ebi.isReadOnly();
+    }
   }
 
-  public EntityBean getOwnerBean() {
+  public Object getOwnerBean() {
     return ownerBean;
   }
 
@@ -83,6 +101,10 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     return propertyName;
   }
 
+  public int getLoaderIndex() {
+    return loaderIndex;
+  }
+
   public ExpressionList<?> getFilterMany() {
     return filterMany;
   }
@@ -106,14 +128,7 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     checkEmptyLazyLoad();
   }
 
-  /**
-   * Set touched. If setFlag is false then typically an isEmpty() call and still
-   * considering that to be untouched.
-   */
-  protected void touched(boolean setFlag) {
-    if (setFlag) {
-      touched = true;
-    }
+  protected void touched() {
     if (beanCollectionTouched != null) {
       // only call this once
       beanCollectionTouched.notifyTouched(this);
@@ -139,6 +154,66 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     this.readOnly = readOnly;
   }
 
+  /**
+   * Set to true if maxRows was hit and there are actually more rows available.
+   * <p>
+   * Can be used by client code that is paging through results using
+   * setFirstRow() setMaxRows(). If this returns true then the client can
+   * display a 'next' button etc.
+   * </p>
+   */
+  public boolean hasMoreRows() {
+    return hasMoreRows;
+  }
+
+  /**
+   * Set to true when maxRows is hit but there are actually more rows available.
+   * This is set so that client code knows that there is more data available.
+   */
+  public void setHasMoreRows(boolean hasMoreRows) {
+    this.hasMoreRows = hasMoreRows;
+  }
+
+  /**
+   * Returns true if the fetch has finished. False if the fetch is continuing in
+   * a background thread.
+   */
+  public boolean isFinishedFetch() {
+    return finishedFetch;
+  }
+
+  /**
+   * Set to true when a fetch has finished. Used when a fetch continues in the
+   * background.
+   */
+  public void setFinishedFetch(boolean finishedFetch) {
+    this.finishedFetch = finishedFetch;
+  }
+
+  public void setBackgroundFetch(Future<Integer> fetchFuture) {
+    this.fetchFuture = fetchFuture;
+  }
+
+  public void backgroundFetchWait(long wait, TimeUnit timeUnit) {
+    if (fetchFuture != null) {
+      try {
+        fetchFuture.get(wait, timeUnit);
+      } catch (Exception e) {
+        throw new PersistenceException(e);
+      }
+    }
+  }
+
+  public void backgroundFetchWait() {
+    if (fetchFuture != null) {
+      try {
+        fetchFuture.get();
+      } catch (Exception e) {
+        throw new PersistenceException(e);
+      }
+    }
+  }
+
   protected void checkReadOnly() {
     if (readOnly) {
       String msg = "This collection is in ReadOnly mode";

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

@@ -10,15 +10,13 @@ import java.util.ListIterator;
 
 import com.avaje.ebean.bean.BeanCollectionAdd;
 import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
 
 /**
  * List capable of lazy loading.
  */
-public final class BeanList<E> extends AbstractBeanCollection<E> implements List<E>, BeanCollectionAdd {
+public final class BeanList<E> extends AbstractBeanCollection<E> implements List<E>,
+    BeanCollectionAdd {
 
-  private static final long serialVersionUID = 1L;
-  
   /**
    * The underlying List implementation.
    */
@@ -42,25 +40,12 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   /**
    * Used to create deferred fetch proxy.
    */
-  public BeanList(BeanCollectionLoader loader, EntityBean ownerBean, String propertyName) {
+  public BeanList(BeanCollectionLoader loader, Object ownerBean, String propertyName) {
     super(loader, ownerBean, propertyName);
   }
 
-  @Override
-  public void reset(EntityBean ownerBean, String propertyName) {
-    this.ownerBean = ownerBean;
-    this.propertyName = propertyName;
-    this.list = null;
-    this.touched = false;
-  }
-
-  @Override
-  public boolean isEmptyAndUntouched() {
-    return !touched && (list == null || list.isEmpty());
-  }
-
   @SuppressWarnings("unchecked")
-  public void addBean(EntityBean bean) {
+  public void addBean(Object bean) {
     list.add((E) bean);
   }
 
@@ -90,24 +75,16 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
           list = new ArrayList<E>();
         }
       }
-      touched(true);
+      touched();
     }
   }
 
-  private void initAsUntouched() {
-    init(false);
-  }
-  
   private void init() {
-    init(true);
-  }
-  
-  private void init(boolean setTouched) {
     synchronized (this) {
       if (list == null) {
         lazyLoadCollection(false);
       }
-      touched(setTouched);
+      touched();
     }
   }
 
@@ -138,6 +115,13 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     return list;
   }
 
+  /**
+   * Returns the underlying list.
+   */
+  public Object getActualCollection() {
+    return list;
+  }
+
   /**
    * Return true if the underlying list is populated.
    */
@@ -154,7 +138,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   }
 
   public String toString() {
-    StringBuffer sb = new StringBuffer(50);
+    StringBuffer sb = new StringBuffer();
     sb.append("BeanList ");
     if (isReadOnly()) {
       sb.append("readOnly ");
@@ -164,6 +148,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
 
     } else {
       sb.append("size[").append(list.size()).append("] ");
+      sb.append("hasMoreRows[").append(hasMoreRows).append("] ");
       sb.append("list").append(list).append("");
     }
     return sb.toString();
@@ -272,7 +257,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   }
 
   public boolean isEmpty() {
-    initAsUntouched();
+    init();
     return list.isEmpty();
   }
 

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

@@ -8,15 +8,12 @@ import java.util.Map;
 import java.util.Set;
 
 import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
 
 /**
  * Map capable of lazy loading.
  */
 public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Map<K, E> {
 
-  private static final long serialVersionUID = 1L;
-
   /**
    * The underlying map implementation.
    */
@@ -36,22 +33,10 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
     this(new LinkedHashMap<K, E>());
   }
 
-  public BeanMap(BeanCollectionLoader ebeanServer, EntityBean ownerBean, String propertyName) {
+  public BeanMap(BeanCollectionLoader ebeanServer, Object ownerBean, String propertyName) {
     super(ebeanServer, ownerBean, propertyName);
   }
 
-  @Override
-  public void reset(EntityBean ownerBean, String propertyName) {
-    this.ownerBean = ownerBean;
-    this.propertyName = propertyName;
-    this.map = null;
-    this.touched = false;
-  }
-
-  public boolean isEmptyAndUntouched() {
-    return !touched && (map == null || map.isEmpty());
-  }
-
   @SuppressWarnings("unchecked")
   public void internalPut(Object key, Object bean) {
     if (map == null) {
@@ -98,24 +83,16 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
           map = new LinkedHashMap<K, E>();
         }
       }
-      touched(true);
+      touched();
     }
   }
 
-  private void initAsUntouched() {
-    init(false);
-  }
-  
   private void init() {
-    init(true);
-  }
-  
-  private void init(boolean setTouched) {
     synchronized (this) {
       if (map == null) {
         lazyLoadCollection(false);
       }
-      touched(setTouched);
+      touched();
     }
   }
 
@@ -154,8 +131,15 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
 
   }
 
+  /**
+   * Returns the underlying map.
+   */
+  public Object getActualCollection() {
+    return map;
+  }
+
   public String toString() {
-    StringBuilder sb = new StringBuilder(50);
+    StringBuffer sb = new StringBuffer();
     sb.append("BeanMap ");
     if (isReadOnly()) {
       sb.append("readOnly ");
@@ -165,6 +149,7 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
 
     } else {
       sb.append("size[").append(map.size()).append("]");
+      sb.append(" hasMoreRows[").append(hasMoreRows).append("]");
       sb.append(" map").append(map);
     }
     return sb.toString();
@@ -224,7 +209,7 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
   }
 
   public boolean isEmpty() {
-    initAsUntouched();
+    init();
     return map.isEmpty();
   }
 

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

@@ -8,15 +8,12 @@ import java.util.Set;
 
 import com.avaje.ebean.bean.BeanCollectionAdd;
 import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
 
 /**
  * Set capable of lazy loading.
  */
 public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E>, BeanCollectionAdd {
 
-  private static final long serialVersionUID = 1L;
-
   /**
    * The underlying Set implementation.
    */
@@ -36,24 +33,12 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
     this(new LinkedHashSet<E>());
   }
 
-  public BeanSet(BeanCollectionLoader loader, EntityBean ownerBean, String propertyName) {
+  public BeanSet(BeanCollectionLoader loader, Object ownerBean, String propertyName) {
     super(loader, ownerBean, propertyName);
   }
 
-  @Override
-  public void reset(EntityBean ownerBean, String propertyName) {
-    this.ownerBean = ownerBean;
-    this.propertyName = propertyName;
-    this.set = null;
-    this.touched = false;
-  }
-
-  public boolean isEmptyAndUntouched() {
-    return !touched && (set == null || set.isEmpty());
-  }
-
   @SuppressWarnings("unchecked")
-  public void addBean(EntityBean bean) {
+  public void addBean(Object bean) {
     set.add((E) bean);
   }
 
@@ -98,24 +83,16 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
           set = new LinkedHashSet<E>();
         }
       }
-      touched(true);
+      touched();
     }
   }
 
-  private void initAsUntouched() {
-    init(false);
-  }
-  
   private void init() {
-    init(true);
-  }
-  
-  private void init(boolean setTouched) {
     synchronized (this) {
       if (set == null) {
         lazyLoadCollection(true);
       }
-      touched(setTouched);
+      touched();
     }
   }
 
@@ -151,7 +128,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   }
 
   public String toString() {
-    StringBuffer sb = new StringBuffer(50);
+    StringBuffer sb = new StringBuffer();
     sb.append("BeanSet ");
     if (isReadOnly()) {
       sb.append("readOnly ");
@@ -161,6 +138,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
 
     } else {
       sb.append("size[").append(set.size()).append("]");
+      sb.append(" hasMoreRows[").append(hasMoreRows).append("]");
       sb.append(" set").append(set);
     }
     return sb.toString();
@@ -239,7 +217,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   }
 
   public boolean isEmpty() {
-    initAsUntouched();
+    init();
     return set.isEmpty();
   }
 

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

@@ -32,8 +32,6 @@ public class DataSourceConfig {
 
   private int isolationLevel = Transaction.READ_COMMITTED;
 
-  private boolean autoCommit;
-  
   private String heartbeatSql;
   
   private int heartbeatFreqSecs = 30;
@@ -133,20 +131,6 @@ public class DataSourceConfig {
   public void setIsolationLevel(int isolationLevel) {
     this.isolationLevel = isolationLevel;
   }
-  
-  /**
-   * Return autoCommit setting.
-   */
-  public boolean isAutoCommit() {
-    return autoCommit;
-  }
-
-  /**
-   * Set to true to turn on autoCommit.
-   */
-  public void setAutoCommit(boolean autoCommit) {
-    this.autoCommit = autoCommit;
-  }
 
   /**
    * Return the minimum number of connections the pool should maintain.
@@ -466,7 +450,6 @@ public class DataSourceConfig {
     String dbUrl = properties.get(prefix + "databaseUrl", null);
     this.url = properties.get(prefix + "url", dbUrl);
 
-    this.autoCommit = properties.getBoolean(prefix + "autoCommit", false);
     this.captureStackTrace = properties.getBoolean(prefix + "captureStackTrace", false);
     this.maxStackTraceSize = properties.getInt(prefix + "maxStackTraceSize", 5);
     this.leakTimeMinutes = properties.getInt(prefix + "leakTimeMinutes", 30);

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

@@ -1,29 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Configuration for JSON features.
- */
-public abstract class JsonConfig {
-
-  /**
-   * Defined the format used for DateTime types.
-   */
-  public enum DateTime {
-
-    /**
-     * Format as epoch millis.
-     */
-    MILLIS,
-
-    /**
-     * Format as epoch with nanos.
-     */
-    NANOS,
-
-    /**
-     * Format as ISO-8601 date format.
-     */
-    ISO8601
-  }
-
-}

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

@@ -1,10 +1,11 @@
 package com.avaje.ebean.config;
 
 import java.io.Serializable;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
+import java.util.Map.Entry;
 
 /**
  * A map like structure of properties.
@@ -67,8 +68,9 @@ final class PropertyMap implements Serializable {
   }
 
   synchronized void putAll(Map<String, String> keyValueMap) {
-
-    for (Map.Entry<String, String> entry : keyValueMap.entrySet()) {
+    Iterator<Entry<String, String>> it = keyValueMap.entrySet().iterator();
+    while (it.hasNext()) {
+      Map.Entry<String, String> entry = it.next();
       put(entry.getKey(), entry.getValue());
     }
   }

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

@@ -1,18 +1,20 @@
 package com.avaje.ebean.config;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.Properties;
+import java.util.Map.Entry;
 
 import javax.servlet.ServletContext;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 /**
  * Helper used to load the PropertyMap.
  */
@@ -79,7 +81,9 @@ final class PropertyMapLoader {
     }
 
     // put values in initially without any evaluation
-    for (Map.Entry<Object, Object> entry : props.entrySet()) {
+    Iterator<Entry<Object, Object>> it = props.entrySet().iterator();
+    while (it.hasNext()) {
+      Map.Entry<Object, Object> entry = it.next();
       String key = ((String) entry.getKey()).toLowerCase();
       String val = ((String) entry.getValue());
       if (val != null) {

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

@@ -1,21 +1,25 @@
 package com.avaje.ebean.config;
 
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.sql.DataSource;
+
 import com.avaje.ebean.EbeanServerFactory;
-import com.avaje.ebean.PersistenceContextScope;
 import com.avaje.ebean.annotation.Encrypted;
 import com.avaje.ebean.cache.ServerCacheFactory;
 import com.avaje.ebean.cache.ServerCacheManager;
 import com.avaje.ebean.config.GlobalProperties.PropertySource;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 import com.avaje.ebean.config.dbplatform.DbEncrypt;
-import com.avaje.ebean.event.*;
+import com.avaje.ebean.event.BeanPersistController;
+import com.avaje.ebean.event.BeanPersistListener;
+import com.avaje.ebean.event.BeanQueryAdapter;
+import com.avaje.ebean.event.BulkTableEventListener;
+import com.avaje.ebean.event.ServerConfigStartup;
+import com.avaje.ebean.event.TransactionEventListener;
 import com.avaje.ebean.meta.MetaInfoManager;
 import com.avaje.ebean.util.ClassUtil;
-import com.fasterxml.jackson.core.JsonFactory;
-
-import javax.sql.DataSource;
-import java.util.ArrayList;
-import java.util.List;
 
 /**
  * The configuration used for creating a EbeanServer.
@@ -62,10 +66,7 @@ import java.util.List;
  * @author rbygrave
  */
 public class ServerConfig {
-  
-  /**
-   * The Constant DEFAULT_QUERY_BATCH_SIZE. Default: 100 
-   */
+  /** The Constant DEFAULT_QUERY_BATCH_SIZE. Default: 100 */
   private final static int DEFAULT_QUERY_BATCH_SIZE = 100;
 
   /**
@@ -111,24 +112,13 @@ public class ServerConfig {
    */
   private List<String> searchJars = new ArrayList<String>();
 
-  /** 
-   * Config controlling the autofetch behaviour.
-   */
+  /** The autofetch config. */
   private AutofetchConfig autofetchConfig = new AutofetchConfig();
 
-  /**
-   * The JSON format used for DateTime types. Default to millis.
-   */
-  private JsonConfig.DateTime jsonDateTime = JsonConfig.DateTime.MILLIS;
-
-  /** 
-   * The database platform name. Used to imply a DatabasePlatform to use.  
-   */
+  /** The database platform name. */
   private String databasePlatformName;
 
-  /** 
-   * The database platform. 
-   */
+  /** The database platform. */
   private DatabasePlatform databasePlatform;
 
   /**
@@ -140,14 +130,10 @@ public class ServerConfig {
 
   private int persistBatchSize = 20;
 
-  /** 
-   * The default batch size for lazy loading 
-   */
+  /** The default batch size for lazy loading */
   private int lazyLoadBatchSize = 1;
 
-  /** 
-   * The query batch size. 
-   */
+  /** The query batch size. */
   private int queryBatchSize = -1;
 
   private boolean ddlGenerate;
@@ -166,61 +152,29 @@ public class ServerConfig {
    */
   private PstmtDelegate pstmtDelegate;
 
-  /** 
-   * The data source (if programmatically provided). 
-   */
+  /** The data source. */
   private DataSource dataSource;
 
-  /** 
-   * The data source config. 
-   */
+  /** The data source config. */
   private DataSourceConfig dataSourceConfig = new DataSourceConfig();
 
-  /**
-   * Set to true if the DataSource uses autoCommit.
-   * <p>
-   * Indicates that Ebean should use autoCommit friendly Transactions and TransactionManager.
-   */
-  private boolean autoCommitMode;
-  
-  /** 
-   * The data source JNDI name if using a JNDI DataSource. 
-   */
+  /** The data source jndi name. */
   private String dataSourceJndiName;
 
-  /** 
-   * The database boolean true value (typically either 1, T, or Y).
-   */
+  /** The database boolean true. */
   private String databaseBooleanTrue;
 
-  /** 
-   * The database boolean false value (typically either 0, F or N). 
-   */
+  /** The database boolean false. */
   private String databaseBooleanFalse;
 
-  /** 
-   * The naming convention. 
-   */
+  /** The naming convention. */
   private NamingConvention namingConvention;
 
-  /** 
-   * Behaviour of update to include on the change properties. 
-   */
+  /** The update changes only. */
   private boolean updateChangesOnly = true;
-  
-  /**
-   * Default behaviour for updates when cascade save on a O2M or M2M to delete any missing children.
-   */
-  private boolean updatesDeleteMissingChildren = true;
-  
-  /**
-   * Setting to indicate if UUID should be stored as binary(16) or varchar(40).
-   */
-  private boolean uuidStoreAsBinary;
-
 
   private List<BeanPersistController> persistControllers = new ArrayList<BeanPersistController>();
-  private List<BeanPersistListener> persistListeners = new ArrayList<BeanPersistListener>();
+  private List<BeanPersistListener<?>> persistListeners = new ArrayList<BeanPersistListener<?>>();
   private List<BeanQueryAdapter> queryAdapters = new ArrayList<BeanQueryAdapter>();
   private List<BulkTableEventListener> bulkTableEventListeners = new ArrayList<BulkTableEventListener>();
   private List<ServerConfigStartup> configStartupListeners = new ArrayList<ServerConfigStartup>();
@@ -241,56 +195,14 @@ public class ServerConfig {
   private boolean collectQueryStatsByNode;
 
   private boolean collectQueryOrigins;
-
+  
   /**
-   * The default PersistenceContextScope used if one is not explicitly set on a query.
-   */
-  private PersistenceContextScope persistenceContextScope = PersistenceContextScope.TRANSACTION;
-
-  private JsonFactory jsonFactory;
-
-  private boolean localTimeWithNanos;
-
-  private boolean durationWithNanos;
-
-  /**
-   * Construct a Server Configuration for programmatically creating an EbeanServer.
+   * Construct a Server Configuration for programmatically creating an
+   * EbeanServer.
    */
   public ServerConfig() {
 
   }
-  
-  /**
-   * Return the Jackson JsonFactory to use.
-   * <p>
-   * If not set a default implmentation will be used.
-   */
-  public JsonFactory getJsonFactory() {
-    return jsonFactory;
-  }
-
-  /**
-   * Set the Jackson JsonFactory to use.
-   * <p>
-   * If not set a default implmentation will be used.
-   */
-  public void setJsonFactory(JsonFactory jsonFactory) {
-    this.jsonFactory = jsonFactory;
-  }
-
-  /**
-   * Return the JSON format used for DateTime types.
-   */
-  public JsonConfig.DateTime getJsonDateTime() {
-    return jsonDateTime;
-  }
-
-  /**
-   * Set the JSON format to use for DateTime types.
-   */
-  public void setJsonDateTime(JsonConfig.DateTime jsonDateTime) {
-    this.jsonDateTime = jsonDateTime;
-  }
 
   /**
    * Return the name of the EbeanServer.
@@ -632,20 +544,6 @@ public class ServerConfig {
   public void setDataSourceJndiName(String dataSourceJndiName) {
     this.dataSourceJndiName = dataSourceJndiName;
   }
-  
-  /**
-   * Return true if autoCommit mode is on. This indicates to Ebean to use autoCommit friendly Transactions and TransactionManager.
-   */
-  public boolean isAutoCommitMode() {
-    return autoCommitMode;
-  }
-
-  /**
-   * Set to true if autoCommit mode is on and Ebean should use autoCommit friendly Transactions and TransactionManager.
-   */
-  public void setAutoCommitMode(boolean autoCommitMode) {
-    this.autoCommitMode = autoCommitMode;
-  }
 
   /**
    * Return a value used to represent TRUE in the database.
@@ -866,58 +764,6 @@ public class ServerConfig {
     this.dbEncrypt = dbEncrypt;
   }
 
-  
-  /**
-   * Return true if UUID should be stored as binary(16) (as opposed to varchar(40)).
-   */
-  public boolean isUuidStoreAsBinary() {
-    return uuidStoreAsBinary;
-  }
-
-  /**
-   * Set to true if UUID should be stored as binary(16) (as opposed to varchar(40)).
-   */
-  public void setUuidStoreAsBinary(boolean uuidStoreAsBinary) {
-    this.uuidStoreAsBinary = uuidStoreAsBinary;
-  }
-
-  /**
-   * Return true if LocalTime should be persisted with nanos precision.
-   */
-  public boolean isLocalTimeWithNanos() {
-    return localTimeWithNanos;
-  }
-
-  /**
-   * Set to true if LocalTime should be persisted with nanos precision.
-   * <p>
-   * Otherwise it is persisted using java.sql.Time which is seconds precision.
-   * </p>
-   */
-  public void setLocalTimeWithNanos(boolean localTimeWithNanos) {
-    this.localTimeWithNanos = localTimeWithNanos;
-  }
-
-  /**
-   * Return true if Duration should be persisted with nanos precision (SQL DECIMAL).
-   * <p>
-   * Otherwise it is persisted with second precision (SQL INTEGER).
-   * </p>
-   */
-  public boolean isDurationWithNanos() {
-    return durationWithNanos;
-  }
-
-  /**
-   * Set to true if Duration should be persisted with nanos precision (SQL DECIMAL).
-   * <p>
-   * Otherwise it is persisted with second precision (SQL INTEGER).
-   * </p>
-   */
-  public void setDurationWithNanos(boolean durationWithNanos) {
-    this.durationWithNanos = durationWithNanos;
-  }
-
   /**
    * Set to true to run the DDL generation on startup.
    */
@@ -1085,23 +931,8 @@ public class ServerConfig {
   public void setUpdateChangesOnly(boolean updateChangesOnly) {
     this.updateChangesOnly = updateChangesOnly;
   }
-    
-  /**
-   * Return true if updates by default delete missing children when cascading save to a OneToMany or
-   * ManyToMany. When not set this defaults to true.
-   */
-  public boolean isUpdatesDeleteMissingChildren() {
-    return updatesDeleteMissingChildren;
-  }
-
-  /**
-   * Set if updates by default delete missing children when cascading save to a OneToMany or
-   * ManyToMany. When not set this defaults to true.
-   */
-  public void setUpdatesDeleteMissingChildren(boolean updatesDeleteMissingChildren) {
-    this.updatesDeleteMissingChildren = updatesDeleteMissingChildren;
-  }
-
+  
+  
   /**
    * Return true if the ebeanServer should collection query statistics by ObjectGraphNode.
    */
@@ -1254,14 +1085,14 @@ public class ServerConfig {
    * all the BeanPersistListener instances.
    * </p>
    */
-  public void add(BeanPersistListener beanPersistListener) {
+  public void add(BeanPersistListener<?> beanPersistListener) {
     persistListeners.add(beanPersistListener);
   }
 
   /**
    * Return the BeanPersistListener instances.
    */
-  public List<BeanPersistListener> getPersistListeners() {
+  public List<BeanPersistListener<?>> getPersistListeners() {
     return persistListeners;
   }
 
@@ -1300,39 +1131,10 @@ public class ServerConfig {
    * BeanPersistListener instances one at a time.
    * </p>
    */
-  public void setPersistListeners(List<BeanPersistListener> persistListeners) {
+  public void setPersistListeners(List<BeanPersistListener<?>> persistListeners) {
     this.persistListeners = persistListeners;
   }
 
-  /**
-   * Return the default PersistenceContextScope to be used if one is not explicitly set on a query.
-   * <p/>
-   * The PersistenceContextScope can specified on each query via {@link com.avaje.ebean
-   * .Query#setPersistenceContextScope(com.avaje.ebean.PersistenceContextScope)}. If it
-   * is not set on the query this default scope is used.
-   *
-   * @see com.avaje.ebean.Query#setPersistenceContextScope(com.avaje.ebean.PersistenceContextScope)
-   */
-  public PersistenceContextScope getPersistenceContextScope() {
-    // if somehow null return TRANSACTION scope
-    return persistenceContextScope == null ? PersistenceContextScope.TRANSACTION : persistenceContextScope;
-  }
-
-  /**
-   * Set the PersistenceContext scope to be used if one is not explicitly set on a query.
-   * <p/>
-   * This defaults to {@link PersistenceContextScope#TRANSACTION}.
-   * <p/>
-   * The PersistenceContextScope can specified on each query via {@link com.avaje.ebean
-   * .Query#setPersistenceContextScope(com.avaje.ebean.PersistenceContextScope)}. If it
-   * is not set on the query this scope is used.
-   *
-   * @see com.avaje.ebean.Query#setPersistenceContextScope(com.avaje.ebean.PersistenceContextScope)
-   */
-  public void setPersistenceContextScope(PersistenceContextScope persistenceContextScope) {
-    this.persistenceContextScope = persistenceContextScope;
-  }
-
   /**
    * Load the settings from the ebean.properties file.
    */
@@ -1387,6 +1189,8 @@ public class ServerConfig {
 
   /**
    * This is broken out for the same reason as above - preserve existing behaviour but let it be overridden.
+   *
+   * @param p
    */
   protected void loadAutofetchConfig(PropertySource p) {
     autofetchConfig.loadSettings(p);
@@ -1409,7 +1213,6 @@ public class ServerConfig {
 
     loadDataSourceSettings(p);
 
-    autoCommitMode = p.getBoolean("autoCommitMode", false);
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", false);
     namingConvention = createNamingConvention(p);
     databasePlatform = createInstance(p, DatabasePlatform.class, "databasePlatform");
@@ -1432,11 +1235,8 @@ public class ServerConfig {
 
     collectQueryStatsByNode = p.getBoolean("collectQueryStatsByNode", true);
     collectQueryOrigins = p.getBoolean("collectQueryOrigins", true);
-
-    updateChangesOnly = p.getBoolean("updateChangesOnly", true);
     
-    boolean defaultDeleteMissingChildren = p.getBoolean("defaultDeleteMissingChildren", true);
-    updatesDeleteMissingChildren = p.getBoolean("updatesDeleteMissingChildren", defaultDeleteMissingChildren);
+    updateChangesOnly = p.getBoolean("updateChangesOnly", true);
 
     boolean batchMode = p.getBoolean("batch.mode", false);
     persistBatching = p.getBoolean("persistBatching", batchMode);
@@ -1444,26 +1244,15 @@ public class ServerConfig {
     int batchSize = p.getInt("batch.size", 20);
     persistBatchSize = p.getInt("persistBatchSize", batchSize);
 
-    persistenceContextScope = PersistenceContextScope.valueOf(p.get("persistenceContextScope","TRANSACTION"));
-
     dataSourceJndiName = p.get("dataSourceJndiName", null);
     databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", 20);
     databaseBooleanTrue = p.get("databaseBooleanTrue", null);
     databaseBooleanFalse = p.get("databaseBooleanFalse", null);
     databasePlatformName = p.get("databasePlatformName", null);
-    uuidStoreAsBinary = p.getBoolean("uuidStoreAsBinary", false);
-    localTimeWithNanos = p.getBoolean("localTimeWithNanos", false);
 
     lazyLoadBatchSize = p.getInt("lazyLoadBatchSize", 1);
     queryBatchSize = p.getInt("queryBatchSize", DEFAULT_QUERY_BATCH_SIZE);
 
-    String jsonDateTimeFormat = p.get("jsonDateTime", null);
-    if (jsonDateTimeFormat != null) {
-      jsonDateTime = JsonConfig.DateTime.valueOf(jsonDateTimeFormat);
-    } else {
-      jsonDateTime = JsonConfig.DateTime.MILLIS;
-    }
-
     ddlGenerate = p.getBoolean("ddl.generate", false);
     ddlRun = p.getBoolean("ddl.run", false);
 

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

@@ -57,13 +57,6 @@ public final class TableName {
     this.name = split[len - 1];
   }
 
-  /**
-   * Parse a qualifiedTableName that might include a catalog and schema and just return the table name.
-   */
-  public static String parse(String qualifiedTableName) {
-    return new TableName(qualifiedTableName).getName();
-  }
-  
   public String toString() {
     return getQualifiedName();
   }
@@ -128,18 +121,6 @@ public final class TableName {
     return buffer.toString();
   }
 
-  /**
-   * Append a catalog and schema prefix if they exist to the string builder.
-   */
-  public void appendCatalogAndSchema(StringBuilder buffer) {
-    if (catalog != null) {
-      buffer.append(catalog).append(".");
-    }
-    if (schema != null) {
-      buffer.append(schema).append(".");
-    }
-  }
-  
   /**
    * Checks if is table name is valid i.e. it has at least a name.
    * 

src/main/java/com/avaje/ebean/config/dbplatform/DatabasePlatform.java

@@ -6,7 +6,6 @@ import javax.sql.DataSource;
 
 import com.avaje.ebean.BackgroundExecutor;
 import com.avaje.ebean.Query;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -15,61 +14,40 @@ import org.slf4j.LoggerFactory;
  */
 public class DatabasePlatform {
 
+  /** The Constant logger. */
   private static final Logger logger = LoggerFactory.getLogger(DatabasePlatform.class);
 
-  /** 
-   * The open quote used by quoted identifiers. 
-   */
+  /** The open quote used by quoted identifiers. */
   protected String openQuote = "\"";
 
-  /**
-   *  The close quote used by quoted identifiers. 
-   */
+  /** The close quote used by quoted identifiers. */
   protected String closeQuote = "\"";
 
-  /** 
-   * For limit/offset, row_number etc limiting of SQL queries. 
-   */
+  /** For limit/offset, row_number etc limiting of SQL queries. */
   protected SqlLimiter sqlLimiter = new LimitOffsetSqlLimiter();
 
-  /** 
-   * Mapping of JDBC to Database types. 
-   */
+  /** Mapping of JDBC to Database types. */
   protected DbTypeMap dbTypeMap = new DbTypeMap();
 
-  /** 
-   * DB specific DDL syntax. 
-   */
+  /** DB specific DDL syntax. */
   protected DbDdlSyntax dbDdlSyntax = new DbDdlSyntax();
 
-  /** 
-   * Defines DB identity/sequence features. 
-   */
+  /** Defines DB identity/sequence features. */
   protected DbIdentity dbIdentity = new DbIdentity();
 
-  /** 
-   * The JDBC type to map booleans to (by default). 
-   */
+  /** The JDBC type to map booleans to (by default). */
   protected int booleanDbType = Types.BOOLEAN;
 
-  /** 
-   * The JDBC type to map Blob to. 
-   */
+  /** The JDBC type to map Blob to. */
   protected int blobDbType = Types.BLOB;
 
-  /** 
-   * The JDBC type to map Clob to. 
-   */
+  /** The JDBC type to map Clob to. */
   protected int clobDbType = Types.CLOB;
 
-  /** 
-   * For Oracle treat empty strings as null. 
-   */
+  /** For Oracle treat empty strings as null. */
   protected boolean treatEmptyStringsAsNull;
 
-  /** 
-   * The database platform name. 
-   */
+  /** The name. */
   protected String name = "generic";
 
   /**
@@ -79,11 +57,6 @@ public class DatabasePlatform {
    */
   private static final char BACK_TICK = '`';
 
-  /**
-   * The like clause. Can be overridden to disable default escape character.
-   */
-  protected String likeClause = "like ?";
-  
   protected DbEncrypt dbEncrypt;
 
   protected boolean idInExpandedForm;
@@ -326,13 +299,4 @@ public class DatabasePlatform {
 
     return sql;
   }
-
-  /**
-   * Returns the like clause used by this database platform.
-   * <p>
-   * This may include an escape clause to disable a default escape character.
-   */
-  public String getLikeClause() {
-    return likeClause;
-  }
 }

src/main/java/com/avaje/ebean/config/dbplatform/DbDdlSyntax.java

@@ -1,7 +1,5 @@
 package com.avaje.ebean.config.dbplatform;
 
-import com.avaje.ebean.config.TableName;
-
 /**
  * Used to support DB specific syntax for DDL generation.
  */
@@ -11,7 +9,7 @@ public class DbDdlSyntax {
 
   private boolean inlinePrimaryKeyConstraint = false;
 
-  private boolean addOneToOneUniqueContraint = true;
+  private boolean addOneToOneUniqueContraint = false;
 
   private int maxConstraintNameLength = 32;
 
@@ -45,17 +43,6 @@ public class DbDdlSyntax {
     return pk;
   }
 
-  /**
-   * Return the column definition for an identity column.
-   */
-  public String getIdentityColumnDefn(String columnDefn) {
-    String identity = getIdentity();
-    if (identity != null && identity.length() > 0) {
-      return columnDefn+" "+identity;
-    }
-    return columnDefn;
-  }
-  
   /**
    * Return the identity clause for DB's that have identities.
    */
@@ -261,29 +248,26 @@ public class DbDdlSyntax {
     this.inlinePrimaryKeyConstraint = inlinePrimaryKeyConstraint;
   }
 
-  /**
-   * Builds and returns a fully index name.
-   */
   public String getIndexName(String table, String propName, int ixCount) {
 
-
-    StringBuilder buffer = new StringBuilder(30);
-    buffer.append("ix_").append(TableName.parse(table));
-    buffer.append("_").append(propName);
+    StringBuilder buffer = new StringBuilder();
+    buffer.append("ix_");
+    buffer.append(table);
+    buffer.append("_");
+    buffer.append(propName);
 
     addSuffix(buffer, ixCount);
 
     return buffer.toString();
   }
 
-  /**
-   * Builds and returns a fully qualified foreign key constraint name.
-   */
   public String getForeignKeyName(String table, String propName, int fkCount) {
 
-    StringBuilder buffer = new StringBuilder(30);
-    buffer.append("fk_").append(TableName.parse(table));
-    buffer.append("_").append(propName);
+    StringBuilder buffer = new StringBuilder();
+    buffer.append("fk_");
+    buffer.append(table);
+    buffer.append("_");
+    buffer.append(propName);
 
     addSuffix(buffer, fkCount);
 
@@ -292,10 +276,15 @@ public class DbDdlSyntax {
 
   /**
    * Adds the suffix.
+   * 
+   * @param buffer
+   *          the buffer
+   * @param count
+   *          the count
    */
   protected void addSuffix(StringBuilder buffer, int count) {
-    String suffixNr = Integer.toString(count);
-    int suffixLen = suffixNr.length() + 1;
+    final String suffixNr = Integer.toString(count);
+    final int suffixLen = suffixNr.length() + 1;
 
     if (buffer.length() + suffixLen > maxConstraintNameLength) {
       buffer.setLength(maxConstraintNameLength - suffixLen);

src/main/java/com/avaje/ebean/config/dbplatform/H2Platform.java

@@ -14,7 +14,6 @@ public class H2Platform extends DatabasePlatform {
     super();
     this.name = "h2";
     this.dbEncrypt = new H2DbEncrypt();
-    this.likeClause = "like ? escape''";
 
     // only support getGeneratedKeys with non-batch JDBC
     // so generally use SEQUENCE instead of IDENTITY for H2

src/main/java/com/avaje/ebean/config/dbplatform/LimitOffsetSqlLimiter.java

@@ -17,21 +17,22 @@ public class LimitOffsetSqlLimiter implements SqlLimiter {
 
   public SqlLimitResponse limit(SqlLimitRequest request) {
 
-    String dbSql = request.getDbSql();
-    
-    StringBuilder sb = new StringBuilder(50 + dbSql.length());
+    StringBuilder sb = new StringBuilder(512);
     sb.append("select ");
     if (request.isDistinct()) {
       sb.append("distinct ");
     }
 
-    sb.append(dbSql);
+    sb.append(request.getDbSql());
 
     int firstRow = request.getFirstRow();
     int maxRows = request.getMaxRows();
+    if (maxRows > 0) {
+      maxRows = maxRows + 1;
+    }
 
     if (maxRows > 0 || firstRow > 0) {
-      sb.append(" ").append(LIMIT).append(" ").append(maxRows);
+      sb.append(" ").append(NEW_LINE).append(LIMIT).append(" ").append(maxRows);
       if (firstRow > 0) {
         sb.append(" ").append(OFFSET).append(" ");
         sb.append(firstRow);

src/main/java/com/avaje/ebean/config/dbplatform/MsSqlServer2005SqlLimiter.java

@@ -26,7 +26,9 @@ public class MsSqlServer2005SqlLimiter implements SqlLimiter {
 
     int lastRow = request.getMaxRows();
     if (lastRow > 0) {
-      lastRow = lastRow + firstRow;
+      // fetch 1 more than we return so that
+      // we know if more rows are available
+      lastRow = lastRow + firstRow + 1;
     }
 
     if (firstRow < 1) {

src/main/java/com/avaje/ebean/config/dbplatform/MySqlPlatform.java

@@ -20,7 +20,6 @@ public class MySqlPlatform extends DatabasePlatform {
   public MySqlPlatform() {
     super();
     this.name = "mysql";
-    this.likeClause = "like ? escape''";
     this.selectCountWithAlias = true;
     this.dbEncrypt = new MySqlDbEncrypt();
 

src/main/java/com/avaje/ebean/config/dbplatform/Postgres8Platform.java

@@ -1,73 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.config.GlobalProperties;
-
-import javax.sql.DataSource;
-import java.sql.Types;
-
-/**
- * Postgres v8.3 specific platform.
- * <p>
- * No support for getGeneratedKeys.
- * </p>
- */
-public class Postgres8Platform extends DatabasePlatform {
-
-  public Postgres8Platform() {
-    super();
-    this.name = "postgres";
-    this.selectCountWithAlias = true;
-    this.blobDbType = Types.LONGVARBINARY;
-    this.clobDbType = Types.VARCHAR;
-
-    this.dbEncrypt = new PostgresDbEncrypt();
-
-    this.dbIdentity.setSupportsGetGeneratedKeys(false);
-    this.dbIdentity.setIdType(IdType.SEQUENCE);
-    this.dbIdentity.setSupportsSequence(true);
-
-    String colAlias = GlobalProperties.get("ebean.columnAliasPrefix", null);
-    if (colAlias == null) {
-      // Postgres requires the "as" keyword for column alias
-      GlobalProperties.put("ebean.columnAliasPrefix", "as c");
-    }
-
-    this.openQuote = "\"";
-    this.closeQuote = "\"";
-
-    // dbTypeMap.put(Types.BOOLEAN, new DbType("bit default 0"));
-
-    dbTypeMap.put(Types.INTEGER, new DbType("integer", false));
-    dbTypeMap.put(Types.DOUBLE, new DbType("float"));
-    dbTypeMap.put(Types.TINYINT, new DbType("smallint"));
-    dbTypeMap.put(Types.DECIMAL, new DbType("decimal", 38));
-
-    dbTypeMap.put(Types.BINARY, new DbType("bytea", false));
-    dbTypeMap.put(Types.VARBINARY, new DbType("bytea", false));
-
-    dbTypeMap.put(Types.BLOB, new DbType("bytea", false));
-    dbTypeMap.put(Types.CLOB, new DbType("text"));
-    dbTypeMap.put(Types.LONGVARBINARY, new DbType("bytea", false));
-    dbTypeMap.put(Types.LONGVARCHAR, new DbType("text"));
-
-    dbDdlSyntax.setDropTableCascade("cascade");
-    dbDdlSyntax.setDropIfExists("if exists");
-
-  }
-
-  /**
-   * Create a Postgres specific sequence IdGenerator.
-   */
-  @Override
-  public IdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds,
-      String seqName, int batchSize) {
-
-    return new PostgresSequenceIdGenerator(be, ds, seqName, batchSize);
-  }
-
-  @Override
-  protected String withForUpdate(String sql) {
-    return sql + " for update";
-  }
-}

src/main/java/com/avaje/ebean/config/dbplatform/PostgresDdlSyntax.java

@@ -1,25 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-public class PostgresDdlSyntax extends DbDdlSyntax {
-
-  /**
-   * Map bigint, integer and smallint into their equivilent serial types. 
-   */
-  @Override
-  public String getIdentityColumnDefn(String columnDefn) {
-    
-    //smallserial, serial and bigserial
-    if ("bigint".equalsIgnoreCase(columnDefn)) {
-      return "bigserial";
-    }
-    if ("integer".equalsIgnoreCase(columnDefn)) {
-      return "serial";
-    }
-    if ("smallint".equalsIgnoreCase(columnDefn)) {
-      return "smallserial";
-    }
-    
-    return columnDefn;
-  }
-
-}

src/main/java/com/avaje/ebean/config/dbplatform/PostgresPlatform.java

@@ -4,38 +4,27 @@ import com.avaje.ebean.BackgroundExecutor;
 import com.avaje.ebean.config.GlobalProperties;
 
 import javax.sql.DataSource;
-
 import java.sql.Types;
 
 /**
- * Postgres v9 specific platform.
+ * Postgres v8.3 specific platform.
  * <p>
- * Uses serial types and getGeneratedKeys.
+ * No support for getGeneratedKeys.
  * </p>
  */
 public class PostgresPlatform extends DatabasePlatform {
 
-  /**
-   * Unique jdbc type id defined for hstore type.
-   */
-  public static final int TYPE_HSTORE = 4001;
-  
   public PostgresPlatform() {
     super();
     this.name = "postgres";
-    this.likeClause = "like ? escape''";
-    
-    this.dbDdlSyntax = new PostgresDdlSyntax();
-    
     this.selectCountWithAlias = true;
     this.blobDbType = Types.LONGVARBINARY;
     this.clobDbType = Types.VARCHAR;
 
     this.dbEncrypt = new PostgresDbEncrypt();
 
-    // Use Identity and getGeneratedKeys
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(true);
+    this.dbIdentity.setSupportsGetGeneratedKeys(false);
+    this.dbIdentity.setIdType(IdType.SEQUENCE);
     this.dbIdentity.setSupportsSequence(true);
 
     String colAlias = GlobalProperties.get("ebean.columnAliasPrefix", null);
@@ -47,8 +36,8 @@ public class PostgresPlatform extends DatabasePlatform {
     this.openQuote = "\"";
     this.closeQuote = "\"";
 
-    dbTypeMap.put(TYPE_HSTORE, new DbType("hstore"));
-    
+    // dbTypeMap.put(Types.BOOLEAN, new DbType("bit default 0"));
+
     dbTypeMap.put(Types.INTEGER, new DbType("integer", false));
     dbTypeMap.put(Types.DOUBLE, new DbType("float"));
     dbTypeMap.put(Types.TINYINT, new DbType("smallint"));

src/main/java/com/avaje/ebean/config/dbplatform/RowNumberSqlLimiter.java

@@ -15,7 +15,7 @@ public class RowNumberSqlLimiter implements SqlLimiter {
    */
   private static final String ROW_NUMBER_AS = ") as rn, ";
 
-  private final String rowNumberWindowAlias;
+  final String rowNumberWindowAlias;
 
   /**
    * Specify the name of the rowNumberWindowAlias.
@@ -30,18 +30,16 @@ public class RowNumberSqlLimiter implements SqlLimiter {
 
   public SqlLimitResponse limit(SqlLimitRequest request) {
 
-    String dbSql = request.getDbSql();
-    
-    StringBuilder sb = new StringBuilder(60 + dbSql.length());
+    StringBuilder sb = new StringBuilder(500);
 
     int firstRow = request.getFirstRow();
 
     int lastRow = request.getMaxRows();
     if (lastRow > 0) {
-      lastRow = lastRow + firstRow;
+      lastRow = lastRow + firstRow + 1;
     }
 
-    sb.append("select * from ( ");
+    sb.append("select * from (").append(NEW_LINE);
 
     sb.append("select ");
     if (request.isDistinct()) {
@@ -52,9 +50,9 @@ public class RowNumberSqlLimiter implements SqlLimiter {
     sb.append(request.getDbOrderBy());
     sb.append(ROW_NUMBER_AS);
 
-    sb.append(dbSql);
+    sb.append(request.getDbSql());
 
-    sb.append(" ) ");
+    sb.append(NEW_LINE).append(") ");
     sb.append(rowNumberWindowAlias);
     sb.append(" where ");
     if (firstRow > 0) {

src/main/java/com/avaje/ebean/config/dbplatform/RownumSqlLimiter.java

@@ -35,40 +35,38 @@ public class RownumSqlLimiter implements SqlLimiter {
     // :MAX_ROW_TO_FETCH )
     // where rnum >= :MIN_ROW_TO_FETCH;
 
-    String dbSql = request.getDbSql();
-    
-    StringBuilder sb = new StringBuilder(60 + dbSql.length());
+    StringBuilder sb = new StringBuilder(500);
 
     int firstRow = request.getFirstRow();
 
     int lastRow = request.getMaxRows();
     if (lastRow > 0) {
-      lastRow = lastRow + firstRow;
+      lastRow = lastRow + firstRow + 1;
     }
 
-    sb.append("select * from ( ");
+    sb.append("select * ").append(NEW_LINE).append("from ( ");
 
     sb.append("select ");
     if (useFirstRowsHint && request.getMaxRows() > 0) {
-      sb.append("/*+ FIRST_ROWS(").append(request.getMaxRows()).append(") */ ");
+      sb.append("/*+ FIRST_ROWS(").append(request.getMaxRows() + 1).append(") */ ");
     }
 
-    sb.append("rownum ").append(rnum).append(", a.* ");
-    sb.append(" from (");
+    sb.append("rownum ").append(rnum).append(", a.* ").append(NEW_LINE);
+    sb.append("       from (");//
 
     sb.append(" select ");
     if (request.isDistinct()) {
       sb.append("distinct ");
     }
-    sb.append(dbSql);
+    sb.append(request.getDbSql());
 
-    sb.append(NEW_LINE).append("  ) a ");
+    sb.append(NEW_LINE).append("            ) a ");
     if (lastRow > 0) {
-      sb.append(" where rownum <= ").append(lastRow);
+      sb.append(NEW_LINE).append("       where rownum <= ").append(lastRow);
     }
-    sb.append(" ) ");
+    sb.append(NEW_LINE).append("     ) ");
     if (firstRow > 0) {
-      sb.append(" where ");
+      sb.append(NEW_LINE).append("where ");
       sb.append(rnum).append(" > ").append(firstRow);
     }
 

src/main/java/com/avaje/ebean/config/dbplatform/SqlAnywhereLimiter.java

@@ -8,12 +8,15 @@ public class SqlAnywhereLimiter implements SqlLimiter {
 
   public SqlLimitResponse limit(SqlLimitRequest request) {
 
-    String dbSql = request.getDbSql();
-    
-    StringBuilder sb = new StringBuilder(60 + dbSql.length());
+    StringBuilder sb = new StringBuilder(500);
 
     int firstRow = request.getFirstRow();
     int maxRows = request.getMaxRows();
+    if (maxRows > 0) {
+      // fetch 1 more than we return so that
+      // we know if more rows are available
+      maxRows = maxRows + 1;
+    }
 
     /*
      * SELECT TOP xx START AT xx ... FROM ...
@@ -28,7 +31,7 @@ public class SqlAnywhereLimiter implements SqlLimiter {
     if (firstRow > 0) {
       sb.append("start at ").append(firstRow + 1).append(" ");
     }
-    sb.append(dbSql);
+    sb.append(request.getDbSql());
 
     String sql = request.getDbPlatform().completeSql(sb.toString(), request.getOrmQuery());
 

src/main/java/com/avaje/ebean/config/dbplatform/SqlLimitRequest.java

@@ -5,6 +5,8 @@ import com.avaje.ebean.Query;
 /**
  * The request object for the query that can have sql limiting applied to it
  * (such as a LIMIT OFFSET clause).
+ * 
+ * @author rob
  */
 public interface SqlLimitRequest {
 

src/main/java/com/avaje/ebean/event/AbstractBeanPersistListener.java

@@ -1,78 +0,0 @@
-package com.avaje.ebean.event;
-
-import java.util.Set;
-
-/**
- * Provides a base implementation of BeanPersistListener.
- * <p>
- * Objects extending this should override the methods then are interested in.
- * The default inserted() updated() and deleted() methods return false and as such
- * means other servers in the cluster are not notified.
- * </p>
- */
-public abstract class AbstractBeanPersistListener implements BeanPersistListener {
-
-  /**
-   * Notified that a bean has been inserted locally. Return true if you want the
-   * cluster to be notified of the event.
-   *
-   * @param bean The bean that was inserted.
-   */
-  @Override
-  public boolean inserted(Object bean) {
-    return false;
-  }
-
-  /**
-   * Notified that a bean has been updated locally. Return true if you want the
-   * cluster to be notified of the event.
-   *
-   * @param bean              The bean that was updated.
-   * @param updatedProperties The properties that were modified by this update.
-   */
-  @Override
-  public boolean updated(Object bean, Set<String> updatedProperties) {
-    return false;
-  }
-
-  /**
-   * Notified that a bean has been deleted locally. Return true if you want the
-   * cluster to be notified of the event.
-   *
-   * @param bean The bean that was deleted.
-   */
-  @Override
-  public boolean deleted(Object bean) {
-    return false;
-  }
-
-  /**
-   * Notify that a bean was inserted on another node of the cluster.
-   *
-   * @param id the id value of the inserted bean
-   */
-  @Override
-  public void remoteInsert(Object id) {
-    // do nothing
-  }
-
-  /**
-   * Notify that a bean was updated on another node of the cluster.
-   *
-   * @param id the id value of the updated bean.
-   */
-  @Override
-  public void remoteUpdate(Object id) {
-    // do nothing
-  }
-
-  /**
-   * Notify that a bean was deleted on another node of the cluster.
-   *
-   * @param id the id value of the deleted bean.
-   */
-  @Override
-  public void remoteDelete(Object id) {
-    // do nothing
-  }
-}

src/main/java/com/avaje/ebean/event/BeanPersistController.java

@@ -5,7 +5,7 @@ import java.util.Set;
 /**
  * Used to enhance or override the default bean persistence mechanism.
  * <p>
- * Note that if want to totally change the finding, you need to use a BeanQueryAdapter
+ * Note that if want to totally change the finding, you need to use a BeanFinder
  * rather than using postLoad().
  * </p>
  * <p>

src/main/java/com/avaje/ebean/event/BeanPersistListener.java

@@ -2,8 +2,6 @@ package com.avaje.ebean.event;
 
 import java.util.Set;
 
-import com.avaje.ebean.config.ServerConfig;
-
 /**
  * Listens for committed bean events.
  * <p>
@@ -33,17 +31,10 @@ import com.avaje.ebean.config.ServerConfig;
  * </p>
  * <p>
  * A BeanPersistListener is either found automatically via class path search or
- * can be added programmatically via {@link ServerConfig#add(BeanPersistListener<?>)}}.
+ * can be added programmatically via ServerConfiguration.addEntity().
  * </p>
- * @see ServerConfig#add(BeanPersistListener)
  */
-public interface BeanPersistListener {
-
-  /**
-   * Return true if this BeanPersistListener should be registered for events
-   * on this entity type.
-   */
-  public boolean isRegisterFor(Class<?> cls);
+public interface BeanPersistListener<T> {
 
   /**
    * Notified that a bean has been inserted locally. Return true if you want the
@@ -52,7 +43,7 @@ public interface BeanPersistListener {
    * @param bean
    *          The bean that was inserted.
    */
-  public boolean inserted(Object bean);
+  public boolean inserted(T bean);
 
   /**
    * Notified that a bean has been updated locally. Return true if you want the
@@ -61,9 +52,9 @@ public interface BeanPersistListener {
    * @param bean
    *          The bean that was updated.
    * @param updatedProperties
-   *          The properties that were modified by this update.
+   *          the properties on the bean that where updated
    */
-  public boolean updated(Object bean, Set<String> updatedProperties);
+  public boolean updated(T bean, Set<String> updatedProperties);
 
   /**
    * Notified that a bean has been deleted locally. Return true if you want the
@@ -72,7 +63,7 @@ public interface BeanPersistListener {
    * @param bean
    *          The bean that was deleted.
    */
-  public boolean deleted(Object bean);
+  public boolean deleted(T bean);
 
   /**
    * Notify that a bean was inserted on another node of the cluster.

src/main/java/com/avaje/ebean/event/BeanPersistRequest.java

@@ -1,11 +1,9 @@
 package com.avaje.ebean.event;
 
-import java.util.Map;
 import java.util.Set;
 
 import com.avaje.ebean.EbeanServer;
 import com.avaje.ebean.Transaction;
-import com.avaje.ebean.ValuePair;
 
 /**
  * Holds the information available for a bean persist (insert, update or
@@ -43,8 +41,12 @@ public interface BeanPersistRequest<T> {
   public T getBean();
 
   /**
-   * Returns a map of the properties that have changed and their new and old values.
+   * Returns a bean containing the original values prior to the bean being
+   * modified.
+   * <p>
+   * This is for updates only.
+   * </p>
    */
-  public Map<String,ValuePair> getUpdatedValues();
+  public T getOldValues();
 
 }

src/main/java/com/avaje/ebean/text/PathPropertiesParser.java

@@ -53,9 +53,6 @@ class PathPropertiesParser {
       case '(':
         return currentWord();
       default:
-        if (pos == 1) {
-          return "";
-        }
       }
     } while (pos < eof);
     throw new RuntimeException("Hit EOF while reading sectionTitle from " + startPos);
@@ -94,10 +91,6 @@ class PathPropertiesParser {
       }
 
     } while (pos < eof);
-    if (startPos < pos) {
-      String currentWord = source.substring(startPos, pos);
-      currentPathProps.addProperty(currentWord);
-    }
   }
 
   private void addSubpath() {

src/main/java/com/avaje/ebean/text/TextException.java

@@ -1,7 +1,7 @@
 package com.avaje.ebean.text;
 
 /**
- * An exception occurred typically in processing CSV, JSON or XML.
+ * An exception occured typically in processing CSV, JSON or XML.
  * 
  * @author rbygrave
  */

src/main/java/com/avaje/ebean/text/csv/CsvReader.java

@@ -32,6 +32,7 @@ import com.avaje.ebean.text.StringParser;
  *   csvReader.addDateTime("anniversary", "dd-MMM-yyyy");
  *   csvReader.addProperty("billingAddress.line1");
  *   csvReader.addProperty("billingAddress.city");
+ *   csvReader.addReference("billingAddress.country.code");
  * 
  *   csvReader.process(reader);
  * 
@@ -40,6 +41,8 @@ import com.avaje.ebean.text.StringParser;
  * }
  * </pre>
  * 
+ * @author rbygrave
+ * 
  * @param <T>
  *          the entity bean type
  */
@@ -126,6 +129,13 @@ public interface CsvReader<T> {
    */
   public void addProperty(String propertyName);
 
+  /**
+   * Define the next property to be a reference. This effectively means it
+   * represents a foreign key. For example, with an Address object a Country
+   * Code could be a reference.
+   */
+  public void addReference(String propertyName);
+
   /**
    * Define the next property and use a custom StringParser to convert the
    * string content into the appropriate type for the property.

src/main/java/com/avaje/ebean/text/json/EJson.java

@@ -1,115 +0,0 @@
-package com.avaje.ebean.text.json;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.io.Writer;
-import java.util.List;
-import java.util.Map;
-
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.core.JsonToken;
-
-/**
- * Utility that converts between JSON content and simple java Maps/Lists.
- */
-public class EJson {
-
-  /**
-   * Write the nested Map/List as json.
-   */
-  public static String write(Object object) throws IOException {
-    return EJsonWriter.write(object);
-  }
-  
-  /**
-   * Write the nested Map/List as json to the writer.
-   */
-  public static void write(Object object, Writer writer) throws IOException {
-    EJsonWriter.write(object, writer);
-  }
-  
-  /**
-   * Write the nested Map/List as json to the jsonGenerator.
-   */
-  public static void write(Object object, JsonGenerator jsonGenerator) throws IOException {
-    EJsonWriter.write(object, jsonGenerator);
-  }
-  
-  /**
-   * Parse the json and return as a Map.
-   */
-  public static Map<String,Object> parseObject(String json) throws IOException {
-    return EJsonReader.parseObject(json);
-  }
-  
-  /**
-   * Parse the json and return as a Map taking a reader.
-   */
-  public static Map<String,Object> parseObject(Reader reader) throws IOException {
-    return EJsonReader.parseObject(reader);
-  }
-  
-  /**
-   * Parse the json and return as a Map taking a JsonParser.
-   */
-  public static Map<String,Object> parseObject(JsonParser parser) throws IOException {
-    return EJsonReader.parseObject(parser);
-  }
-
-  /**
-   * Parse the json and return as a Map taking a JsonParser and a starting token.
-   * <p>
-   * Used when the first token is checked to see if the value is null prior to calling this.
-   * </p>
-   */
-  public static Map<String,Object> parseObject(JsonParser parser, JsonToken token) throws IOException {
-    return EJsonReader.parseObject(parser, token);
-  }
-
-  /**
-   * Parse the json and return as a List.
-   * @throws IOException 
-   */
-  public static List<Object> parseList(String json) throws IOException {
-    return EJsonReader.parseList(json);
-  }
-  
-  /**
-   * Parse the json and return as a List taking a Reader.
-   * @throws IOException 
-   */
-  public static List<Object> parseList(Reader reader) throws IOException {
-    return EJsonReader.parseList(reader);
-  }
-  
-  /**
-   * Parse the json and return as a List taking a JsonParser.
-   */
-  public static List<Object> parseList(JsonParser parser) throws IOException {
-    return EJsonReader.parseList(parser);
-  }
-  
-  
-  /**
-   * Parse the json and return as a List or Map.
-   */
-  public static Object parse(String json) throws IOException {
-    return EJsonReader.parse(json);
-  }
-  
-  /**
-   * Parse the json and return as a List or Map.
-   */
-  public static Object parse(Reader reader) throws IOException {
-    return EJsonReader.parse(reader);
-  }
-  
-  /**
-   * Parse the json and return as a List or Map.
-   */
-  public static Object parse(JsonParser parser) throws IOException {
-    return EJsonReader.parse(parser);
-  }
-
-}

src/main/java/com/avaje/ebean/text/json/EJsonReader.java

@@ -1,282 +0,0 @@
-package com.avaje.ebean.text.json;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.io.StringReader;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
-
-import com.fasterxml.jackson.core.JsonFactory;
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.core.JsonToken;
-
-class EJsonReader {
-
-  static JsonFactory json = new JsonFactory();
-  
-  @SuppressWarnings("unchecked")
-  static Map<String, Object> parseObject(String json) throws IOException  {
-    return (Map<String, Object>) parse(json);
-  }
-  
-  @SuppressWarnings("unchecked")
-  static Map<String, Object> parseObject(Reader reader) throws IOException {
-    return (Map<String, Object>) parse(reader);
-  }
-  
-  @SuppressWarnings("unchecked")
-  static Map<String, Object> parseObject(JsonParser parser) throws IOException {
-    return (Map<String, Object>) parse(parser);
-  }
-
-  @SuppressWarnings("unchecked")
-  static Map<String, Object> parseObject(JsonParser parser, JsonToken token) throws IOException {
-    return (Map<String, Object>)parse(parser, token);
-  }
-
-  @SuppressWarnings("unchecked")
-  static List<Object> parseList(String json) throws IOException {
-    return (List<Object>) parse(json);
-  }
-  
-  @SuppressWarnings("unchecked")
-  static List<Object> parseList(Reader reader) throws IOException {
-    return (List<Object>) parse(reader);
-  }
-  
-  @SuppressWarnings("unchecked")
-  static List<Object> parseList(JsonParser parser) throws IOException {
-    return (List<Object>) parse(parser);
-  }
-
-  static Object parse(String json) throws IOException {
-    return parse(new StringReader(json));
-  }
-
-  static Object parse(Reader reader) throws IOException {
-    return parse(json.createParser(reader));
-  }
-
-  static Object parse(JsonParser parser) throws IOException {
-    return parse(parser, null);
-  }
-
-  static Object parse(JsonParser parser, JsonToken token) throws IOException {
-    return new EJsonReader(parser).parseJson(token);
-  }
-
-  private final JsonParser parser;
-
-  private int depth;
-  
-  private Stack stack;
-
-  private Context currentContext;
-
-  EJsonReader(JsonParser parser) {
-    this.parser = parser;
-  }
-
-  private void startArray() {
-    depth++;
-    stack.push(currentContext);
-    currentContext = new ArrayContext();
-  }
-
-  private void startObject() {
-    depth++;
-    stack.push(currentContext);
-    currentContext = new ObjectContext();
-  }
-
-  private void endArray() {
-    end();
-  }
-
-  private void endObject() {
-    end();
-  }
-
-  private void end() {
-    depth--;
-    if (!stack.isEmpty()) {
-      currentContext = stack.pop(currentContext);
-    }
-  }
-
-  private void setValue(Object value) {
-    currentContext.setValue(value);
-  }
-
-  private void setValueNull() {
-    currentContext.setValueNull();
-  }
-
-  private Object parseJson(JsonToken token) throws IOException {
-
-    if (token == null) {
-      // no initial token so expect to read START_OBJECT or similar
-      token = parser.nextToken();
-      if (JsonToken.VALUE_NULL == token) {
-        return null;
-      }
-    }
-
-    stack = new Stack();
-    // it is a object or array, process the first JsonToken
-    processJsonToken(token);
-
-    // process the rest of the object or array
-    while (depth > 0) {
-      token = parser.nextToken();
-      processJsonToken(token);
-    }
-
-    return currentContext.getValue();
-  }
-
-  /**
-   * Process the JsonToken for objects and arrays.
-   */
-  private void processJsonToken(JsonToken token) throws IOException {
-    switch (token) {
-
-    case START_ARRAY:
-      startArray();
-      break;
-
-    case START_OBJECT:
-      startObject();
-      break;
-
-    case FIELD_NAME:
-      currentContext.setKey(parser.getCurrentName());
-      break;
-
-    case VALUE_STRING:
-      setValue(parser.getValueAsString());
-      break;
-
-    case VALUE_NUMBER_INT:
-      setValue(parser.getLongValue());
-      break;
-      
-    case VALUE_NUMBER_FLOAT:
-      setValue(parser.getDecimalValue());
-      break;
-
-    case VALUE_TRUE:
-      setValue(Boolean.TRUE);
-      break;
-
-    case VALUE_FALSE:
-      setValue(Boolean.FALSE);
-      break;
-
-    case VALUE_NULL:
-      setValueNull();
-      break;
-
-    case END_OBJECT:
-      endObject();
-      break;
-
-    case END_ARRAY:
-      endArray();
-      break;
-
-    default:
-      break;
-    }
-  }
-  
-  private static final class Stack {
-    
-    private Context head;
-    
-    private void push(Context context) {
-      if (context != null) {
-        context.next = head;
-        head = context;
-      }
-    }
-
-    private Context pop(Context endingContext) {
-      if (head == null) {
-        throw new NoSuchElementException();
-      }
-      Context temp = head;
-      head = head.next;
-      temp.popContext(endingContext);
-      return temp;
-    }
-
-    private boolean isEmpty() {
-      return head == null;
-    }
-  }
-
-  private static abstract class Context {
-    Context next;
-    abstract void popContext(Context temp);
-    abstract Object getValue();
-    abstract void setKey(String key);
-    abstract void setValue(Object value);
-    abstract void setValueNull();
-  }
-  
-  private static class ObjectContext extends Context {
-        
-    private final Map<String, Object> map = new LinkedHashMap<String, Object>();
-
-    private String key;
-
-    public void popContext(Context temp) {
-      setValue(temp.getValue());
-    }
-
-    Object getValue() {
-      return map;
-    }
-
-    void setKey(String key) {
-      this.key = key;
-    }
-
-    void setValue(Object value) {
-      map.put(key, value);
-    }
-
-    void setValueNull() {
-      map.put(key, null);
-    }
-  }
-
-  private static class ArrayContext extends Context {
-    
-    private final List<Object> values = new ArrayList<Object>();
-
-    public void popContext(Context temp) {
-      values.add(temp.getValue());
-    }
-
-    Object getValue() {
-      return values;
-    }
-    
-    void setValue(Object value) {
-      values.add(value);
-    }
-
-    void setValueNull() {
-      // ignore
-    }
-    void setKey(String key) {  
-      // not expected
-    }
-  }
-
-}

src/main/java/com/avaje/ebean/text/json/EJsonWriter.java

@@ -1,209 +0,0 @@
-package com.avaje.ebean.text.json;
-
-import java.io.IOException;
-import java.io.StringWriter;
-import java.io.Writer;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.Collection;
-import java.util.Date;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import com.fasterxml.jackson.core.JsonFactory;
-import com.fasterxml.jackson.core.JsonGenerator;
-
-class EJsonWriter {
-
-  /**
-   * Base jsonFactory implementation used when it is not passed in.
-   */
-  static JsonFactory jsonFactory = new JsonFactory();
-
-  static String write(Object object) throws IOException {
-    StringWriter writer = new StringWriter(200);
-    write(object, writer);
-    return writer.toString();
-  }
-
-  static void write(Object object, Writer writer) throws IOException {
-    JsonGenerator generator = jsonFactory.createGenerator(writer);
-    write(object, generator);
-    generator.close();
-  }
-
-  static void write(Object object, JsonGenerator jsonGenerator) {
-    new EJsonWriter(jsonGenerator).writeJson(object);
-  }
-
-  private final JsonGenerator jsonGenerator;
-
-  private EJsonWriter(JsonGenerator jsonGenerator) {
-    this.jsonGenerator = jsonGenerator;
-  }
-
-  private void writeJson(Object object) {
-    writeJson(null, object);
-  }
-
-  @SuppressWarnings("unchecked")
-  private void writeJson(String name, Object object) {
-    try {
-      if (object == null) {
-        writeNull(name);
-
-      } else if (object instanceof Map) {
-        writeMap(name, (Map<Object, Object>) object);
-
-      } else if (object instanceof Collection) {
-        writeCollection(name, (Collection<Object>) object);
-
-      } else if (object instanceof Boolean) {
-        writeBoolean(name, (Boolean) object);
-
-      } else if (object instanceof Number) {
-        writeNumber(name, (Number) object);
-
-      } else if (object instanceof Date) {
-        writeDate(name, (Date) object);
-
-      } else if (object instanceof String) {
-        writeString(name, (String) object);
-
-      } else if (object instanceof Map.Entry<?, ?>) {
-        Map.Entry<?, ?> entry = (Map.Entry<?, ?>) object;
-        writeJson(entry.getKey().toString(), entry.getValue());
-
-      } else {
-        writeString(name, object.toString());
-      }
-
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  private void writeBoolean(String name, Boolean object) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeBoolean(object);
-    } else {
-      jsonGenerator.writeBooleanField(name, object);
-    }
-  }
-
-  private void writeDate(String name, Date object) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeNumber(object.getTime());
-    } else {
-      jsonGenerator.writeNumberField(name, object.getTime());
-    }
-  }
-
-  private void writeNumber(String name, Number object) throws IOException {
-
-    if (object instanceof Long) {
-      writeLong(name, object);
-
-    } else if (object instanceof Integer) {
-      writeInteger(name, object);
-
-    } else if (object instanceof Double) {
-      writeDouble(name, object);
-
-    } else if (object instanceof BigDecimal) {
-      writeBigDecimal(name, object);
-
-    } else if (object instanceof BigInteger) {
-      writeBigInteger(name, object);
-
-    } else {
-      writeGeneralNumber(name, object);
-    }
-  }
-
-  private void writeGeneralNumber(String name, Number object) throws IOException {
-    writeBigDecimal(name, new BigDecimal(object.toString()));
-  }
-
-  private void writeBigDecimal(String name, Number object) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeNumber((BigDecimal) object);
-    } else {
-      jsonGenerator.writeNumberField(name, (BigDecimal) object);
-    }
-  }
-
-  private void writeBigInteger(String name, Number object) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeNumber((BigInteger) object);
-    } else {
-      jsonGenerator.writeNumberField(name, object.longValue());
-    }
-  }
-
-  private void writeDouble(String name, Number object) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeNumber((Double) object);
-    } else {
-      jsonGenerator.writeNumberField(name, (Double) object);
-    }
-  }
-
-  private void writeLong(String name, Number object) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeNumber((Long) object);
-    } else {
-      jsonGenerator.writeNumberField(name, (Long) object);
-    }
-  }
-
-  private void writeInteger(String name, Number object) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeNumber((Integer) object);
-    } else {
-      jsonGenerator.writeNumberField(name, (Integer) object);
-    }
-  }
-
-  private void writeNull(String name) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeNull();
-    } else {
-      jsonGenerator.writeNullField(name);
-    }
-  }
-
-  private void writeString(String name, String object) throws IOException {
-    if (name == null) {
-      jsonGenerator.writeString(object);
-    } else {
-      jsonGenerator.writeStringField(name, object);
-    }
-  }
-
-  private void writeCollection(String name, Collection<Object> collection) throws IOException {
-    if (name != null) {
-      jsonGenerator.writeFieldName(name);
-    }
-    jsonGenerator.writeStartArray();
-    for (Object object : collection) {
-      writeJson(null, object);
-    }
-    jsonGenerator.writeEndArray();
-  }
-
-  private void writeMap(String name, Map<Object, Object> map) throws IOException {
-
-    if (name != null) {
-      jsonGenerator.writeFieldName(name);
-    }
-    jsonGenerator.writeStartObject();
-    Set<Entry<Object, Object>> entrySet = map.entrySet();
-    for (Entry<Object, Object> entry : entrySet) {
-      writeJson(entry.getKey().toString(), entry.getValue());
-    }
-    jsonGenerator.writeEndObject();
-  }
-
-}

src/main/java/com/avaje/ebean/text/json/JsonContext.java

@@ -1,8 +1,5 @@
 package com.avaje.ebean.text.json;
 
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonParser;
-
 import java.io.Reader;
 import java.io.Writer;
 import java.lang.reflect.Type;
@@ -10,105 +7,125 @@ import java.util.List;
 
 /**
  * Converts objects to and from JSON format.
+ * 
+ * @author rbygrave
  */
 public interface JsonContext {
 
   /**
    * Convert json string input into a Bean of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
    */
-  public <T> T toBean(Class<T> rootType, String json) throws JsonIOException;
+  public <T> T toBean(Class<T> rootType, String json);
 
   /**
    * Convert json reader input into a Bean of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
    */
-  public <T> T toBean(Class<T> rootType, Reader json) throws JsonIOException;
+  public <T> T toBean(Class<T> rootType, Reader json);
+
+  /**
+   * Convert json string input into a Bean of a specific type with options.
+   */
+  public <T> T toBean(Class<T> rootType, String json, JsonReadOptions options);
+
+  /**
+   * Convert json reader input into a Bean of a specific type with options.
+   */
+  public <T> T toBean(Class<T> rootType, Reader json, JsonReadOptions options);
 
   /**
    * Convert json string input into a list of beans of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
    */
-  public <T> List<T> toList(Class<T> rootType, String json) throws JsonIOException;
+  public <T> List<T> toList(Class<T> rootType, String json);
+
+  /**
+   * Convert json string input into a list of beans of a specific type with
+   * options.
+   */
+  public <T> List<T> toList(Class<T> rootType, String json, JsonReadOptions options);
 
   /**
    * Convert json reader input into a list of beans of a specific type.
-   *
-   * @throws JsonIOException When IOException occurs
    */
-  public <T> List<T> toList(Class<T> rootType, Reader json) throws JsonIOException;
+  public <T> List<T> toList(Class<T> rootType, Reader json);
+
+  /**
+   * Convert json reader input into a list of beans of a specific type with
+   * options.
+   */
+  public <T> List<T> toList(Class<T> rootType, Reader json, JsonReadOptions options);
 
   /**
    * Use the genericType to determine if this should be converted into a List or
    * bean.
-   *
-   * @throws JsonIOException When IOException occurs
    */
-  public Object toObject(Type genericType, Reader json) throws JsonIOException;
+  public Object toObject(Type genericType, Reader json, JsonReadOptions options);
 
   /**
    * Use the genericType to determine if this should be converted into a List or
    * bean.
-   *
-   * @throws JsonIOException When IOException occurs
    */
-  public Object toObject(Type genericType, String json) throws JsonIOException;
+  public Object toObject(Type genericType, String json, JsonReadOptions options);
 
   /**
    * Write the bean or collection in JSON format to the writer with default
    * options.
-   *
-   * @param value  the bean or collection of beans to write
-   * @param writer used to write the json output to
-   * @throws JsonIOException When IOException occurs
+   * 
+   * @param o
+   *          the bean or collection of beans to write
+   * @param writer
+   *          used to write the json output to
    */
-  public void toJson(Object value, Writer writer) throws JsonIOException;
+  public void toJsonWriter(Object o, Writer writer);
+
+  /**
+   * With additional pretty output option.
+   */
+  public void toJsonWriter(Object o, Writer writer, boolean pretty);
 
   /**
    * With additional options to specify JsonValueAdapter and
    * JsonWriteBeanVisitor's.
-   *
-   * @param value   the bean or collection of beans to write
-   * @param writer  used to write the json output to
-   * @param options additional options to control the JSON output
-   * @throws JsonIOException When IOException occurs
+   * 
+   * @param o
+   *          the bean or collection of beans to write
+   * @param writer
+   *          used to write the json output to
+   * @param options
+   *          additional options to control the JSON output
    */
-  public void toJson(Object value, Writer writer, JsonWriteOptions options) throws JsonIOException;
+  public void toJsonWriter(Object o, Writer writer, boolean pretty, JsonWriteOptions options);
+
+  /**
+   * With additional JSONP callback function.
+   */
+  public void toJsonWriter(Object o, Writer writer, boolean pretty, JsonWriteOptions options,
+      String callback);
 
   /**
    * Convert a bean or collection to json string using default options.
-   *
-   * @throws JsonIOException When IOException occurs
    */
-  public String toJson(Object value) throws JsonIOException;
+  public String toJsonString(Object o);
 
   /**
-   * Convert a bean or collection to json string.
-   *
-   * @throws JsonIOException When IOException occurs
+   * Convert a bean or collection to json string with pretty format using
+   * default options.
    */
-  public String toJson(Object value, JsonWriteOptions options) throws JsonIOException;
+  public String toJsonString(Object o, boolean pretty);
 
   /**
-   * Return true if the type is known as an Entity bean or a List Set or
-   * Map of entity beans.
+   * Convert a bean or collection to json string using options.
+   */
+  public String toJsonString(Object o, boolean pretty, JsonWriteOptions options);
+
+  /**
+   * Convert a bean or collection to json string using a JSONP callback.
+   */
+  public String toJsonString(Object o, boolean pretty, JsonWriteOptions options, String callback);
+
+  /**
+   * Return true if the type is known as an Entity or Xml type or a List Set or
+   * Map of known bean types.
    */
   public boolean isSupportedType(Type genericType);
 
-  /**
-   * Create and return a new JsonGenerator for the given writer.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  public JsonGenerator createGenerator(Writer writer) throws JsonIOException;
-
-  /**
-   * Create and return a new JsonParser for the given reader.
-   *
-   * @throws JsonIOException When IOException occurs
-   */
-  public JsonParser createParser(Reader reader) throws JsonIOException;
 }

src/main/java/com/avaje/ebean/text/json/JsonElement.java

@@ -0,0 +1,39 @@
+package com.avaje.ebean.text.json;
+
+/**
+ * Marker interface for all the Raw JSON types.
+ * <p>
+ * You will only use the JsonElements when you register a JsonReadBeanVisitor.
+ * The JSON elements that are not mapped to a bean property are made available
+ * to the JsonReadBeanVisitor.
+ * </p>
+ * 
+ * @see JsonReadBeanVisitor
+ * 
+ * @author rbygrave
+ */
+public interface JsonElement {
+
+  /**
+   * Return true if this is a JSON primitive type (null, boolean, number or
+   * string).
+   */
+  public boolean isPrimitive();
+
+  /**
+   * Return the string value of this primitive JSON element.
+   * <p>
+   * This can not be used for JsonElementObject or JsonElementArray.
+   * </p>
+   */
+  public String toPrimitiveString();
+
+  public Object eval(String exp);
+
+  public int evalInt(String exp);
+
+  public String evalString(String exp);
+
+  public boolean evalBoolean(String exp);
+
+}

src/main/java/com/avaje/ebean/text/json/JsonElementArray.java

@@ -0,0 +1,112 @@
+package com.avaje.ebean.text.json;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * JSON Array element.
+ * <p>
+ * You will only use the JsonElements when you register a JsonReadBeanVisitor.
+ * The JSON elements that are not mapped to a bean property are made available
+ * to the JsonReadBeanVisitor.
+ * </p>
+ * 
+ * @see JsonReadBeanVisitor
+ * 
+ * @author rbygrave
+ */
+public class JsonElementArray implements JsonElement {
+
+  private final List<JsonElement> values = new ArrayList<JsonElement>();
+
+  public List<JsonElement> getValues() {
+    return values;
+  }
+
+  public void add(JsonElement value) {
+    values.add(value);
+  }
+
+  public String toString() {
+    return values.toString();
+  }
+
+  public boolean isPrimitive() {
+    return false;
+  }
+
+  public String toPrimitiveString() {
+    return null;
+  }
+
+  private String[] split(String exp) {
+    int pos = exp.indexOf('.');
+    if (pos == -1) {
+      return new String[] { exp, null };
+    }
+    String exp0 = exp.substring(0, pos);
+    String exp1 = exp.substring(pos + 1);
+    return new String[] { exp0, exp1 };
+  }
+
+  public Object eval(String exp) {
+    String[] e = split(exp);
+    return eval(e[0], e[1]);
+  }
+
+  public int evalInt(String exp) {
+    String[] e = split(exp);
+    return evalInt(e[0], e[1]);
+  }
+
+  public String evalString(String exp) {
+    String[] e = split(exp);
+    return evalString(e[0], e[1]);
+  }
+
+  public boolean evalBoolean(String exp) {
+    // TODO Auto-generated method stub
+    return false;
+  }
+
+  private Object eval(String exp0, String exp1) {
+    if ("size".equals(exp0)) {
+      return values.size();
+    }
+    if ("isEmpty".equals(exp0)) {
+      return values.isEmpty();
+    }
+    int idx = Integer.parseInt(exp0);
+    JsonElement element = values.get(idx);
+    return element.eval(exp1);
+  }
+
+  private int evalInt(String exp0, String exp1) {
+    if ("size".equals(exp0)) {
+      return values.size();
+    }
+    if ("isEmpty".equals(exp0)) {
+      return values.isEmpty() ? 1 : 0;
+    }
+    int idx = Integer.parseInt(exp0);
+    JsonElement element = values.get(idx);
+    return element.evalInt(exp1);
+  }
+
+  private String evalString(String exp0, String exp1) {
+    if ("size".equals(exp0)) {
+      return String.valueOf(values.size());
+    }
+    if ("isEmpty".equals(exp0)) {
+      return String.valueOf(values.isEmpty());
+    }
+    int idx = Integer.parseInt(exp0);
+    JsonElement element = values.get(idx);
+    return element.evalString(exp1);
+  }
+
+  public String getString() {
+    return toString();
+  }
+
+}

src/main/java/com/avaje/ebean/text/json/JsonElementBoolean.java

@@ -0,0 +1,63 @@
+package com.avaje.ebean.text.json;
+
+/**
+ * JSON boolean element.
+ * <p>
+ * You will only use the JsonElements when you register a JsonReadBeanVisitor.
+ * The JSON elements that are not mapped to a bean property are made available
+ * to the JsonReadBeanVisitor.
+ * </p>
+ * 
+ * @see JsonReadBeanVisitor
+ * 
+ * @author rbygrave
+ */
+
+public class JsonElementBoolean implements JsonElement {
+
+  public static final JsonElementBoolean TRUE = new JsonElementBoolean(true);
+
+  public static final JsonElementBoolean FALSE = new JsonElementBoolean(false);
+
+  private final Boolean value;
+
+  private JsonElementBoolean(Boolean value) {
+    this.value = value;
+  }
+
+  public Boolean getValue() {
+    return value;
+  }
+
+  public String toString() {
+    return Boolean.toString(value);
+  }
+
+  public boolean isPrimitive() {
+    return true;
+  }
+
+  public String toPrimitiveString() {
+    return value.toString();
+  }
+
+  public Object eval(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on boolean");
+    }
+    return value;
+  }
+
+  public int evalInt(String exp) {
+    return value ? 1 : 0;
+  }
+
+  public String evalString(String exp) {
+    return toString();
+  }
+
+  public boolean evalBoolean(String exp) {
+    return value;
+  }
+
+}

src/main/java/com/avaje/ebean/text/json/JsonElementNull.java

@@ -0,0 +1,57 @@
+package com.avaje.ebean.text.json;
+
+/**
+ * JSON null element.
+ * <p>
+ * You will only use the JsonElements when you register a JsonReadBeanVisitor.
+ * The JSON elements that are not mapped to a bean property are made available
+ * to the JsonReadBeanVisitor.
+ * </p>
+ * 
+ * @see JsonReadBeanVisitor
+ * 
+ * @author rbygrave
+ */
+public class JsonElementNull implements JsonElement {
+
+  public static final JsonElementNull NULL = new JsonElementNull();
+
+  private JsonElementNull() {
+  }
+
+  public String getValue() {
+    return "null";
+  }
+
+  public String toString() {
+    return "json null";
+  }
+
+  public boolean isPrimitive() {
+    return true;
+  }
+
+  public String toPrimitiveString() {
+    return null;
+  }
+
+  public Object eval(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on null");
+    }
+    return null;
+  }
+
+  public int evalInt(String exp) {
+    return 0;
+  }
+
+  public String evalString(String exp) {
+    return null;
+  }
+
+  public boolean evalBoolean(String exp) {
+    return false;
+  }
+
+}

src/main/java/com/avaje/ebean/text/json/JsonElementNumber.java

@@ -0,0 +1,67 @@
+package com.avaje.ebean.text.json;
+
+/**
+ * JSON number element.
+ * <p>
+ * You will only use the JsonElements when you register a JsonReadBeanVisitor.
+ * The JSON elements that are not mapped to a bean property are made available
+ * to the JsonReadBeanVisitor.
+ * </p>
+ * 
+ * @see JsonReadBeanVisitor
+ * 
+ * @author rbygrave
+ */
+public class JsonElementNumber implements JsonElement {
+
+  private final String value;
+
+  public JsonElementNumber(String value) {
+    this.value = value;
+  }
+
+  public String getValue() {
+    return value;
+  }
+
+  public String toString() {
+    return value;
+  }
+
+  public boolean isPrimitive() {
+    return true;
+  }
+
+  public String toPrimitiveString() {
+    return value;
+  }
+
+  public Object eval(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on number");
+    }
+    return Double.parseDouble(value);
+  }
+
+  public int evalInt(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on number");
+    }
+    return Integer.parseInt(value);
+  }
+
+  public String evalString(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on number");
+    }
+    return value;
+  }
+
+  public boolean evalBoolean(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on number");
+    }
+    return Boolean.parseBoolean(value);
+  }
+
+}

src/main/java/com/avaje/ebean/text/json/JsonElementObject.java

@@ -0,0 +1,108 @@
+package com.avaje.ebean.text.json;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * JSON Object element.
+ * <p>
+ * You will only use the JsonElements when you register a JsonReadBeanVisitor.
+ * The JSON elements that are not mapped to a bean property are made available
+ * to the JsonReadBeanVisitor.
+ * </p>
+ * 
+ * @see JsonReadBeanVisitor
+ * 
+ * @author rbygrave
+ */
+public class JsonElementObject implements JsonElement {
+
+  private final Map<String, JsonElement> map = new LinkedHashMap<String, JsonElement>();
+
+  public void put(String key, JsonElement value) {
+    map.put(key, value);
+  }
+
+  private String[] split(String exp) {
+    int pos = exp.indexOf('.');
+    if (pos == -1) {
+      return new String[] { exp, null };
+    }
+    String exp0 = exp.substring(0, pos);
+    String exp1 = exp.substring(pos + 1);
+    return new String[] { exp0, exp1 };
+  }
+
+  public Object eval(String exp) {
+    String[] e = split(exp);
+    return eval(e[0], e[1]);
+  }
+
+  public int evalInt(String exp) {
+    String[] e = split(exp);
+    return evalInt(e[0], e[1]);
+  }
+
+  public String evalString(String exp) {
+    if (exp == null) {
+      return map.toString();
+    }
+    String[] e = split(exp);
+    return evalString(e[0], e[1]);
+  }
+
+  public boolean evalBoolean(String exp) {
+    String[] e = split(exp);
+    return evalBoolean(e[0], e[1]);
+  }
+
+  private Object eval(String exp0, String exp1) {
+    JsonElement e = map.get(exp0);
+    return e == null ? null : e.eval(exp1);
+  }
+
+  private int evalInt(String exp0, String exp1) {
+    JsonElement e = map.get(exp0);
+    return e == null ? 0 : e.evalInt(exp1);
+  }
+
+  private String evalString(String exp0, String exp1) {
+    JsonElement e = map.get(exp0);
+    return e == null ? "" : e.evalString(exp1);
+  }
+
+  private boolean evalBoolean(String exp0, String exp1) {
+    JsonElement e = map.get(exp0);
+    return e == null ? false : e.evalBoolean(exp1);
+  }
+
+  public JsonElement get(String key) {
+    return map.get(key);
+  }
+
+  public JsonElement getValue(String key) {
+    return map.get(key);
+  }
+
+  public Set<String> keySet() {
+    return map.keySet();
+  }
+
+  public Set<Map.Entry<String, JsonElement>> entrySet() {
+    return map.entrySet();
+  }
+
+  public String toString() {
+    return map.toString();
+  }
+
+  public boolean isPrimitive() {
+    return false;
+  }
+
+  public String toPrimitiveString() {
+    return null;
+  }
+
+}

src/main/java/com/avaje/ebean/text/json/JsonElementString.java

@@ -0,0 +1,71 @@
+package com.avaje.ebean.text.json;
+
+/**
+ * JSON string element.
+ * <p>
+ * You will only use the JsonElements when you register a JsonReadBeanVisitor.
+ * The JSON elements that are not mapped to a bean property are made available
+ * to the JsonReadBeanVisitor.
+ * </p>
+ * 
+ * @see JsonReadBeanVisitor
+ * 
+ * @author rbygrave
+ */
+public class JsonElementString implements JsonElement {
+
+  private final String value;
+
+  public JsonElementString(String value) {
+    this.value = value;
+  }
+
+  public String getValue() {
+    return value;
+  }
+
+  public String toString() {
+    return value;
+  }
+
+  public boolean isPrimitive() {
+    return true;
+  }
+
+  public String toPrimitiveString() {
+    return value;
+  }
+
+  public Object eval(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on number");
+    }
+    return value;
+  }
+
+  public int evalInt(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on number");
+    }
+    try {
+      return Integer.parseInt(value);
+    } catch (NumberFormatException e) {
+      return 0;
+    }
+  }
+
+  public String evalString(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on number");
+    }
+    return value;
+  }
+
+  public boolean evalBoolean(String exp) {
+    if (exp != null) {
+      throw new IllegalArgumentException("expression [" + exp + "] not allowed on number");
+    }
+    return Boolean.parseBoolean(exp);
+  }
+
+}

src/main/java/com/avaje/ebean/text/json/JsonIOException.java

@@ -1,24 +0,0 @@
-package com.avaje.ebean.text.json;
-
-/**
- * Unchecked exception thrown when an IOException occurs in json processing.
- * <p>
- * Typically wraps the checked IOException.
- * </p>
- */
-public class JsonIOException extends RuntimeException {
-
-  /**
-   * Construct with an underlying cause.
-   */
-  public JsonIOException(Throwable cause) {
-    super(cause);
-  }
-
-  /**
-   * Construct with a message.
-   */
-  public JsonIOException(String message) {
-    super(message);
-  }
-}

src/main/java/com/avaje/ebean/text/json/JsonReadBeanVisitor.java

@@ -0,0 +1,34 @@
+package com.avaje.ebean.text.json;
+
+import java.util.Map;
+
+/**
+ * Provides for some custom handling of json content as it is read.
+ * <p>
+ * This visit method is called after all the known properties of the bean have
+ * been processed. Any JSON elements that could not be mapped to known bean
+ * properties are available in the unmapped Map.
+ * </p>
+ * 
+ * @author rbygrave
+ * 
+ * @param <T>
+ *          The type of entity bean
+ */
+public interface JsonReadBeanVisitor<T> {
+
+  /**
+   * Visit the bean that has just been processed.
+   * <p>
+   * This provides a method of customising the bean and processing any custom
+   * JSON content.
+   * </p>
+   * 
+   * @param bean
+   *          the bean being processed
+   * @param unmapped
+   *          Map of any JSON elements that didn't map to known bean properties
+   */
+  public void visit(T bean, Map<String, JsonElement> unmapped);
+
+}

src/main/java/com/avaje/ebean/text/json/JsonReadOptions.java

@@ -0,0 +1,71 @@
+package com.avaje.ebean.text.json;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Provides the ability to customise the reading of JSON content.
+ * <p>
+ * You can optionally provide a custom JsonValueAdapter to handle specific
+ * formatting for Date and DateTime types.
+ * </p>
+ * <p>
+ * You can optionally register JsonReadBeanVisitors to customise the processing
+ * of the beans as they are processed and handle any custom JSON elements that
+ * could not be mapped to bean properties.
+ * </p>
+ * 
+ * @author rbygrave
+ * 
+ */
+public class JsonReadOptions {
+
+  protected JsonValueAdapter valueAdapter;
+
+  protected Map<String, JsonReadBeanVisitor<?>> visitorMap;
+
+  /**
+   * Default constructor.
+   */
+  public JsonReadOptions() {
+    this.visitorMap = new LinkedHashMap<String, JsonReadBeanVisitor<?>>();
+  }
+
+  /**
+   * Return the JsonValueAdapter.
+   */
+  public JsonValueAdapter getValueAdapter() {
+    return valueAdapter;
+  }
+
+  /**
+   * Return the map of JsonReadBeanVisitor's.
+   */
+  public Map<String, JsonReadBeanVisitor<?>> getVisitorMap() {
+    return visitorMap;
+  }
+
+  /**
+   * Set a JsonValueAdapter for custom DateTime and Date formatting.
+   */
+  public JsonReadOptions setValueAdapter(JsonValueAdapter valueAdapter) {
+    this.valueAdapter = valueAdapter;
+    return this;
+  }
+
+  /**
+   * Register a JsonReadBeanVisitor for the root level.
+   */
+  public JsonReadOptions addRootVisitor(JsonReadBeanVisitor<?> visitor) {
+    return addVisitor(null, visitor);
+  }
+
+  /**
+   * Register a JsonReadBeanVisitor for a given path.
+   */
+  public JsonReadOptions addVisitor(String path, JsonReadBeanVisitor<?> visitor) {
+    visitorMap.put(path, visitor);
+    return this;
+  }
+
+}

src/main/java/com/avaje/ebean/text/json/JsonValueAdapter.java

@@ -0,0 +1,61 @@
+/**
+ * Copyright (C) 2009 Authors
+ * 
+ * This file is part of Ebean.
+ * 
+ * Ebean is free software; you can redistribute it and/or modify it 
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *  
+ * Ebean is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ebean; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
+ */
+package com.avaje.ebean.text.json;
+
+import java.sql.Timestamp;
+
+/**
+ * Allows you to customise the Date and Timestamp formats.
+ * <p>
+ * There is not a standard JSON format for Date or Timestamp types. By default
+ * Ebean uses ISO8601 "yyyy-MM-dd'T'HH:mm:ss.SSSZ" and "yyyy-MM-dd".
+ * </p>
+ * <p>
+ * Note that Ebean will convert Joda types to either of the Date or Timestamp
+ * types and back for you.
+ * </p>
+ * 
+ * @see JsonReadOptions
+ * 
+ * @author rbygrave
+ */
+public interface JsonValueAdapter {
+
+  /**
+   * Convert the Date to json string.
+   */
+  public String jsonFromDate(java.sql.Date date);
+
+  /**
+   * Convert the DateTime to json string.
+   */
+  public String jsonFromTimestamp(java.sql.Timestamp date);
+
+  /**
+   * Parse the JSON string into a Date.
+   */
+  public java.sql.Date jsonToDate(String jsonDate);
+
+  /**
+   * Parse the JSON DateTime into a Timestamp.
+   */
+  public Timestamp jsonToTimestamp(String jsonDateTime);
+
+}

src/main/java/com/avaje/ebean/text/json/JsonWriteBeanVisitor.java

@@ -0,0 +1,33 @@
+package com.avaje.ebean.text.json;
+
+/**
+ * Allows for customising the JSON write processing.
+ * <p>
+ * You can use this to add raw JSON content via {@link JsonWriter}.
+ * </p>
+ * <p>
+ * You register a JsonWriteBeanVisitor with {@link JsonWriteOptions}.
+ * </p>
+ * 
+ * @author rbygrave
+ * 
+ * @param <T>
+ *          the type of entity bean
+ * 
+ * @see JsonWriteOptions
+ */
+public interface JsonWriteBeanVisitor<T> {
+
+  /**
+   * Visit the bean that has just been writing it's content to JSON. You can
+   * write your own additional JSON content to the JsonWriter if you wish.
+   * 
+   * @param bean
+   *          the bean that has been writing it's content
+   * @param jsonWriter
+   *          the JsonWriter which you can append custom json content to if you
+   *          wish.
+   */
+  public void visit(T bean, JsonWriter jsonWriter);
+
+}

src/main/java/com/avaje/ebean/text/json/JsonWriteOptions.java

@@ -1,23 +1,78 @@
 package com.avaje.ebean.text.json;
 
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
 import com.avaje.ebean.text.PathProperties;
 
 /**
  * Provides options for customising the JSON write process.
  * <p>
+ * You can optionally provide a custom JsonValueAdapter to handle specific
+ * formatting for Date and DateTime types.
+ * </p>
+ * <p>
+ * You can optionally register JsonWriteBeanVisitors to customise the processing
+ * of the beans as they are processed and <strong>add raw JSON
+ * elements</strong>.
+ * </p>
+ * <p>
  * You can explicitly state which properties to include in the JSON output for
  * the root level and each path.
  * </p>
  * 
  * <pre class="code">
-
+ * // find some customers ...
+ * 
+ * List&lt;Customer&gt; list = Ebean.find(Customer.class).select(&quot;id, name, status, shippingAddress&quot;)
+ *     .fetch(&quot;billingAddress&quot;,
+ *         &quot;line1, city&quot;).fetch(&quot;billingAddress.country&quot;, &quot;*&quot;).fetch(&quot;contacts&quot;, &quot;firstName,email&quot;)
+ *     .order().desc(&quot;id&quot;)
+ *     .findList();
+ * 
+ * JsonContext json = Ebean.createJsonContext();
+ * 
+ * JsonWriteOptions writeOptions = new JsonWriteOptions();
+ * writeOptions.setRootPathVisitor(new JsonWriteBeanVisitor&lt;Customer&gt;() {
+ * 
+ *   public void visit(Customer bean, JsonWriter ctx) {
+ *     System.out.println(&quot;write visit customer: &quot; + bean);
+ *     ctx.appendKeyValue(&quot;dummyCust&quot;, &quot;34&quot;);
+ *     ctx.appendKeyValue(&quot;smallCustObject&quot;, &quot;{\&quot;a\&quot;:34,\&quot;b\&quot;:\&quot;asdasdasd\&quot;}&quot;);
+ *   }
+ * });
+ * 
+ * writeOptions.setPathProperties(&quot;contacts&quot;, &quot;firstName,id&quot;);
+ * writeOptions.setPathVisitor(&quot;contacts&quot;, new JsonWriteBeanVisitor&lt;Contact&gt;() {
+ * 
+ *   public void visit(Contact bean, JsonWriter ctx) {
+ *     System.out.println(&quot;write additional custom json on customer: &quot; + bean);
+ *     ctx.appendKeyValue(&quot;dummy&quot;, &quot;  3400&quot; + bean.getId() + &quot;&quot;);
+ *     ctx.appendKeyValue(&quot;smallObject&quot;, &quot;{\&quot;contactA\&quot;:34,\&quot;contactB\&quot;:\&quot;banana\&quot;}&quot;);
+ *   }
+ * 
+ * });
+ * 
  * // output as a JSON string with pretty formatting
- * String s = json.toJson(list, true, writeOptions);
+ * String s = json.toJsonString(list, true, writeOptions);
  * 
  * </pre>
+ * 
+ * @see JsonContext#toList(Class, String, JsonReadOptions)
+ * 
+ * @author rbygrave
+ * 
  */
 public class JsonWriteOptions {
 
+  protected String callback;
+
+  protected JsonValueAdapter valueAdapter;
+
+  protected Map<String, JsonWriteBeanVisitor<?>> visitorMap;
+
   protected PathProperties pathProperties;
 
   /**
@@ -33,6 +88,138 @@ public class JsonWriteOptions {
     return o;
   }
 
+  /**
+   * This creates and returns a copy of these options.
+   * <p>
+   * Note that it assumes that the JsonWriteBeanVisitor (if defined) are
+   * immutable and any JsonWriteBeanVisitor instances are shared between the
+   * original and the copy.
+   * </p>
+   */
+  public JsonWriteOptions copy() {
+    JsonWriteOptions copy = new JsonWriteOptions();
+    copy.callback = callback;
+    copy.valueAdapter = valueAdapter;
+    copy.pathProperties = pathProperties;
+    if (visitorMap != null) {
+      copy.visitorMap = new HashMap<String, JsonWriteBeanVisitor<?>>(visitorMap);
+    }
+    return copy;
+  }
+
+  /**
+   * Return a JSONP callback function.
+   */
+  public String getCallback() {
+    return callback;
+  }
+
+  /**
+   * Set a JSONP callback function.
+   */
+  public JsonWriteOptions setCallback(String callback) {
+    this.callback = callback;
+    return this;
+  }
+
+  /**
+   * Return the JsonValueAdapter.
+   */
+  public JsonValueAdapter getValueAdapter() {
+    return valueAdapter;
+  }
+
+  /**
+   * Set a JsonValueAdapter for custom DateTime and Date formatting.
+   */
+  public JsonWriteOptions setValueAdapter(JsonValueAdapter valueAdapter) {
+    this.valueAdapter = valueAdapter;
+    return this;
+  }
+
+  /**
+   * Register a JsonWriteBeanVisitor for the root level.
+   */
+  public JsonWriteOptions setRootPathVisitor(JsonWriteBeanVisitor<?> visitor) {
+    return setPathVisitor(null, visitor);
+  }
+
+  /**
+   * Register a JsonWriteBeanVisitor for the given path.
+   */
+  public JsonWriteOptions setPathVisitor(String path, JsonWriteBeanVisitor<?> visitor) {
+    if (visitorMap == null) {
+      visitorMap = new HashMap<String, JsonWriteBeanVisitor<?>>();
+    }
+    visitorMap.put(path, visitor);
+    return this;
+  }
+
+  /**
+   * Set the properties to include in the JSON output for the given path.
+   * 
+   * @param propertiesToInclude
+   *          The set of properties to output
+   */
+  public JsonWriteOptions setPathProperties(String path, Set<String> propertiesToInclude) {
+    if (pathProperties == null) {
+      pathProperties = new PathProperties();
+    }
+    pathProperties.put(path, propertiesToInclude);
+    return this;
+  }
+
+  /**
+   * Set the properties to include in the JSON output for the given path.
+   * 
+   * @param propertiesToInclude
+   *          Comma delimited list of properties to output
+   */
+  public JsonWriteOptions setPathProperties(String path, String propertiesToInclude) {
+    return setPathProperties(path, parseProps(propertiesToInclude));
+  }
+
+  /**
+   * Set the properties to include in the JSON output for the root level.
+   * 
+   * @param propertiesToInclude
+   *          Comma delimited list of properties to output
+   */
+  public JsonWriteOptions setRootPathProperties(String propertiesToInclude) {
+    return setPathProperties(null, parseProps(propertiesToInclude));
+  }
+
+  /**
+   * Set the properties to include in the JSON output for the root level.
+   * 
+   * @param propertiesToInclude
+   *          The set of properties to output
+   */
+  public JsonWriteOptions setRootPathProperties(Set<String> propertiesToInclude) {
+    return setPathProperties(null, propertiesToInclude);
+  }
+
+  private Set<String> parseProps(String propertiesToInclude) {
+
+    LinkedHashSet<String> props = new LinkedHashSet<String>();
+
+    String[] split = propertiesToInclude.split(",");
+    for (int i = 0; i < split.length; i++) {
+      String s = split[i].trim();
+      if (s.length() > 0) {
+        props.add(s);
+      }
+    }
+    return props;
+  }
+
+  /**
+   * Return the Map of registered JsonWriteBeanVisitor's by path.
+   */
+  public Map<String, JsonWriteBeanVisitor<?>> getVisitorMap() {
+    return visitorMap;
+  }
+
   /**
    * Set the Map of properties to include by path.
    */

src/main/java/com/avaje/ebean/text/json/JsonWriter.java

@@ -0,0 +1,28 @@
+package com.avaje.ebean.text.json;
+
+/**
+ * The JSON Writer made available to JsonWriteBeanVisitor's so that you can
+ * append your own JSON content into the output.
+ * 
+ * @see JsonWriteBeanVisitor
+ * @see JsonWriteOptions#setRootPathVisitor(JsonWriteBeanVisitor)
+ * @see JsonWriteOptions#setPathVisitor(String, JsonWriteBeanVisitor)
+ * 
+ * @author rbygrave
+ */
+public interface JsonWriter {
+
+  /**
+   * Use this to append some custom content into the JSON output.
+   * 
+   * @param key
+   *          the json key
+   * 
+   * @param rawJsonValue
+   *          raw json value
+   */
+  public void appendRawValue(String key, String rawJsonValue);
+
+  public void appendQuoteEscapeValue(String key, String rawJsonValue);
+
+}

src/main/java/com/avaje/ebean/text/json/package-info.java

@@ -19,10 +19,31 @@
  *     .order().desc("id")
  *     .findList();
  * 
- * JsonContext json = Ebean.json();
- *
- *  // output as a JSON string
- * String jsonOutput = json.toJson(list);
+ * JsonContext json = Ebean.createJsonContext();
+ * 
+ * JsonWriteOptions writeOptions = new JsonWriteOptions();
+ * writeOptions.setRootPathVisitor(new JsonWriteBeanVisitor<Customer>() {
+ * 
+ *     public void visit(Customer bean, JsonWriter ctx) {
+ *         System.out.println("write visit customer: " + bean);
+ *         ctx.appendKeyValue("dummyCust", "34");
+ *         ctx.appendKeyValue("smallCustObject", "{\"a\":34,\"b\":\"asdasdasd\"}");
+ *     }
+ * });
+ * 
+ * writeOptions.setPathProperties("contacts", "firstName,id");
+ * writeOptions.setPathVisitor("contacts", new JsonWriteBeanVisitor<Contact>() {
+ * 
+ *     public void visit(Contact bean, JsonWriter ctx) {
+ *         System.out.println("write additional custom json on customer: " + bean);
+ *         ctx.appendKeyValue("dummy", "  3400" + bean.getId() + "");
+ *         ctx.appendKeyValue("smallObject", "{\"contactA\":34,\"contactB\":\"banana\"}");
+ *     }
+ * 
+ * });
+ * 
+ *  // output as a JSON string with pretty formatting
+ * String s = json.toJsonString(list, true, writeOptions);
  * 
  * </pre>
  */

src/main/java/com/avaje/ebeaninternal/api/BindParams.java

@@ -31,12 +31,6 @@ public class BindParams implements Serializable {
 	 */
 	private String preparedSql;
 
-  /**
-   * Bind hash and count used to detect when the bind values have changed such
-   * that the generated SQL (with named parameters) needs to be recalculated.
-   */
-  private int[] bindHash;
-
 	public BindParams() {  
 	}
 	
@@ -57,33 +51,20 @@ public class BindParams implements Serializable {
    * </p>
    */
   public void buildQueryPlanHash(HashQueryPlanBuilder builder) {
-    int[] vals = calcQueryPlanHash();
-    builder.add(vals[0]).bind(vals[1]);
-  }
-
-  /**
-   * Calculate and return a query plan bind hash with total bind count.
-   */
-  public int[] calcQueryPlanHash() {
-    int tempBindCount;
-    int bc = 0;
     int hc = 31;
     for (Param param : positionedParameters) {
-      tempBindCount = param.queryBindCount();
-      bc += tempBindCount;
-      hc = hc * 31 + tempBindCount;
+      hc = hc * 31 + param.queryBindCount();
     }
 
     for (Map.Entry<String, Param> entry : namedParameters.entrySet()) {
-      tempBindCount = entry.getValue().queryBindCount();
-      bc += tempBindCount;
       hc = hc * 31 + entry.getKey().hashCode();
-      hc = hc * 31 + tempBindCount;
+      hc = hc * 31 + entry.getValue().queryBindCount();
     }
 
-    return new int[]{hc, bc};
+    int bindCount = positionedParameters.size() + namedParameters.size();
+    builder.add(hc).bind(bindCount);
   }
-
+ 
 	/**
 	 * Return a deep copy of the BindParams.
 	 */
@@ -129,7 +110,7 @@ public class BindParams implements Serializable {
 	 * parameters ordered.
 	 */
 	public boolean requiresNamedParamsPrepare() {
-		return !namedParameters.isEmpty();
+		return !namedParameters.isEmpty() && positionedParameters.isEmpty();
 	}
 
 	/**
@@ -169,7 +150,7 @@ public class BindParams implements Serializable {
 	}
 
 	private Param getParam(String name) {
-		Param p = namedParameters.get(name);
+		Param p = (Param) namedParameters.get(name);
 		if (p == null) {
 			p = new Param();
 			namedParameters.put(name, p);
@@ -184,7 +165,7 @@ public class BindParams implements Serializable {
 				positionedParameters.add(new Param());
 			}
 		}
-		return positionedParameters.get(position - 1);
+		return (Param) positionedParameters.get(position - 1);
 	}
 
 	/**
@@ -272,29 +253,7 @@ public class BindParams implements Serializable {
 		return preparedSql;
 	}
 
-  /**
-   * Return true if the bind hash and count has not changed.
-   */
-  public boolean isSameBindHash() {
-
-    if (bindHash == null) {
-      bindHash = calcQueryPlanHash();
-      return false;
-    }
-    int[] oldPlan = bindHash;
-    bindHash = calcQueryPlanHash();
-    return bindHash[0] == oldPlan[0] && bindHash[1] == oldPlan[1];
-  }
-
-  /**
-   * Create a new positioned parameters orderedList.
-   */
-  public OrderedList createOrderedList() {
-    positionedParameters.clear();
-    return new OrderedList(positionedParameters);
-  }
-
-  /**
+	/**
 	 * The bind parameters in the correct binding order.
 	 * <p>
 	 * This is the result of converting sql with named parameters
@@ -368,6 +327,8 @@ public class BindParams implements Serializable {
 
 		private Object outValue;
 
+		private int textLocation;
+
 		/**
 		 * Construct a Parameter.
 		 */
@@ -407,8 +368,17 @@ public class BindParams implements Serializable {
 		}
 
 		public boolean equals(Object o) {
-      return o != null && (o == this || (o instanceof Param) && hashCode() == o.hashCode());
-    }
+			if (o == null) {
+				return false;
+			}
+			if (o == this) {
+				return true;
+			}
+			if (o instanceof Param) {
+				return hashCode() == o.hashCode();
+			}
+			return false;
+		}
 		
 		/**
 		 * Return true if this is an In parameter that needs to be bound before
@@ -493,6 +463,21 @@ public class BindParams implements Serializable {
 			this.outValue = out;
 		}
 
+		/**
+		 * Return the location this parameter was found in the sql text.
+		 */
+		public int getTextLocation() {
+			return textLocation;
+		}
+
+		/**
+		 * Set the location in the sql text this parameter was located. This is
+		 * used to control order for named parameters.
+		 */
+		public void setTextLocation(int textLocation) {
+			this.textLocation = textLocation;
+		}
+
     /**
      * If true do not include this value in a transaction log.
      */

src/main/java/com/avaje/ebeaninternal/api/LoadBeanBuffer.java

@@ -11,8 +11,6 @@ import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
  */
 public interface LoadBeanBuffer {
 
-  public int getBatchSize();
-
   public List<EntityBeanIntercept> getBatch();
   
   public BeanDescriptor<?> getBeanDescriptor();

src/main/java/com/avaje/ebeaninternal/api/LoadBeanRequest.java

@@ -2,8 +2,8 @@ package com.avaje.ebeaninternal.api;
 
 import java.util.List;
 
+import com.avaje.ebean.Transaction;
 import com.avaje.ebean.bean.EntityBeanIntercept;
-import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
 
 /**
  * Request for loading ManyToOne and OneToOne relationships.
@@ -18,12 +18,10 @@ public class LoadBeanRequest extends LoadRequest {
 
   private final boolean loadCache;
 
-  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, boolean lazy, String lazyLoadProperty, boolean loadCache) {
-    this(LoadBuffer, null, lazy, lazyLoadProperty, loadCache);
-  }
-  
-  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, OrmQueryRequest<?> parentRequest, boolean lazy, String lazyLoadProperty, boolean loadCache) {
-    super(parentRequest, lazy);
+  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, Transaction transaction, boolean lazy, String lazyLoadProperty,
+      boolean loadCache) {
+
+    super(transaction, lazy);
     this.LoadBuffer = LoadBuffer;
     this.batch = LoadBuffer.getBatch();
     this.lazyLoadProperty = lazyLoadProperty;
@@ -59,7 +57,4 @@ public class LoadBeanRequest extends LoadRequest {
     return lazyLoadProperty;
   }
 
-  public int getBatchSize() {
-    return getLoadContext().getBatchSize();
-  }
 }

src/main/java/com/avaje/ebeaninternal/api/LoadContext.java

@@ -11,16 +11,16 @@ import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
  */
 public interface LoadContext {
 
-  /**
-   * Return the minimum batch size when using QueryIterator with query joins.
-   */
-  public int getSecondaryQueriesMinBatchSize(OrmQueryRequest<?> parentRequest, int defaultQueryBatch);
+    /**
+     * Return the minimum batch size when using QueryIterator with query joins.
+     */
+    public int getSecondaryQueriesMinBatchSize(OrmQueryRequest<?> parentRequest, int defaultQueryBatch);
 
 	/**
 	 * Execute any secondary (+query) queries if there are any defined.
 	 * @param parentRequest the originating query request
 	 */
-	public void executeSecondaryQueries(OrmQueryRequest<?> parentRequest);
+	public void executeSecondaryQueries(OrmQueryRequest<?> parentRequest, int defaultQueryBatch);
 
 	/**
 	 * Register any secondary queries (+query or +lazy) with their

src/main/java/com/avaje/ebeaninternal/api/LoadManyBuffer.java

@@ -13,8 +13,6 @@ import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
  */
 public interface LoadManyBuffer {
 
-  public int getBatchSize();
-
   public List<BeanCollection<?>> getBatch();
   
   public BeanPropertyAssocMany<?> getBeanProperty();

src/main/java/com/avaje/ebeaninternal/api/LoadManyRequest.java

@@ -2,76 +2,69 @@ package com.avaje.ebeaninternal.api;
 
 import java.util.List;
 
+import com.avaje.ebean.Transaction;
 import com.avaje.ebean.bean.BeanCollection;
-import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
 
 /**
- * Request for loading Associated Many Beans.
+ * Request for loading Associated One Beans.
  */
 public class LoadManyRequest extends LoadRequest {
 
-  private final List<BeanCollection<?>> batch;
 
-  private final LoadManyBuffer loadContext;
+	private final List<BeanCollection<?>> batch;
 
-  private final boolean onlyIds;
+	private final LoadManyBuffer loadContext;
 
-  private final boolean loadCache;
+	private final boolean onlyIds;
+	
+	private final boolean loadCache;
+	
+  public LoadManyRequest(LoadManyBuffer loadContext, Transaction transaction, int batchSize, boolean lazy,
+      boolean onlyIds, boolean loadCache) {
 
-  public LoadManyRequest(LoadManyBuffer loadContext, boolean lazy, boolean onlyIds, boolean loadCache) {
-    this(loadContext, null, lazy, onlyIds, loadCache);
-  }
-  
-  public LoadManyRequest(LoadManyBuffer loadContext, OrmQueryRequest<?> parentRequest,  boolean lazy, boolean onlyIds, boolean loadCache) {
+		super(transaction, lazy);
+		this.loadContext = loadContext;
+		this.batch = loadContext.getBatch();
+		this.onlyIds = onlyIds;
+		this.loadCache = loadCache;
+	}
 
-    super(parentRequest, lazy);
-    this.loadContext = loadContext;
-    this.batch = loadContext.getBatch();
-    this.onlyIds = onlyIds;
-    this.loadCache = loadCache;
-  }
+	public String getDescription() {
+		return "path:" + loadContext.getFullPath() + " size:"+ batch.size();
+	}
 
-  public String getDescription() {
-    return "path:" + loadContext.getFullPath() + " size:" + batch.size();
-  }
+	/**
+	 * Return the batch of collections to actually load.
+	 */
+	public List<BeanCollection<?>> getBatch() {
+		return batch;
+	}
 
-  /**
-   * Return the batch of collections to actually load.
-   */
-  public List<BeanCollection<?>> getBatch() {
-    return batch;
-  }
+	/**
+	 * Return the load context.
+	 */
+	public LoadManyBuffer getLoadContext() {
+		return loadContext;
+	}
 
-  /**
-   * Return the load context.
-   */
-  public LoadManyBuffer getLoadContext() {
-    return loadContext;
-  }
+	/**
+	 * Return true if lazy loading should only load the id values.
+	 * <p>
+	 * This for use when lazy loading is invoked on methods such
+	 * as clear() and removeAll() where it generally makes sense to
+	 * only fetch the Id values as the other property information is 
+	 * not used.
+	 * </p>
+	 */
+	public boolean isOnlyIds() {
+		return onlyIds;
+	}
 
-  /**
-   * Return true if lazy loading should only load the id values.
-   * <p>
-   * This for use when lazy loading is invoked on methods such as clear() and removeAll() where it
-   * generally makes sense to only fetch the Id values as the other property information is not
-   * used.
-   * </p>
-   */
-  public boolean isOnlyIds() {
-    return onlyIds;
-  }
-
-  /**
-   * Return true if we should load the Collection ids into the cache.
-   */
-  public boolean isLoadCache() {
-    return loadCache;
-  }
-
-  /**
-   * Return the batch size used for this load context.
-   */
-  public int getBatchSize() {
-    return loadContext.getBatchSize();
-  }
+	/**
+	 * Return true if we should load the Collection ids into the cache.
+	 */
+	public boolean isLoadCache() {
+    	return loadCache;
+    }
+	
 }

src/main/java/com/avaje/ebeaninternal/api/LoadRequest.java

@@ -1,36 +1,22 @@
 package com.avaje.ebeaninternal.api;
 
 import com.avaje.ebean.Transaction;
-import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
 
 /**
  * Request for loading Associated One Beans.
  */
 public abstract class LoadRequest {
 
-  protected final OrmQueryRequest<?> parentRequest;
+	protected final boolean lazy;
 
-  protected final Transaction transaction;
+	protected final Transaction transaction;
 
-  protected final boolean lazy;
+	public LoadRequest(Transaction transaction, boolean lazy) {
 
-	public LoadRequest(OrmQueryRequest<?> parentRequest, boolean lazy) {
-
-	  this.parentRequest = parentRequest;
-		this.transaction = parentRequest == null ? null : parentRequest.getTransaction();
+		this.transaction = transaction;
 		this.lazy = lazy;
 	}
 
-  /**
-   * Log the just executed secondary query with the 'root' query if 'logSecondaryQuery' is set to
-   * true. This is for testing purposes to confirm the secondary query executes etc.
-   */
-  public void logSecondaryQuery(SpiQuery<?> query) {
-    if (parentRequest != null && parentRequest.isLogSecondaryQuery()) {
-      parentRequest.getQuery().logSecondaryQuery(query);
-    }
-  }
-  
 	/**
 	 * Return true if this is a lazy load and false if it is a secondary query.
 	 */

src/main/java/com/avaje/ebeaninternal/api/LoadSecondaryQuery.java

@@ -13,6 +13,9 @@ public interface LoadSecondaryQuery {
 
 	/**
 	 * Execute the secondary query with a given batch size.
+	 * 
+	 * @param parentRequest
+	 *            the originating query request
 	 */
-	public void loadSecondaryQuery(OrmQueryRequest<?> parentRequest);
+	public void loadSecondaryQuery(OrmQueryRequest<?> parentRequest, int requestedBatchSize, boolean all);
 }

src/main/java/com/avaje/ebeaninternal/api/ManyWhereJoins.java

@@ -1,15 +1,13 @@
 package com.avaje.ebeaninternal.api;
 
 import java.io.Serializable;
-import java.util.Collection;
-import java.util.TreeMap;
+import java.util.Set;
 import java.util.TreeSet;
 
 import com.avaje.ebeaninternal.server.deploy.BeanProperty;
 import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
 import com.avaje.ebeaninternal.server.el.ElPropertyDeploy;
 import com.avaje.ebeaninternal.server.query.SplitName;
-import com.avaje.ebeaninternal.server.query.SqlJoinType;
 
 /**
  * Holds the joins needs to support the many where predicates.
@@ -19,32 +17,12 @@ public class ManyWhereJoins implements Serializable {
 
     private static final long serialVersionUID = -6490181101871795417L;
     
-    private final TreeMap<String,PropertyJoin> joins = new TreeMap<String,PropertyJoin>();
+    private final TreeSet<String> joins = new TreeSet<String>();
 
     private StringBuilder formulaProperties = new StringBuilder();
     
     private boolean formulaWithJoin;
 
-  /**
-   * 'Mode' indicating that joins added while this is true are required to be outer joins.
-   */
-    private boolean requireOuterJoins;
-    
-    /**
-     * Return the current 'mode' indicating if outer joins are currently required or not.
-     */
-    public boolean isRequireOuterJoins() {
-      return requireOuterJoins;
-    }
-
-    /**
-     * Set the 'mode' to be that joins added are required to be outer joins.
-     * This is set during the evaluation of disjunction predicates.
-     */
-    public void setRequireOuterJoins(boolean requireOuterJoins) {
-      this.requireOuterJoins = requireOuterJoins;
-    }
-
     /**
      * Add a many where join.
      */
@@ -53,15 +31,13 @@ public class ManyWhereJoins implements Serializable {
         String join = elProp.getElPrefix();
         BeanProperty p = elProp.getBeanProperty();
         if (p instanceof BeanPropertyAssocMany<?>){
-            join = addManyToJoin(join, p.getName());          
+            join = addManyToJoin(join, p.getName());
         }
         if (join != null){
-            addJoin(join);
-            if (p != null) {
-              String secondaryTableJoinPrefix = p.getSecondaryTableJoinPrefix();
-              if (secondaryTableJoinPrefix != null) {
-                addJoin(join+"."+secondaryTableJoinPrefix);
-              }
+            joins.add(join);
+            String secondaryTableJoinPrefix = p.getSecondaryTableJoinPrefix();
+            if (secondaryTableJoinPrefix != null) {
+                joins.add(join+"."+secondaryTableJoinPrefix);
             }
             addParentJoins(join);
         }
@@ -82,16 +58,11 @@ public class ManyWhereJoins implements Serializable {
     private void addParentJoins(String join) {
         String[] split = SplitName.split(join);
         if (split[0] != null){
-            addJoin(split[0]);
+            joins.add(split[0]);
             addParentJoins(split[0]);
         }
     }
 
-    private void addJoin(String property) {
-      SqlJoinType joinType = (requireOuterJoins) ? SqlJoinType.OUTER: SqlJoinType.INNER; 
-      joins.put(property, new PropertyJoin(property, joinType));
-    }
-    
     /**
      * Return true if there are no extra many where joins.
      */
@@ -102,22 +73,10 @@ public class ManyWhereJoins implements Serializable {
     /**
      * Return the set of many where joins.
      */
-    public Collection<PropertyJoin> getPropertyJoins() {
-        return joins.values();
+    public Set<String> getJoins() {
+        return joins;
     }
-
-    /**
-     * Return the set of property names for the many where joins.
-     */
-    public TreeSet<String> getPropertyNames() {
-      
-      TreeSet<String> propertyNames = new TreeSet<String>();
-      for (PropertyJoin join : joins.values()) {
-        propertyNames.add(join.getProperty());
-      }
-      return propertyNames;
-    }
-
+    
     /**
      * In findRowCount query found a formula property with a join clause so building a select clause
      * specifically for the findRowCount query.

src/main/java/com/avaje/ebeaninternal/api/PropertyJoin.java

@@ -1,39 +0,0 @@
-package com.avaje.ebeaninternal.api;
-
-import com.avaje.ebeaninternal.server.query.SqlJoinType;
-
-/**
- * Represents a join required for a given property and whether than needs to be an outer join.
- */
-public class PropertyJoin {
-
-  /**
-   * The property name.
-   */
-  private final String property;
-  
-  /**
-   * Set to true if the property needs to be an outer join.
-   */
-  private final SqlJoinType joinType;
-
-  public PropertyJoin(String property, SqlJoinType joinType) {
-    this.property = property;
-    this.joinType = joinType;
-  }
-
-  /**
-   * Return the property that should be joined.
-   */
-  public String getProperty() {
-    return property;
-  }
-
-  /**
-   * Return true if this join is required to be an outer join.
-   */
-  public SqlJoinType getSqlJoinType() {
-    return joinType;
-  }
-  
-}

src/main/java/com/avaje/ebeaninternal/api/SpiEbeanServer.java

@@ -2,12 +2,14 @@ package com.avaje.ebeaninternal.api;
 
 import java.util.List;
 
-import com.avaje.ebean.*;
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.Query;
+import com.avaje.ebean.Transaction;
+import com.avaje.ebean.TxScope;
 import com.avaje.ebean.bean.BeanCollectionLoader;
 import com.avaje.ebean.bean.BeanLoader;
 import com.avaje.ebean.bean.CallStack;
 import com.avaje.ebean.bean.ObjectGraphNode;
-import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 import com.avaje.ebeaninternal.server.autofetch.AutoFetchManager;
 import com.avaje.ebeaninternal.server.core.PstmtBatch;
@@ -28,15 +30,18 @@ public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionL
    */
   public void shutdownManaged();
 
-  /**
-   * Return true if query origins should be collected.
-   */
   public boolean isCollectQueryOrigins();
   
   /**
-   * Return the server configuration.
+   * Return true if DeleteMissingChildren defaults to true for stateless
+   * updates.
    */
-  public ServerConfig getServerConfig();
+  public boolean isDefaultDeleteMissingChildren();
+
+  /**
+   * Return true if UpdateNullProperties defaults to true for stateless updates.
+   */
+  public boolean isDefaultUpdateNullProperties();
 
   /**
    * Return the DatabasePlatform for this server.
@@ -60,11 +65,6 @@ public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionL
    */
   public CallStack createCallStack();
 
-  /**
-   * Return the PersistenceContextScope to use defined at query or server level.
-   */
-  public PersistenceContextScope getPersistenceContextScope(SpiQuery<?> query);
-
   /**
    * Return the DDL generator.
    */

src/main/java/com/avaje/ebeaninternal/api/SpiExpression.java

@@ -10,12 +10,13 @@ import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
  */
 public interface SpiExpression extends Expression {
 
-  /**
-   * Process "Many" properties populating ManyWhereJoins.
-   * <p>
-   * Predicates on Many properties require an extra independent join clause.
-   * </p>
-   */
+	/**
+	 * Process "Many" properties populating ManyWhereJoins.
+	 * <p>
+	 * Predicates on Many properties require an extra independent
+     * join clause.
+	 * </p>
+	 */
 	public void containsMany(BeanDescriptor<?> desc, ManyWhereJoins whereManyJoins);
 	
 	/**

src/main/java/com/avaje/ebeaninternal/api/SpiExpressionFactory.java

@@ -1,12 +1,13 @@
 package com.avaje.ebeaninternal.api;
 
 import com.avaje.ebean.ExpressionFactory;
+import com.avaje.ebeaninternal.server.expression.FilterExprPath;
 
 public interface SpiExpressionFactory extends ExpressionFactory {
 
-  /**
-   * Create another expression factory with a given sub path.
-   */
-  public ExpressionFactory createExpressionFactory();
-
+    /**
+     * Create another expression factory with a given sub path.
+     */
+    public ExpressionFactory createExpressionFactory();//FilterExprPath prefix);
+    
 }

src/main/java/com/avaje/ebeaninternal/api/SpiExpressionRequest.java

@@ -44,14 +44,9 @@ public interface SpiExpressionRequest {
 	 * Return the ordered list of bind values for all expressions in this request.
 	 */
 	public ArrayList<Object> getBindValues();
-
-  /**
-   * Increments the parameter index and returns that value.
-   */
-  public int nextParameter();
-
-  /**
-   * Append a DB Like clause.
-   */
-  public void appendLike();
+	
+    /**
+     * Increments the parameter index and returns that value.
+     */
+    public int nextParameter();
 }

src/main/java/com/avaje/ebeaninternal/api/SpiQuery.java

@@ -5,7 +5,6 @@ import java.util.List;
 
 import com.avaje.ebean.ExpressionList;
 import com.avaje.ebean.OrderBy;
-import com.avaje.ebean.PersistenceContextScope;
 import com.avaje.ebean.Query;
 import com.avaje.ebean.bean.BeanCollectionTouched;
 import com.avaje.ebean.bean.CallStack;
@@ -27,7 +26,7 @@ import com.avaje.ebeaninternal.server.querydefn.OrmQueryProperties;
  */
 public interface SpiQuery<T> extends Query<T> {
 
-  public enum Mode {
+    public enum Mode {
         NORMAL(false), LAZYLOAD_MANY(false), LAZYLOAD_BEAN(true), REFRESH_BEAN(true);
         Mode(boolean loadContextBean) {
             this.loadContextBean = loadContextBean;
@@ -80,20 +79,7 @@ public interface SpiQuery<T> extends Query<T> {
          */
         SUBQUERY
     }
-
-  /**
-   * Return the PersistenceContextScope that this query should use.
-   * <p>
-   * This can be null and in that case use the default scope.
-   * </p>
-   */
-  public PersistenceContextScope getPersistenceContextScope();
-
-  /**
-   * Return the default lazy load batch size.
-   */
-  public int getLazyLoadBatchSize();
-
+    
     /**
      * Return true if select all properties was used to ensure the property
      * invoking a lazy load was included in the query.
@@ -274,25 +260,10 @@ public interface SpiQuery<T> extends Query<T> {
      */
     public Boolean isAutofetch();
 
-    /**
-     * Set to true if you want to capture executed secondary queries. 
-     */
-    public void setLogSecondaryQuery(boolean logSecondaryQuery);
-
-    /**
-     * Return true if executed secondary queries should be captured.
-     */
-    public boolean isLogSecondaryQuery();
-
-    /**
-     * Return the list of secondary queries that were executed.
-     */
-    public List<SpiQuery<?>> getLoggedSecondaryQueries(); 
-    
-    /**
-     * Log an executed secondary query.
-     */
-    public void logSecondaryQuery(SpiQuery<?> query);
+//    /**
+//     * Return explicit forUpdate setting or null.
+//     */
+//    public boolean isForUpdate();
 
     /**
      * If return null then no autoFetch profiling for this query. If a
@@ -546,24 +517,12 @@ public interface SpiQuery<T> extends Query<T> {
      * Return the index of the first row to return in the query.
      */
     public int getFirstRow();
-    
-    /**
-     * Internally set by Ebean when this query must use the DISTINCT keyword.
-     * <p>
-     * This does not exclude/remove the use of the id property.
-     */
-    public Query<T> setSqlDistinct(boolean sqlDistinct);
 
     /**
-     * Return true if this query has been specified by a user or internally by Ebean to use DISTINCT.
-     */
-    public boolean isDistinctQuery();
-
-    /**
-     * Return true if this query has been specified by a user to use DISTINCT.
+     * return true if this query uses DISTINCT.
      */
     public boolean isDistinct();
-    
+
     /**
      * Set default select clauses where none have been explicitly defined.
      */

src/main/java/com/avaje/ebeaninternal/api/SpiSqlUpdate.java

@@ -5,6 +5,4 @@ import com.avaje.ebean.SqlUpdate;
 public interface SpiSqlUpdate extends SqlUpdate {
 
 	public BindParams getBindParams();
-
-  public void setGeneratedSql(String sql);
 }

src/main/java/com/avaje/ebeaninternal/api/SpiTransaction.java

@@ -15,183 +15,178 @@ import com.avaje.ebeaninternal.server.persist.BatchControl;
  */
 public interface SpiTransaction extends Transaction {
 
-  /**
-   * End the transaction when had query only use.
-   */
-  public void endQueryOnly();
-
   /**
    * Return the string prefix with the transactin id and label used in logging.
    */
   public String getLogPrefix();
+  
+	/**
+	 * Return true if generated SQL and Bind values should be logged to the
+	 * transaction log.
+	 */
+	public boolean isLogSql();
 
-  /**
-   * Return true if generated SQL and Bind values should be logged to the
-   * transaction log.
-   */
-  public boolean isLogSql();
+	/**
+	 * Return true if summary level events should be logged to the transaction
+	 * log.
+	 */
+	public boolean isLogSummary();
 
-  /**
-   * Return true if summary level events should be logged to the transaction
-   * log.
-   */
-  public boolean isLogSummary();
+	/**
+	 * Log a message to the SQL logger.
+	 */
+	public void logSql(String msg);
 
-  /**
-   * Log a message to the SQL logger.
-   */
-  public void logSql(String msg);
+	/**
+	 * Log a message to the SUMMARY logger.
+	 */
+	public void logSummary(String msg);
 
-  /**
-   * Log a message to the SUMMARY logger.
-   */
-  public void logSummary(String msg);
+	/**
+	 * Register a "Derived Relationship" (that requires an additional update).
+	 */
+	public void registerDerivedRelationship(DerivedRelationshipData assocBean);
 
-  /**
-   * Register a "Derived Relationship" (that requires an additional update).
-   */
-  public void registerDerivedRelationship(DerivedRelationshipData assocBean);
+	/**
+	 * Return the list of "Derived Relationships" that must be maintained after
+	 * insert.
+	 */
+	public List<DerivedRelationshipData> getDerivedRelationship(Object bean);
 
-  /**
-   * Return the list of "Derived Relationships" that must be maintained after
-   * insert.
-   */
-  public List<DerivedRelationshipData> getDerivedRelationship(Object bean);
+	/**
+	 * Add a deleting bean to the registered list.
+	 * <p>
+	 * This is to handle bi-directional relationships where both sides Cascade.
+	 * </p>
+	 */
+	public void registerDeleteBean(Integer hash);
 
-  /**
-   * Add a deleting bean to the registered list.
-   * <p>
-   * This is to handle bi-directional relationships where both sides Cascade.
-   * </p>
-   */
-  public void registerDeleteBean(Integer hash);
+	/**
+	 * Unregister the hash of the bean.
+	 */
+	public void unregisterDeleteBean(Integer hash);
 
-  /**
-   * Unregister the hash of the bean.
-   */
-  public void unregisterDeleteBean(Integer hash);
+	/**
+	 * Return true if this is a bean that has already been saved/deleted.
+	 */
+	public boolean isRegisteredDeleteBean(Integer hash);
 
-  /**
-   * Return true if this is a bean that has already been saved/deleted.
-   */
-  public boolean isRegisteredDeleteBean(Integer hash);
+	/**
+	 * Unregister the persisted bean.
+	 */
+	public void unregisterBean(Object bean);
 
-  /**
-   * Unregister the persisted bean.
-   */
-  public void unregisterBean(Object bean);
+	/**
+	 * Return true if this is a bean that has already been persisted in the
+	 * current recursive save request. The goal is to stop recursively saving
+	 * the bean when cascade persist is on both sides of a relationship).
+	 * <p>
+	 * This will register the bean if it is not already.
+	 * </p>
+	 */
+	public boolean isRegisteredBean(Object bean);
 
-  /**
-   * Return true if this is a bean that has already been persisted in the
-   * current recursive save request. The goal is to stop recursively saving
-   * the bean when cascade persist is on both sides of a relationship).
-   * <p>
-   * This will register the bean if it is not already.
-   * </p>
-   */
-  public boolean isRegisteredBean(Object bean);
+	/**
+	 * Returns a String used to identify the transaction. This id is used for
+	 * Transaction logging.
+	 */
+	public String getId();
 
-  /**
-   * Returns a String used to identify the transaction. This id is used for
-   * Transaction logging.
-   */
-  public String getId();
+	/**
+	 * Return the batchSize specifically set for this transaction or 0.
+	 * <p>
+	 * Returning 0 implies to use the system wide default batch size.
+	 * </p>
+	 */
+	public int getBatchSize();
 
-  /**
-   * Return the batchSize specifically set for this transaction or 0.
-   * <p>
-   * Returning 0 implies to use the system wide default batch size.
-   * </p>
-   */
-  public int getBatchSize();
+	/**
+	 * Modify and return the current 'depth' of the transaction.
+	 * <p>
+	 * As we cascade save or delete we traverse the object graph tree. Going up
+	 * to Assoc Ones the depth decreases and going down to Assoc Manys the depth
+	 * increases.
+	 * </p>
+	 * <p>
+	 * The depth is used for ordering batching statements. The lowest depth get
+	 * executed first during save.
+	 * </p>
+	 */
+	public int depth(int diff);
 
-  /**
-   * Modify and return the current 'depth' of the transaction.
-   * <p>
-   * As we cascade save or delete we traverse the object graph tree. Going up
-   * to Assoc Ones the depth decreases and going down to Assoc Manys the depth
-   * increases.
-   * </p>
-   * <p>
-   * The depth is used for ordering batching statements. The lowest depth get
-   * executed first during save.
-   * </p>
-   */
-  public int depth(int diff);
+	/**
+	 * Return true if this transaction was created explicitly via
+	 * <code>Ebean.beginTransaction()</code>.
+	 */
+	public boolean isExplicit();
 
-  /**
-   * Return true if this transaction was created explicitly via
-   * <code>Ebean.beginTransaction()</code>.
-   */
-  public boolean isExplicit();
+	/**
+	 * Get the object that holds the event details.
+	 * <p>
+	 * This information is used maintain the table state, cache and text
+	 * indexes. On commit the Table modifications this generates is broadcast
+	 * around the cluster (if you have a cluster).
+	 * </p>
+	 */
+	public TransactionEvent getEvent();
 
-  /**
-   * Get the object that holds the event details.
-   * <p>
-   * This information is used maintain the table state, cache and text
-   * indexes. On commit the Table modifications this generates is broadcast
-   * around the cluster (if you have a cluster).
-   * </p>
-   */
-  public TransactionEvent getEvent();
+	/**
+	 * Whether persistCascade is on for save and delete.
+	 */
+	public boolean isPersistCascade();
 
-  /**
-   * Whether persistCascade is on for save and delete.
-   */
-  public boolean isPersistCascade();
+	/**
+	 * Return true if this request should be batched. Conversely returns false
+	 * if this request should be executed immediately.
+	 */
+	public boolean isBatchThisRequest();
 
-  /**
-   * Return true if this request should be batched. Conversely returns false
-   * if this request should be executed immediately.
-   */
-  public boolean isBatchThisRequest();
+	/**
+	 * Return the queue used to batch up persist requests.
+	 */
+	public BatchControl getBatchControl();
 
-  /**
-   * Return the queue used to batch up persist requests.
-   */
-  public BatchControl getBatchControl();
+	/**
+	 * Set the queue used to batch up persist requests. There should only be one
+	 * PersistQueue set per transaction.
+	 */
+	public void setBatchControl(BatchControl control);
 
-  /**
-   * Set the queue used to batch up persist requests. There should only be one
-   * PersistQueue set per transaction.
-   */
-  public void setBatchControl(BatchControl control);
+	/**
+	 * Return the persistence context associated with this transaction.
+	 * <p>
+	 * You may wish to hold onto this and set it against another transaction
+	 * later. This is along the lines of 'extended persistence context'
+	 * behaviour.
+	 * </p>
+	 */
+	public PersistenceContext getPersistenceContext();
 
-  /**
-   * Return the persistence context associated with this transaction.
-   * <p>
-   * You may wish to hold onto this and set it against another transaction
-   * later. This is along the lines of 'extended persistence context'
-   * behaviour.
-   * </p>
-   */
-  public PersistenceContext getPersistenceContext();
+	/**
+	 * Set the persistence context to this transaction.
+	 * <p>
+	 * This could be considered similar to 'EJB3 Extended Persistence Context'.
+	 * In that you can get the PersistenceContext from a transaction, hold onto
+	 * it, and then set it back later to a second transaction. In general there
+	 * is one PersistenceContext per Transaction. The getPersistenceContext()
+	 * and setPersistenceContext() enable a developer to reuse a single
+	 * PersistenceContext with multiple transactions.
+	 * </p>
+	 */
+	public void setPersistenceContext(PersistenceContext context);
 
-  /**
-   * Set the persistence context to this transaction.
-   * <p>
-   * This could be considered similar to 'EJB3 Extended Persistence Context'.
-   * In that you can get the PersistenceContext from a transaction, hold onto
-   * it, and then set it back later to a second transaction. In general there
-   * is one PersistenceContext per Transaction. The getPersistenceContext()
-   * and setPersistenceContext() enable a developer to reuse a single
-   * PersistenceContext with multiple transactions.
-   * </p>
-   */
-  public void setPersistenceContext(PersistenceContext context);
+	/**
+	 * Return the underlying Connection for internal use.
+	 * <p>
+	 * If the connection is made public from Transaction and the user code calls
+	 * that method we can no longer trust the query only status of a
+	 * Transaction.
+	 * </p>
+	 */
+	public Connection getInternalConnection();
 
-  /**
-   * Return the underlying Connection for internal use.
-   * <p>
-   * If the connection is made public from Transaction and the user code calls
-   * that method we can no longer trust the query only status of a
-   * Transaction.
-   * </p>
-   */
-  public Connection getInternalConnection();
-
-  /**
-   * Return true if the manyToMany intersection should be persisted for this particular relationship direction.
-   */
+	/**
+	 * Return true if the manyToMany intersection should be persisted for this particular relationship direction.
+	 */
   public boolean isSaveAssocManyIntersection(String intersectionTable, String beanName);
 }

src/main/java/com/avaje/ebeaninternal/api/SpiUpdatePlan.java

@@ -1,9 +1,9 @@
 package com.avaje.ebeaninternal.api;
 
 import java.sql.SQLException;
+import java.util.Set;
 
 import com.avaje.ebean.annotation.ConcurrencyMode;
-import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebeaninternal.server.persist.dml.DmlHandler;
 import com.avaje.ebeaninternal.server.persist.dmlbind.Bindable;
 
@@ -21,20 +21,20 @@ import com.avaje.ebeaninternal.server.persist.dmlbind.Bindable;
  */
 public interface SpiUpdatePlan {
 
-  /**
-   * Return true if the set clause has no columns.
-   * <p>
-   * Can occur when the only columns updated have a updatable=false in their
-   * deployment.
-   * </p>
-   */
-  public boolean isEmptySetClause();
+    /**
+     * Return true if the set clause has no columns.
+     * <p>
+     * Can occur when the only columns updated have a updatable=false in their
+     * deployment.
+     * </p>
+     */
+    public boolean isEmptySetClause();
     
 	/**
 	 * Bind given the request and bean. The bean could be the oldValues bean
 	 * when binding a update or delete where clause with ALL concurrency mode.
 	 */
-	public void bindSet(DmlHandler bind, EntityBean bean) throws SQLException;
+	public void bindSet(DmlHandler bind, Object bean) throws SQLException;
 
 	/**
 	 * Return the time this plan was created.
@@ -66,10 +66,10 @@ public interface SpiUpdatePlan {
 	 */
 	public Bindable getSet();
 
-//	/**
-//	 * Return the properties that where changed and should be included in the
-//	 * update statement.
-//	 */
-//	public Set<String> getProperties();
+	/**
+	 * Return the properties that where changed and should be included in the
+	 * update statement.
+	 */
+	public Set<String> getProperties();
 
 }

src/main/java/com/avaje/ebeaninternal/server/autofetch/StatisticsNodeUsage.java

@@ -86,9 +86,9 @@ public class StatisticsNodeUsage implements Serializable {
             }
 
             if ((modified || queryTuningAddVersion) && desc != null) {
-                BeanProperty versionProp = desc.getVersionProperty();
-                if (versionProp != null) {
-                    pathProps.addToPath(path, versionProp.getName());
+                BeanProperty[] versionProps = desc.propertiesVersion();
+                if (versionProps.length > 0) {
+                    pathProps.addToPath(path, versionProps[0].getName());
                 }
             }
 		}