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

Add support for java.time types, tidy up ScalarTypes

.gitignore

@@ -6,6 +6,7 @@
 target/
 logs/
 log/
+/db
 /mydb.db
 
 

README.md

@@ -1,14 +1,12 @@
+[![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>3.3.2</version>
+      <version>4.3.1</version>
     </dependency>
     
-    

pom.xml

@@ -9,7 +9,7 @@
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>4.0.2</version>
+  <version>4.4.1</version>
   <packaging>jar</packaging>
 
   <name>avaje-ebeanorm</name>
@@ -48,6 +48,18 @@
       <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>
@@ -77,13 +89,6 @@
       <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>
@@ -94,14 +99,14 @@
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.1.2</version>
+      <version>4.1.10</version>
       <scope>test</scope>
     </dependency>
         
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.3.153</version>
+      <version>1.4.182</version>
       <scope>test</scope>
     </dependency>
     
@@ -174,23 +179,21 @@
   <!-- Enhance the meta beans -->
   <build>
     <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.2</version>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
       <plugin>
         <groupId>org.avaje.ebeanorm</groupId>
         <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.1.2</version>
+        <version>4.1.9</version>
         <executions>
-           <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>
+          <!--   Not going to enhance Model bean -->
           <execution>
             <id>test</id>
             <phase>process-test-classes</phase>
@@ -220,9 +223,37 @@
           </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>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
     </plugins>
 
   </build>
-
+ 
 </project>

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

@@ -15,7 +15,6 @@ import org.slf4j.LoggerFactory;
 
 import com.avaje.ebean.annotation.CacheStrategy;
 import com.avaje.ebean.cache.ServerCacheManager;
-import com.avaje.ebean.config.GlobalProperties;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.text.csv.CsvReader;
 import com.avaje.ebean.text.json.JsonContext;
@@ -63,34 +62,38 @@ import com.avaje.ebean.text.json.JsonContext;
  * created automatically they are configured using information in the
  * ebean.properties file.
  * </p>
+ *
+ * <pre>{@code
+ *
+ *   // fetch shipped orders (and also their customer)
+ *   List<Order> list = Ebean.find(Order.class)
+ * 	  .fetch("customer")
+ * 	  .where()
+ * 	  .eq("status.code", Order.Status.SHIPPED)
+ * 	  .findList();
+ *
+ *   // read/use the order list ...
+ *   for (Order order : list) {
+ * 	   Customer customer = order.getCustomer();
+ * 	   ...
+ *   }
+ *
+ * }</pre>
  * 
- * <pre class="code">
- * // fetch shipped orders (and also their customer)
- * List&lt;Order&gt; list = Ebean.find(Order.class)
- * 	.fetch(&quot;customer&quot;)
- * 	.where() 
- * 	.eq(&quot;status.code&quot;, Order.Status.SHIPPED) 
- * 	.findList();
+ * <pre>{@code
+ *
+ *   // fetch order 10, modify and save
+ *   Order order = Ebean.find(Order.class, 10);
  * 
- * // read/use the order list ... 
- * for (Order order : list) { 
- * 	Customer customer = order.getCustomer(); 
- * 	... 
- * }
- * </pre>
+ *   OrderStatus shipped = Ebean.getReference(OrderStatus.class,"SHIPPED");
+ *   order.setStatus(shipped);
+ *   order.setShippedDate(shippedDate);
+ *   ...
  * 
- * <pre class="code">
- * // fetch order 10, modify and save 
- * Order order = Ebean.find(Order.class, 10);
- * 
- * OrderStatus shipped = Ebean.getReference(OrderStatus.class,&quot;SHIPPED&quot;); 
- * order.setStatus(shipped);
- * order.setShippedDate(shippedDate); 
- * ...
- * 
- * // implicitly creates a transaction and commits 
- * Ebean.save(order);
- * </pre>
+ *   // implicitly creates a transaction and commits
+ *   Ebean.save(order);
+ *
+ * }</pre>
  * 
  * <p>
  * When you have multiple databases and need access to a specific one the
@@ -98,20 +101,22 @@ import com.avaje.ebean.text.json.JsonContext;
  * specific database.
  * </p>
  * 
- * <pre class="code">
- * // Get access to the Human Resources EbeanServer/Database
- * EbeanServer hrDb = Ebean.getServer(&quot;hr&quot;);
+ * <pre> {@code
+ *
+ *   // Get access to the Human Resources EbeanServer/Database
+ *   EbeanServer hrDb = Ebean.getServer("hr");
  * 
  * 
- * // fetch contact 3 from the HR database 
- * Contact contact = hrDb.find(Contact.class, 3);
+ *   // fetch contact 3 from the HR database
+ *   Contact contact = hrDb.find(Contact.class, 3);
  * 
- * contact.setName(&quot;I'm going to change&quot;); 
- * ...
+ *   contact.setName("I'm going to change");
+ *   ...
  * 
- * // save the contact back to the HR database 
- * hrDb.save(contact);
- * </pre>
+ *   // save the contact back to the HR database
+ *   hrDb.save(contact);
+ *
+ * }</pre>
  */
 public final class Ebean {
   private static final Logger logger = LoggerFactory.getLogger(Ebean.class);
@@ -149,14 +154,14 @@ public final class Ebean {
 
       // skipDefaultServer is set by EbeanServerFactory
       // ... when it is creating the primaryServer
-      if (GlobalProperties.isSkipPrimaryServer()) {
+      if (PrimaryServer.isSkip()) {
         // primary server being created by EbeanServerFactory
         // ... so we should not try and create it here
-        logger.debug("GlobalProperties.isSkipPrimaryServer()");
+        logger.debug("PrimaryServer.isSkip()");
 
       } else {
         // look to see if there is a default server defined
-        String primaryName = getPrimaryServerName();
+        String primaryName = PrimaryServer.getPrimaryServerName();
         logger.debug("primaryName:" + primaryName);
         if (primaryName != null && primaryName.trim().length() > 0) {
           primaryServer = getWithCreate(primaryName.trim());
@@ -164,12 +169,6 @@ public final class Ebean {
       }
     }
 
-    private String getPrimaryServerName() {
-
-      String serverName = GlobalProperties.get("ebean.default.datasource", null);
-      return GlobalProperties.get("datasource.default", serverName);
-    }
-
     private EbeanServer getPrimaryServer() {
       if (primaryServer == null) {
         String msg = "The default EbeanServer has not been defined?";
@@ -214,14 +213,13 @@ public final class Ebean {
      * Register a server so we can get it by its name.
      */
     private void register(EbeanServer server, boolean isPrimaryServer) {
+      registerWithName(server.getName(), server, isPrimaryServer);
+    }
+    
+    private void registerWithName(String name, EbeanServer server, boolean isPrimaryServer) {
       synchronized (monitor) {
-        concMap.put(server.getName(), server);
-        EbeanServer existingServer = syncMap.put(server.getName(), server);
-        if (existingServer != null) {
-          String msg = "Existing EbeanServer [" + server.getName() + "] is being replaced?";
-          logger.warn(msg);
-        }
-
+        concMap.put(name, server);
+        syncMap.put(name, server);
         if (isPrimaryServer) {
           primaryServer = server;
         }
@@ -243,12 +241,12 @@ public final class Ebean {
    * Ebean.
    * </p>
    * 
-   * <pre class="code">
-   * // use the &quot;hr&quot; database
-   * EbeanServer hrDatabase = Ebean.getServer(&quot;hr&quot;);
+   * <pre>{@code
+   * // use the "hr" database
+   * EbeanServer hrDatabase = Ebean.getServer("hr");
    * 
    * Person person = hrDatabase.find(Person.class, 10);
-   * </pre>
+   * }</pre>
    * 
    * @param name
    *          the name of the server, use null for the 'default server'
@@ -282,10 +280,19 @@ public final class Ebean {
    * Register the server with this Ebean singleton. Specify if the registered
    * server is the primary/default server.
    */
-  protected static void register(EbeanServer server, boolean isPrimaryServer) {
+  public static void register(EbeanServer server, boolean isPrimaryServer) {
     serverMgr.register(server, isPrimaryServer);
   }
 
+  /**
+   * Backdoor for registering a mock implementation of EbeanServer as the default  server.
+   */
+  protected static EbeanServer mock(String name, EbeanServer server, boolean isPrimaryServer) {
+    EbeanServer originalPrimaryServer = serverMgr.primaryServer;
+    serverMgr.registerWithName(name, server, isPrimaryServer);
+    return originalPrimaryServer;
+  }
+  
   /**
    * Return the next identity value for a given bean type.
    * <p>
@@ -315,22 +322,24 @@ public final class Ebean {
    * etc.
    * </p>
    * 
-   * <pre class="code">
-   * // start a transaction (stored in a ThreadLocal)
-   * Ebean.beginTransaction(); 
-   * try { 
-   * 	Order order = Ebean.find(Order.class,10); ...
+   * <pre>{@code
+   *
+   *   // start a transaction (stored in a ThreadLocal)
+   *   Ebean.beginTransaction();
+   *   try {
+   * 	   Order order = Ebean.find(Order.class,10); ...
+   *
+   * 	   Ebean.save(order);
    * 
-   * 	Ebean.save(order);
+   * 	   Ebean.commitTransaction();
    * 
-   * 	Ebean.commitTransaction();
-   * 
-   * } finally { 
-   * 	// rollback if we didn't commit 
-   * 	// i.e. an exception occurred before commitTransaction(). 
-   * 	Ebean.endTransaction(); 
-   * }
-   * </pre>
+   *   } finally {
+   * 	   // rollback if we didn't commit
+   * 	   // i.e. an exception occurred before commitTransaction().
+   * 	   Ebean.endTransaction();
+   *   }
+   *
+   * }</pre>
    * 
    * <p>
    * If you want to externalise the transaction management then you should be
@@ -364,6 +373,19 @@ public final class Ebean {
     return serverMgr.getPrimaryServer().currentTransaction();
   }
 
+  /**
+   * 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 static void register(TransactionCallback transactionCallback) throws PersistenceException {
+    serverMgr.getPrimaryServer().register(transactionCallback);
+  }
+
   /**
    * Commit the current transaction.
    */
@@ -389,17 +411,19 @@ public final class Ebean {
    * Code example:
    * </p>
    * 
-   * <pre class="code">
-   * Ebean.beginTransaction();
-   * try {
-   *   // do some fetching and or persisting
-   *   // commit at the end Ebean.commitTransaction();
+   * <pre>{@code
+   *   Ebean.beginTransaction();
+   *   try {
+   *     // do some fetching and or persisting
+   *
+   *     // commit at the end
+   *     Ebean.commitTransaction();
    * 
-   * } finally {
-   *   // if commit didn't occur then rollback the transaction
-   *   Ebean.endTransaction();
-   * }
-   * </pre>
+   *   } finally {
+   *     // if commit didn't occur then rollback the transaction
+   *     Ebean.endTransaction();
+   *   }
+   * }</pre>
    */
   public static void endTransaction() {
     serverMgr.getPrimaryServer().endTransaction();
@@ -432,15 +456,15 @@ public final class Ebean {
    * saving an order will also save all its details.
    * </p>
    * 
-   * <pre class="code">
-   * public class Order { ...
+   * <pre>{@code
+   *   public class Order { ...
    * 	
-   * 	&#064;OneToMany(cascade=CascadeType.ALL, mappedBy=&quot;order&quot;)
-   * 	&#064;JoinColumn(name=&quot;order_id&quot;) 
-   * 	List&lt;OrderDetail&gt; details; 
-   * 	... 
-   * }
-   * </pre>
+   * 	   @OneToMany(cascade=CascadeType.ALL, mappedBy="order")
+   * 	   @JoinColumn(name="order_id")
+   * 	   List<OrderDetail> details;
+   * 	   ...
+   *   }
+   * }</pre>
    * 
    * <p>
    * When a save cascades via a OneToMany or ManyToMany Ebean will automatically
@@ -467,7 +491,31 @@ public final class Ebean {
   public static void insert(Collection<?> beans) {
     serverMgr.getPrimaryServer().insert(beans);
   }
-  
+
+  /**
+   * Marks the entity bean as dirty.
+   * <p>
+   * This is used so that when a bean that is otherwise unmodified is updated with the version
+   * property 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>{@code
+   * 
+   *   Customer customer = Ebean.find(Customer, id);
+   * 
+   *   // mark the bean as dirty so that a save() or update() will
+   *   // increment the version property
+   *   Ebean.markAsDirty(customer);
+   *   Ebean.save(customer);
+   * 
+   * }</pre>
+   */
+  public static void markAsDirty(Object bean) throws OptimisticLockException {
+    serverMgr.getPrimaryServer().markAsDirty(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().
@@ -491,15 +539,15 @@ public final class Ebean {
    * properties are included instead.
    * </p>
    * 
-   * <pre class="code">
+   * <pre>{@code
    * 
-   * // A 'stateless update' example
-   * Customer customer = new Customer();
-   * customer.setId(7);
-   * customer.setName(&quot;ModifiedNameNoOCC&quot;);
-   * ebeanServer.update(customer);
+   *   // A 'stateless update' example
+   *   Customer customer = new Customer();
+   *   customer.setId(7);
+   *   customer.setName("ModifiedNameNoOCC");
+   *   ebeanServer.update(customer);
    * 
-   * </pre>
+   * }</pre>
    * 
    * @see ServerConfig#setUpdatesDeleteMissingChildren(boolean)
    * @see ServerConfig#setUpdateChangesOnly(boolean)
@@ -633,12 +681,14 @@ public final class Ebean {
   /**
    * Refresh a 'many' property of a bean.
    * 
-   * <pre class="code">
-   * Order order = ...;
-   * ...
-   * // refresh the order details...
-   * Ebean.refreshMany(order, &quot;details&quot;);
-   * </pre>
+   * <pre>{@code
+   *
+   *   Order order = ...;
+   *   ...
+   *   // refresh the order details...
+   *   Ebean.refreshMany(order, "details");
+   *
+   * }</pre>
    * 
    * @param bean
    *          the entity bean containing the List Set or Map to refresh.
@@ -655,16 +705,18 @@ public final class Ebean {
    * This is sometimes described as a proxy (with lazy loading).
    * </p>
    * 
-   * <pre class="code">
-   * Product product = Ebean.getReference(Product.class, 1);
+   * <pre>{@code
+   *
+   *   Product product = Ebean.getReference(Product.class, 1);
    * 
-   * // You can get the id without causing a fetch/lazy load
-   * Integer productId = product.getId();
+   *   // 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>
+   *   // 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
@@ -694,23 +746,23 @@ public final class Ebean {
    * not invoke a DB query.
    * </p>
    * 
-   * <pre class="code">
+   * <pre>{@code
    * 
-   * // find orders and their customers
-   * List&lt;Order&gt; list = Ebean.find(Order.class)
-   *     .fetch(&quot;customer&quot;)
-   *     .orderBy(&quot;id&quot;)
+   *   // find orders and their customers
+   *   List<Order> list = Ebean.find(Order.class)
+   *     .fetch("customer")
+   *     .orderBy("id")
    *     .findList();
    * 
-   * // sort by customer name ascending, then by order shipDate
-   * // ... then by the order status descending
-   * Ebean.sort(list, &quot;customer.name, shipDate, status desc&quot;);
+   *   // sort by customer name ascending, then by order shipDate
+   *   // ... then by the order status descending
+   *   Ebean.sort(list, "customer.name, shipDate, status desc");
    * 
-   * // sort by customer name descending (with nulls low)
-   * // ... then by the order id
-   * Ebean.sort(list, &quot;customer.name desc nullsLow, id&quot;);
+   *   // sort by customer name descending (with nulls low)
+   *   // ... then by the order id
+   *   Ebean.sort(list, "customer.name desc nullsLow, id");
    * 
-   * </pre>
+   * }</pre>
    * 
    * @param list
    *          the list of entity beans
@@ -724,41 +776,43 @@ public final class Ebean {
   /**
    * Find a bean using its unique id. This will not use caching.
    * 
-   * <pre class="code">
-   * // Fetch order 1
-   * Order order = Ebean.find(Order.class, 1);
-   * </pre>
+   * <pre>{@code
+   *   // Fetch order 1
+   *   Order order = Ebean.find(Order.class, 1);
+   * }</pre>
    * 
    * <p>
    * If you want more control over the query then you can use createQuery() and
    * Query.findUnique();
    * </p>
    * 
-   * <pre class="code">
-   * // ... additionally fetching customer, customer shipping address,
-   * // order details, and the product associated with each order detail.
-   * // note: only product id and name is fetch (its a &quot;partial object&quot;).
-   * // note: all other objects use &quot;*&quot; and have all their properties fetched.
+   * <pre>{@code
+   *   // ... additionally fetching customer, customer shipping address,
+   *   // order details, and the product associated with each order detail.
+   *   // note: only product id and name is fetch (its a "partial object").
+   *   // note: all other objects use "*" and have all their properties fetched.
    * 
-   * Query&lt;Order&gt; query = Ebean.createQuery(Order.class);
-   * query.setId(1);
-   * query.fetch(&quot;customer&quot;);
-   * query.fetch(&quot;customer.shippingAddress&quot;);
-   * query.fetch(&quot;details&quot;);
+   *   Query<Order> query = Ebean.find(Order.class)
+   *     .setId(1)
+   *     .fetch("customer")
+   *     .fetch("customer.shippingAddress")
+   *     .fetch("details")
+   *     .query();
    * 
-   * // fetch associated products but only fetch their product id and name
-   * query.fetch(&quot;details.product&quot;, &quot;name&quot;);
+   *   // fetch associated products but only fetch their product id and name
+   *   query.fetch("details.product", "name");
    * 
-   * // traverse the object graph...
+   *   // traverse the object graph...
    * 
-   * Order order = query.findUnique();
-   * Customer customer = order.getCustomer();
-   * Address shippingAddress = customer.getShippingAddress();
-   * List&lt;OrderDetail&gt; details = order.getDetails();
-   * OrderDetail detail0 = details.get(0);
-   * Product product = detail0.getProduct();
-   * String productName = product.getName();
-   * </pre>
+   *   Order order = query.findUnique();
+   *   Customer customer = order.getCustomer();
+   *   Address shippingAddress = customer.getShippingAddress();
+   *   List<OrderDetail> details = order.getDetails();
+   *   OrderDetail detail0 = details.get(0);
+   *   Product product = detail0.getProduct();
+   *   String productName = product.getName();
+   *
+   * }</pre>
    * 
    * @param beanType
    *          the type of entity bean to fetch
@@ -770,7 +824,7 @@ public final class Ebean {
   }
 
   /**
-   * Create a <a href="SqlQuery.html">SqlQuery</a> for executing native sql
+   * Create a SqlQuery for executing native sql
    * query statements.
    * <p>
    * Note that you can use raw SQL with entity beans, refer to the SqlSelect
@@ -828,15 +882,17 @@ public final class Ebean {
    * deployment orm xml file.
    * </p>
    * 
-   * <pre class="code">
-   * // Use a namedQuery
-   * UpdateSql update = Ebean.createNamedSqlUpdate(&quot;update.topic.count&quot;);
+   * <pre>{@code
+   *
+   *   // Use a namedQuery
+   *   UpdateSql update = Ebean.createNamedSqlUpdate("update.topic.count");
    * 
-   * update.setParameter(&quot;count&quot;, 1);
-   * update.setParameter(&quot;topicId&quot;, 50);
+   *   update.setParameter("count", 1);
+   *   update.setParameter("topicId", 50);
    * 
-   * int modifiedCount = update.execute();
-   * </pre>
+   *   int modifiedCount = update.execute();
+   *
+   * }</pre>
    */
   public static SqlUpdate createNamedSqlUpdate(String namedQuery) {
     return serverMgr.getPrimaryServer().createNamedSqlUpdate(namedQuery);
@@ -851,12 +907,14 @@ public final class Ebean {
    * need to bind required parameters and then execute the query.
    * </p>
    * 
-   * <pre class="code">
-   * // example
-   * Query&lt;Order&gt; query = Ebean.createNamedQuery(Order.class, &quot;new.for.customer&quot;);
-   * query.setParameter(&quot;customerId&quot;, 23);
-   * List&lt;Order&gt; newOrders = query.findList();
-   * </pre>
+   * <pre>{@code
+   *
+   *   // example
+   *   Query<Order> query = Ebean.createNamedQuery(Order.class, "new.for.customer");
+   *   query.setParameter("customerId", 23);
+   *   List<Order> newOrders = query.findList();
+   *
+   * }</pre>
    * 
    * @param beanType
    *          the class of entity to be fetched
@@ -879,14 +937,15 @@ public final class Ebean {
    * moved to {@link #createNamedQuery(Class, String)}.
    * </p>
    * 
-   * <pre class="code">
+   * <pre>{@code
    * 
-   * String q = &quot;find order fetch details where status = :st&quot;;
+   *   String q = "find order fetch details where status = :st";
    * 
-   * List&lt;Order&gt; newOrders = Ebean.createQuery(Order.class, q)
-   *     .setParameter(&quot;st&quot;, Order.Status.NEW)
+   *   List<Order> newOrders = Ebean.>findOrder.class, q)
+   *     .setParameter("st", Order.Status.NEW)
    *     .findList();
-   * </pre>
+   *
+   * }</pre>
    * 
    * @param query
    *          the object query
@@ -911,40 +970,43 @@ public final class Ebean {
    * Example named updates:
    * </p>
    * 
-   * <pre class="code">
-   * package app.data;
+   * <pre>{@code
+   *   package app.data;
    * 
-   * import ...
+   *   import ...
    * 
-   * &#064;NamedUpdates(value = { 
-   * 	&#064;NamedUpdate( name = &quot;setTitle&quot;, 
-   * 		isSql = false, 
-   * 		notifyCache = false, 
-   * 		update = &quot;update topic set title = :title, postCount = :postCount where id = :id&quot;), 
-   * 	&#064;NamedUpdate( name = &quot;setPostCount&quot;,
-   * 		notifyCache = false,
-   * 		update = &quot;update f_topic set post_count = :postCount where id = :id&quot;), 
-   * 	&#064;NamedUpdate( name = &quot;incrementPostCount&quot;, 
-   * 		notifyCache = false, 
-   * 		isSql = false,
-   * 		update = &quot;update Topic set postCount = postCount + 1 where id = :id&quot;) }) 
-   * &#064;Entity 
-   * &#064;Table(name = &quot;f_topic&quot;) 
-   * public class Topic { ...
-   * </pre>
+   *   @NamedUpdates(value = {
+   *    @NamedUpdate( name = "setTitle",
+   * 	    isSql = false,
+   * 		  notifyCache = false,
+   * 		  update = "update topic set title = :title, postCount = :postCount where id = :id"),
+   * 	  @NamedUpdate( name = "setPostCount",
+   * 		  notifyCache = false,
+   * 		  update = "update f_topic set post_count = :postCount where id = :id"),
+   * 	  @NamedUpdate( name = "incrementPostCount",
+   * 		  notifyCache = false,
+   * 		  isSql = false,
+   * 		  update = "update Topic set postCount = postCount + 1 where id = :id") })
+   *   @Entity
+   *   @Table(name = "f_topic")
+   *   public class Topic { ...
+   *
+   * }</pre>
    * 
    * <p>
    * Example using a named update:
    * </p>
    * 
-   * <pre class="code">
-   * Update&lt;Topic&gt; update = Ebean.createNamedUpdate(Topic.class, &quot;setPostCount&quot;);
-   * update.setParameter(&quot;postCount&quot;, 10);
-   * update.setParameter(&quot;id&quot;, 3);
+   * <pre>{@code
+   *
+   *   Update<Topic> update = Ebean.createNamedUpdate(Topic.class, "setPostCount");
+   *   update.setParameter("postCount", 10);
+   *   update.setParameter("id", 3);
    * 
-   * int rows = update.execute();
-   * System.out.println(&quot;rows updated: &quot; + rows);
-   * </pre>
+   *   int rows = update.execute();
+   *   System.out.println("rows updated: " + rows);
+   *
+   * }</pre>
    */
   public static <T> Update<T> createNamedUpdate(Class<T> beanType, String namedUpdate) {
 
@@ -963,21 +1025,22 @@ public final class Ebean {
    * An example:
    * </p>
    * 
-   * <pre class="code">
+   * <pre>{@code
    * 
-   * // The bean name and properties - &quot;topic&quot;,&quot;postCount&quot; and &quot;id&quot;
+   *   // The bean name and properties - "topic","postCount" and "id"
    * 
-   * // will be converted into their associated table and column names
-   * String updStatement = &quot;update topic set postCount = :pc where id = :id&quot;;
+   *   // will be converted into their associated table and column names
+   *   String updStatement = "update topic set postCount = :pc where id = :id";
    * 
-   * Update&lt;Topic&gt; update = Ebean.createUpdate(Topic.class, updStatement);
+   *   Update<Topic> update = Ebean.createUpdate(Topic.class, updStatement);
    * 
-   * update.set(&quot;pc&quot;, 9);
-   * update.set(&quot;id&quot;, 3);
+   *   update.set("pc", 9);
+   *   update.set("id", 3);
    * 
-   * int rows = update.execute();
-   * System.out.println(&quot;rows updated:&quot; + rows);
-   * </pre>
+   *   int rows = update.execute();
+   *   System.out.println("rows updated:" + rows);
+   *
+   * }</pre>
    */
   public static <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) {
 
@@ -1008,38 +1071,37 @@ public final class Ebean {
    * which is was created.
    * </p>
    * 
-   * <pre class="code">
-   * // Find order 2 additionally fetching the customer, details and details.product
-   * // name.
+   * <pre>{@code
+   *   // Find order 2 additionally fetching the customer, details and details.product
+   *   // name.
    * 
-   * Query&lt;Order&gt; query = Ebean.createQuery(Order.class);
-   * query.fetch(&quot;customer&quot;);
-   * query.fetch(&quot;details&quot;);
-   * query.fetch(&quot;detail.product&quot;, &quot;name&quot;);
-   * query.setId(2);
+   *   Order order = Ebean.find(Order.class)
+   *     .fetch("customer")
+   *     .fetch("details")
+   *     .fetch("detail.product", "name")
+   *     .setId(2)
+   *     .findUnique();
    * 
-   * Order order = query.findUnique();
+   *   // Find order 2 additionally fetching the customer, details and details.product
+   *   // name.
+   *   // Note: same query as above but using the query language
+   *   // Note: using a named query would be preferred practice
    * 
-   * // Find order 2 additionally fetching the customer, details and details.product
-   * // name.
-   * // Note: same query as above but using the query language
-   * // Note: using a named query would be preferred practice
+   *   String oql = "find order fetch customer fetch details fetch details.product (name) where id = :orderId ";
    * 
-   * String oql = &quot;find order fetch customer fetch details fetch details.product (name) where id = :orderId &quot;;
+   *   Query<Order> query = Ebean.find(Order.class);
+   *   query.setQuery(oql);
+   *   query.setParameter("orderId", 2);
    * 
-   * Query&lt;Order&gt; query = Ebean.createQuery(Order.class);
-   * query.setQuery(oql);
-   * query.setParameter(&quot;orderId&quot;, 2);
+   *   Order order = query.findUnique();
    * 
-   * Order order = query.findUnique();
+   *   // Using a named query
+   *   Query<Order> query = Ebean.find(Order.class, "with.details");
+   *   query.setParameter("orderId", 2);
    * 
-   * // Using a named query
-   * Query&lt;Order&gt; query = Ebean.createQuery(Order.class, &quot;with.details&quot;);
-   * query.setParameter(&quot;orderId&quot;, 2);
+   *   Order order = query.findUnique();
    * 
-   * Order order = query.findUnique();
-   * 
-   * </pre>
+   * }</pre>
    * 
    * @param beanType
    *          the class of entity to be fetched
@@ -1099,19 +1161,21 @@ public final class Ebean {
    * Example:
    * </p>
    * 
-   * <pre class="code">
-   * // example that uses 'named' parameters 
-   * String s = &quot;UPDATE f_topic set post_count = :count where id = :id&quot;
+   * <pre>{@code
+   *
+   *   // example that uses 'named' parameters
+   *   String s = "UPDATE f_topic set post_count = :count where id = :id"
    * 
-   * SqlUpdate update = Ebean.createSqlUpdate(s);
+   *   SqlUpdate update = Ebean.createSqlUpdate(s);
    * 
-   * update.setParameter(&quot;id&quot;, 1);
-   * update.setParameter(&quot;count&quot;, 50);
+   *   update.setParameter("id", 1);
+   *   update.setParameter("count", 50);
    * 
-   * int modifiedCount = Ebean.execute(update);
+   *   int modifiedCount = Ebean.execute(update);
    * 
-   * String msg = &quot;There where &quot; + modifiedCount + &quot;rows updated&quot;;
-   * </pre>
+   *   String msg = "There where " + modifiedCount + "rows updated";
+   *
+   * }</pre>
    * 
    * @param sqlUpdate
    *          the update sql potentially with bind values
@@ -1132,19 +1196,21 @@ public final class Ebean {
    * Example:
    * </p>
    * 
-   * <pre class="code">
-   * String sql = &quot;{call sp_order_modify(?,?,?)}&quot;;
+   * <pre>{@code
+   *
+   *   String sql = "{call sp_order_modify(?,?,?)}";
    * 
-   * CallableSql cs = Ebean.createCallableSql(sql);
-   * cs.setParameter(1, 27);
-   * cs.setParameter(2, &quot;SHIPPED&quot;);
-   * cs.registerOut(3, Types.INTEGER);
+   *   CallableSql cs = Ebean.createCallableSql(sql);
+   *   cs.setParameter(1, 27);
+   *   cs.setParameter(2, "SHIPPED");
+   *   cs.registerOut(3, Types.INTEGER);
    * 
-   * Ebean.execute(cs);
+   *   Ebean.execute(cs);
    * 
-   * // read the out parameter
-   * Integer returnValue = (Integer) cs.getObject(3);
-   * </pre>
+   *   // read the out parameter
+   *   Integer returnValue = (Integer) cs.getObject(3);
+   *
+   * }</pre>
    * 
    * @see CallableSql
    * @see Ebean#execute(SqlUpdate)
@@ -1160,18 +1226,19 @@ public final class Ebean {
    * semantics.
    * </p>
    * 
-   * <pre class="code">
-   * // set specific transactional scope settings 
-   * TxScope scope = TxScope.requiresNew().setIsolation(TxIsolation.SERIALIZABLE);
-   * 
-   * Ebean.execute(scope, new TxRunnable() { 
-   * 	public void run() { 
-   * 		User u1 = Ebean.find(User.class, 1); 
-   * 		...
-   * 
-   * 	} 
-   * });
-   * </pre>
+   * <pre>{@code
+   *
+   *   // set specific transactional scope settings
+   *   TxScope scope = TxScope.requiresNew().setIsolation(TxIsolation.SERIALIZABLE);
+   *
+   *   Ebean.execute(scope, new TxRunnable() {
+   * 	   public void run() {
+   * 		   User u1 = Ebean.find(User.class, 1);
+   * 		   ...
+   * 	   }
+   *   });
+   *
+   * }</pre>
    */
   public static void execute(TxScope scope, TxRunnable r) {
     serverMgr.getPrimaryServer().execute(scope, r);
@@ -1184,20 +1251,22 @@ public final class Ebean {
    * exception (checked or runtime).
    * </p>
    * 
-   * <pre class="code">
-   * Ebean.execute(new TxRunnable() {
-   *   public void run() {
-   *     User u1 = Ebean.find(User.class, 1);
-   *     User u2 = Ebean.find(User.class, 2);
+   * <pre>{@code
+   *
+   *   Ebean.execute(new TxRunnable() {
+   *     public void run() {
+   *       User u1 = Ebean.find(User.class, 1);
+   *       User u2 = Ebean.find(User.class, 2);
    * 
-   *     u1.setName(&quot;u1 mod&quot;);
-   *     u2.setName(&quot;u2 mod&quot;);
+   *       u1.setName("u1 mod");
+   *       u2.setName("u2 mod");
    * 
-   *     Ebean.save(u1);
-   *     Ebean.save(u2);
-   *   }
-   * });
-   * </pre>
+   *       Ebean.save(u1);
+   *       Ebean.save(u2);
+   *     }
+   *   });
+   *
+   * }</pre>
    */
   public static void execute(TxRunnable r) {
     serverMgr.getPrimaryServer().execute(r);
@@ -1210,18 +1279,20 @@ public final class Ebean {
    * semantics.
    * </p>
    * 
-   * <pre class="code">
-   * // set specific transactional scope settings 
-   * TxScope scope = TxScope.requiresNew().setIsolation(TxIsolation.SERIALIZABLE);
-   * 
-   * Ebean.execute(scope, new TxCallable&lt;String&gt;() {
-   * 	public String call() { 
-   * 		User u1 = Ebean.find(User.class, 1); 
-   * 		...
-   * 		return u1.getEmail(); 
-   * 	} 
-   * });
-   * </pre>
+   * <pre>{@code
+   *
+   *   // set specific transactional scope settings
+   *   TxScope scope = TxScope.requiresNew().setIsolation(TxIsolation.SERIALIZABLE);
+   *
+   *   Ebean.execute(scope, new TxCallable<String>() {
+   * 	   public String call() {
+   * 		   User u1 = Ebean.find(User.class, 1);
+   * 		   ...
+   * 		   return u1.getEmail();
+   * 	   }
+   *   });
+   *
+   * }</pre>
    * 
    */
   public static <T> T execute(TxScope scope, TxCallable<T> c) {
@@ -1239,22 +1310,24 @@ public final class Ebean {
    * (and you specify the return type via generics).
    * </p>
    * 
-   * <pre class="code">
-   * Ebean.execute(new TxCallable&lt;String&gt;() {
-   *   public String call() {
-   *     User u1 = Ebean.find(User.class, 1);
-   *     User u2 = Ebean.find(User.class, 2);
+   * <pre>{@code
+   *
+   *   Ebean.execute(new TxCallable<String>() {
+   *     public String call() {
+   *       User u1 = Ebean.find(User.class, 1);
+   *       User u2 = Ebean.find(User.class, 2);
    * 
-   *     u1.setName(&quot;u1 mod&quot;);
-   *     u2.setName(&quot;u2 mod&quot;);
+   *       u1.setName("u1 mod");
+   *       u2.setName("u2 mod");
    * 
-   *     Ebean.save(u1);
-   *     Ebean.save(u2);
+   *       Ebean.save(u1);
+   *       Ebean.save(u2);
    * 
-   *     return u1.getEmail();
-   *   }
-   * });
-   * </pre>
+   *       return u1.getEmail();
+   *     }
+   *   });
+   *
+   * }</pre>
    */
   public static <T> T execute(TxCallable<T> c) {
     return serverMgr.getPrimaryServer().execute(c);
@@ -1275,7 +1348,7 @@ public final class Ebean {
    * </p>
    * <p>
    * If there is a transaction then this information is placed into the current
-   * transactions event information. When the transaction is commited this
+   * transactions event information. When the transaction is committed this
    * information is registered (with the transaction manager). If this
    * transaction is rolled back then none of the transaction event information
    * registers including the information you put in via this method.
@@ -1351,10 +1424,18 @@ public final class Ebean {
   }
 
   /**
-   * Create a JsonContext that will use the default configuration options.
+   * Return the JsonContext for reading/writing JSON.
+   */
+  public static JsonContext json() {
+    return serverMgr.getPrimaryServer().json();
+  }
+  
+  /**
+   * Return the JsonContext for reading/writing JSON.
+   * @deprecated Please use #json instead.
    */
   public static JsonContext createJsonContext() {
-    return serverMgr.getPrimaryServer().createJsonContext();
+    return json();
   }
 
 }

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

@@ -7,6 +7,7 @@ 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;
@@ -48,18 +49,18 @@ import com.avaje.ebean.text.json.JsonContext;
  * Example: Get a EbeanServer
  * </p>
  * 
- * <pre class="code">
+ * <pre>{@code
  * // Get access to the Human Resources EbeanServer/Database
- * EbeanServer hrServer = Ebean.getServer(&quot;HR&quot;);
+ * EbeanServer hrServer = Ebean.getServer("HR");
  * 
  * 
  * // fetch contact 3 from the HR database Contact contact =
  * hrServer.find(Contact.class, new Integer(3));
  * 
- * contact.setStatus(&quot;INACTIVE&quot;); ...
+ * contact.setStatus("INACTIVE"); ...
  * 
  * // save the contact back to the HR database hrServer.save(contact);
- * </pre>
+ * }</pre>
  * 
  * <p>
  * <b>EbeanServer has more API than Ebean</b><br/>
@@ -127,7 +128,6 @@ public interface EbeanServer {
    */
   public MetaInfoManager getMetaInfoManager();
 
-
   /**
    * Return the BeanState for a given entity bean.
    * <p>
@@ -191,15 +191,15 @@ public interface EbeanServer {
    * moved to {@link #createNamedQuery(Class, String)}.
    * </p>
    * 
-   * <pre class="code">
+   * <pre>{@code
    *  EbeanServer ebeanServer = ... ;
    *  String q = "find order fetch details where status = :st";
    *  
-   *  List&lt;Order&gt; newOrders 
+   *  List<Order> newOrders
    *        = ebeanServer.createQuery(Order.class, q)
    *             .setParameter("st", Order.Status.NEW)
    *             .findList();
-   * </pre>
+   * }</pre>
    * 
    * @param query
    *          the object query
@@ -207,16 +207,14 @@ 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);
 
@@ -272,8 +270,7 @@ 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>
@@ -283,8 +280,7 @@ 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)
    */
@@ -296,8 +292,7 @@ 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.
@@ -307,6 +302,17 @@ 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>
@@ -338,8 +344,7 @@ 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();
 
@@ -367,15 +372,19 @@ public interface EbeanServer {
    * <p>
    * Code example:
    * 
-   * <pre class="code">
-   * Ebean.startTransaction(); try { // do some fetching
-   * and or persisting
+   * <pre>{@code
+   *   ebeanServer.startTransaction();
+   *   try {
+   *     // do some fetching and or persisting ...
    * 
-   * // commit at the end Ebean.commitTransaction();
+   *     // commit at the end
+   *     ebeanServer.commitTransaction();
    * 
-   * } finally { // if commit didn't occur then rollback the transaction
-   * Ebean.endTransaction(); }
-   * </pre>
+   *   } finally {
+   *     // if commit didn't occur then rollback the transaction
+   *     ebeanServer.endTransaction();
+   *   }
+   * }</pre>
    * 
    * </p>
    * 
@@ -417,7 +426,7 @@ public interface EbeanServer {
    * <p>
    * This will not perform a query against the database.
    * </p>
-   * <pre class="code">
+   * <pre>{@code
    * Product product = Ebean.getReference(Product.class, 1);
    * 
    * // You can get the id without causing a fetch/lazy load
@@ -426,14 +435,14 @@ public interface EbeanServer {
    * // 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>
+   * }</pre>
    * 
    * @param beanType
    *          the type of entity bean
    * @param id
    *          the id value
    */
-  public <T> T getReference(Class<T> beanType, Object uid);
+  public <T> T getReference(Class<T> beanType, Object id);
 
   /**
    * Return the number of 'top level' or 'root' entities this query should
@@ -457,6 +466,30 @@ public interface EbeanServer {
    * 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);
 
@@ -489,7 +522,7 @@ public interface EbeanServer {
    * 
    * @param query
    *          the query to execute the row count on
-   * @param t
+   * @param transaction
    *          the transaction (can be null).
    * @return a Future object for the row count query
    */
@@ -505,26 +538,27 @@ public interface EbeanServer {
    * 
    * @param query
    *          the query to execute the fetch Id's on
-   * @param t
+   * @param transaction
    *          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);
 
   /**
-   * Execute find list query in a background thread.
+   * Execute find list query in a background thread returning a FutureList object.
    * <p>
    * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a
-   * timeout).
-   * </p>
-   * 
+   * execution status (isDone etc) and get the value (with or without a timeout).
+   * <p>
+   * This query will execute in it's own PersistenceContext and using its own transaction.
+   * What that means is that it will not share any bean instances with other queries.
+   *
+   *
    * @param query
    *          the query to execute in the background
-   * @param t
+   * @param transaction
    *          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);
 
@@ -535,23 +569,15 @@ public interface EbeanServer {
    * execution status (isDone etc) and get the value (with or without a
    * timeout).
    * </p>
-   * 
+   *
    * @param query
    *          the query to execute in the background
-   * @param t
+   * @param transaction
    *          the transaction (can be null).
    * @return a Future object for the list result of the query
-   * @deprecated 
    */
   public SqlFutureList findFutureList(SqlQuery query, Transaction transaction);
 
-  /**
-   * 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>
@@ -837,6 +863,28 @@ public interface EbeanServer {
    */
   public int save(Collection<?> beans, Transaction transaction) throws OptimisticLockException;
 
+  /**
+   * 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>{@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>
+   */
+  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().
@@ -860,15 +908,15 @@ public interface EbeanServer {
    * properties are included instead.
    * </p>
    * 
-   * <pre class="code">
+   * <pre>{@code
    * 
    * // A 'stateless update' example
    * Customer customer = new Customer();
    * customer.setId(7);
-   * customer.setName(&quot;ModifiedNameNoOCC&quot;);
+   * customer.setName("ModifiedNameNoOCC");
    * ebeanServer.update(customer);
    * 
-   * </pre>
+   * }</pre>
    * 
    * @see ServerConfig#setUpdatesDeleteMissingChildren(boolean)
    * @see ServerConfig#setUpdateChangesOnly(boolean)
@@ -1097,9 +1145,17 @@ public interface EbeanServer {
   public void runCacheWarming(Class<?> beanType);
 
   /**
-   * Create a JsonContext that will use the default configuration options.
+   * Return the JsonContext for reading/writing JSON.
+   * @deprecated Please use #json instead.
    */
   public JsonContext createJsonContext();
 
+  /**
+   * Return the JsonContext for reading/writing JSON.
+   * <p>
+   * This instance is safe to be used concurrently by multiple threads and this method is cheap to call.
+   * </p>
+   */
+  public JsonContext json();
 
 }

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

@@ -1,13 +1,12 @@
 package com.avaje.ebean;
 
-import javax.persistence.PersistenceException;
-
 import com.avaje.ebean.common.BootupEbeanManager;
-import com.avaje.ebean.config.GlobalProperties;
+import com.avaje.ebean.config.ContainerConfig;
 import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.util.ClassUtil;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
+import javax.persistence.PersistenceException;
+import java.lang.reflect.Constructor;
+import java.util.Properties;
 
 /**
  * Creates EbeanServer instances.
@@ -26,39 +25,46 @@ import org.slf4j.LoggerFactory;
  * 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();
+  private static BootupEbeanManager bootupEbeanManager;
+
+  /**
+   * Initialise the container with clustering configuration.
+   *
+   * Call this prior to creating any EbeanServer instances or alternatively set the
+   * ContainerConfig on the ServerConfig when creating the first EbeanServer instance.
+   */
+  public static synchronized void initialiseContainer(ContainerConfig containerConfig) {
+    getServerFactory(containerConfig);
+  }
 
   /**
    * Create using ebean.properties to configure the server.
    */
-  public static EbeanServer create(String name) {
+  public static synchronized EbeanServer create(String name) {
 
-    EbeanServer server = serverFactory.createServer(name);
-
-    return server;
+    // construct based on loading properties files
+    // and if invoked by Ebean then it handles registration
+    BootupEbeanManager serverFactory = getServerFactory(null);
+    return serverFactory.createServer(name);
   }
 
   /**
    * Create using the ServerConfig object to configure the server.
    */
-  public static EbeanServer create(ServerConfig config) {
+  public static synchronized EbeanServer create(ServerConfig config) {
 
     if (config.getName() == null) {
       throw new PersistenceException("The name is null (it is required)");
     }
 
-    EbeanServer server = serverFactory.createServer(config);
+    EbeanServer server = createInternal(config);
 
     if (config.isDefaultServer()) {
-      GlobalProperties.setSkipPrimaryServer(true);
+      PrimaryServer.setSkip(true);
     }
     if (config.isRegister()) {
       Ebean.register(server, config.isDefaultServer());
@@ -67,30 +73,45 @@ public class EbeanServerFactory {
     return server;
   }
 
-  private static BootupEbeanManager createServerFactory() {
 
-    // String d___ =
-    // com.avaje.ebean.server.core.DefaultServerFactory.class.getName();
-    String dflt = "com.avaje.ebeaninternal.server.core.DefaultServerFactory";
-    String implClassName = GlobalProperties.get("ebean.serverfactory", dflt);
+  private static EbeanServer createInternal(ServerConfig config) {
 
-    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);
+    return getServerFactory(config.getContainerConfig()).createServer(config);
+  }
 
-      } catch (InterruptedException e) {
-        String m = "Interrupting debug.start.delay of " + delaySecs;
-        logger.error(m, e);
-      }
+  /**
+   * Get the BootupEbeanManager initialising it if necessary.
+   *
+   * @param containerConfig the configuration controlling clustering communication
+   */
+  private static BootupEbeanManager getServerFactory(ContainerConfig containerConfig) {
+
+    if (bootupEbeanManager != null) {
+      return bootupEbeanManager;
     }
+
+    if (containerConfig == null) {
+      // effectively load configuration from ebean.properties
+      Properties properties = PrimaryServer.getProperties();
+      containerConfig = new ContainerConfig();
+      containerConfig.loadFromProperties(properties);
+    }
+    bootupEbeanManager = createServerFactory(containerConfig);
+    return bootupEbeanManager;
+  }
+
+  /**
+   * Create the container instance using the configuration.
+   */
+  private static BootupEbeanManager createServerFactory(ContainerConfig containerConfig) {
+
+    String dflt = "com.avaje.ebeaninternal.server.core.DefaultServerFactory";
+    String implClassName = System.getProperty("ebean.serverfactory", dflt);
+
     try {
-      // use a client side implementation?
-      return (BootupEbeanManager) ClassUtil.newInstance(implClassName);
+      Class<?> cls = Class.forName(implClassName);
+      Constructor<?> constructor = cls.getConstructor(ContainerConfig.class);
+      return (BootupEbeanManager) constructor.newInstance(containerConfig);
     } catch (Exception ex) {
       throw new RuntimeException(ex);
     }

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

@@ -1,5 +1,7 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.text.PathProperties;
+
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.List;
@@ -87,6 +89,11 @@ 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.
    * 
@@ -95,9 +102,25 @@ public interface ExpressionList<T> extends Serializable {
   public QueryIterator<T> findIterate();
 
   /**
-   * Execute the query visiting the results.
-   * 
-   * @see Query#findVisit(QueryResultVisitor)
+   * 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
    */
   public void findVisit(QueryResultVisitor<T> visitor);
 
@@ -185,25 +208,6 @@ public interface ExpressionList<T> extends Serializable {
    */
   public FutureList<T> findFutureList();
 
-  /**
-   * 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>
@@ -238,22 +242,6 @@ 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/FutureList.java

@@ -1,7 +1,11 @@
 package com.avaje.ebean;
 
+import javax.persistence.PersistenceException;
 import java.util.List;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 /**
  * FutureList represents the result of a background query execution that will
@@ -15,13 +19,13 @@ import java.util.concurrent.Future;
  * A simple example:
  * </p>
  * 
- * <pre class="code">
+ * <pre>{@code
  *  // create a query to find all orders
- * Query&lt;Order&gt; query = Ebean.find(Order.class);
+ * Query<Order> query = Ebean.find(Order.class);
  * 
  *  // execute the query in a background thread
  *  // immediately returning the futureList
- * FutureList&lt;Order&gt; futureList = query.findFutureList();
+ * FutureList<Order> futureList = query.findFutureList();
  * 
  *  // do something else ... 
  * 
@@ -35,13 +39,11 @@ import java.util.concurrent.Future;
  * 
  * if (!futureList.isCancelled()){
  * 	// wait for the query to finish and return the list
- * 	List&lt;Order&gt; list = futureList.get();
+ * 	List<Order> list = futureList.get();
  * 	...
  * }
  * 
- * </pre>
- * 
- * @author rbygrave
+ * }</pre>
  */
 public interface FutureList<T> extends Future<List<T>> {
 
@@ -50,4 +52,25 @@ public interface FutureList<T> extends Future<List<T>> {
    */
   public Query<T> getQuery();
 
+  /**
+   * Same as {@link #get()} but wraps InterruptedException and ExecutionException in the
+   * unchecked PersistenceException.
+   *
+   * @return The query list result
+   *
+   * @throws PersistenceException when a InterruptedException or ExecutionException occurs.
+   */
+  public List<T> getUnchecked();
+
+  /**
+   * Same as {@link #get(long, java.util.concurrent.TimeUnit)} but wraps InterruptedException
+   * and ExecutionException in the unchecked PersistenceException.
+   *
+   * @return The query list result
+   *
+   * @throws TimeoutException if the wait timed out
+   * @throws PersistenceException if a InterruptedException or ExecutionException occurs.
+   */
+  public List<T> getUnchecked(long timeout, TimeUnit unit) throws TimeoutException;
+
 }

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

@@ -0,0 +1,636 @@
+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);
+    }
+
+    /**
+     * Delete a bean by Id.
+     */
+    public void deleteById(I id) {
+      db().delete(type, id);
+    }
+
+    /**
+     * Retrieves all entities of the given type.
+     * 
+     * <p>
+     * This is the same as (synonym for) {@link #findList()}
+     */
+    public List<T> all() {
+      return findList();
+    }
+
+    /**
+     * Retrieves an entity by ID.
+     * 
+     * <p>
+     * Equivalent to {@link EbeanServer#find(Class, Object)}
+     */
+    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/PagingList.java

@@ -1,127 +0,0 @@
-package com.avaje.ebean;
-
-import java.util.List;
-import java.util.concurrent.Future;
-
-/**
- * Used to page through a query result rather than fetching all the results in a
- * single query.
- * <p>
- * Has the ability to use background threads to 'fetch ahead' the next page and
- * get the total row count.
- * </p>
- * <p>
- * If you are building a stateless web application and not keeping the
- * PagingList over multiple requests then there is not much to be gained in
- * using PagingList. Instead you can just use {@link Query#setFirstRow(int)} and
- * {@link Query#setMaxRows(int)}.
- * </p>
- * 
- * <p>
- * If you are using PagingList is a stateful web application where the
- * PagingList is held over multiple requests then PagingList provides the extra
- * benefits of
- * <ul>
- * <li>Fetch ahead - automatically fetching the next page via background query
- * execution</li>
- * <li>Automatic propagation of the persistence context</li>
- * </ul>
- * </p>
- * <p>
- * So with PagingList when you use Page 2 it can automatically fetch Page 3 data
- * in the background (using a findFutureList() query). It also automatically
- * propagates the persistence context so that all the queries executed by the
- * PagingList all use the same persistence context.
- * </p>
- * 
- * <pre>
- * PagingList&lt;TOne&gt; pagingList =
- *     Ebean.find(TOne.class)
- *         .where().gt(&quot;name&quot;, &quot;2&quot;)
- *         .findPagingList(10);
- * 
- * // get the row count in the background...
- * // ... otherwise it is fetched on demand
- * // ... when getRowCount() or getPageCount()
- * // ... is called
- * pagingList.getFutureRowCount();
- * 
- * // get the first page
- * Page&lt;TOne&gt; page = pagingList.getPage(0);
- * 
- * // get the beans from the page as a list
- * List&lt;TOne&gt; list = page.getList();
- * </pre>
- * 
- * @author rbygrave
- * 
- * @param <T>
- *          the entity bean type
- */
-public interface PagingList<T> {
-
-  /**
-   * Refresh will clear all the pages and row count forcing them to be
-   * re-fetched when next required.
-   */
-  public void refresh();
-
-  // public void fetchAll();
-  // public String? getOrderBy();
-  // public void setOrderBy(String?);
-
-  /**
-   * By default fetchAhead is true so use this to turn off fetchAhead.
-   * <p>
-   * Set this to false if you don't want to fetch ahead using background
-   * fetching.
-   * <p>
-   * If set to true (or left as to default) then the next page is fetched in the
-   * background as soon as the list is accessed.
-   * </p>
-   */
-  public PagingList<T> setFetchAhead(boolean fetchAhead);
-
-  /**
-   * Return the Future for getting the total row count.
-   */
-  public Future<Integer> getFutureRowCount();
-
-  /**
-   * Return the data for all the pages in the form of a single List.
-   * <p>
-   * Iterating through this list will automatically fire the paging queries as
-   * required.
-   * </p>
-   */
-  public List<T> getAsList();
-
-  /**
-   * Return the page size. This is the number of rows per page.
-   */
-  public int getPageSize();
-
-  /**
-   * Return the total row count.
-   * <p>
-   * This gets the result from getFutureRowCount and will wait until that query
-   * has completed.
-   * </p>
-   */
-  public int getTotalRowCount();
-
-  /**
-   * Return the total page count.
-   * <p>
-   * This is based on the total row count. This will wait until the row count
-   * has returned if it has not already.
-   * </p>
-   */
-  public int getTotalPageCount();
-
-  /**
-   * Return the page for a given page position (starting at 0).
-   */
-  public Page<T> getPage(int i);
-
-}

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

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

@@ -0,0 +1,55 @@
+package com.avaje.ebean;
+
+import com.avaje.ebean.config.PropertyMap;
+
+import java.util.Properties;
+
+/**
+ * Provides singleton state for the default server.
+ * <p/>
+ * Intended for internal use as part of bootup, construction, registration of the default server.
+ */
+class PrimaryServer {
+
+  private static Properties globalProperties;
+
+  private static String defaultServerName;
+
+  private static boolean skip;
+
+  /**
+   * Set whether to skip automatically creating the primary server.
+   */
+  static synchronized void setSkip(boolean skip) {
+    PrimaryServer.skip = skip;
+  }
+
+  /**
+   * Return true to skip automatically creating the primary server.
+   */
+  static synchronized boolean isSkip() {
+    return skip;
+  }
+
+  /**
+   * Return the default server name.
+   */
+  static synchronized String getPrimaryServerName() {
+    getProperties();
+    return defaultServerName;
+  }
+
+  /**
+   * Return the default configuration Properties.
+   */
+  static synchronized Properties getProperties() {
+    if (globalProperties == null) {
+      globalProperties = PropertyMap.defaultProperties();
+    }
+    defaultServerName = globalProperties.getProperty("datasource.default");
+    if (defaultServerName == null) {
+      defaultServerName = globalProperties.getProperty("ebean.default.datasource");
+    }
+    return globalProperties;
+  }
+}

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

@@ -1,5 +1,7 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.text.PathProperties;
+
 import java.io.Serializable;
 import java.util.List;
 import java.util.Map;
@@ -299,6 +301,21 @@ 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.
    */
@@ -323,22 +340,32 @@ 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).
    */
@@ -413,6 +440,14 @@ 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>
@@ -436,37 +471,89 @@ 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>
-   * 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.
+   * 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.
    * </p>
-   * 
+
+   *
    * <pre class="code">
-   * 
+   *
    * Query&lt;Customer&gt; query = server.find(Customer.class)
    *     .fetch(&quot;contacts&quot;, new FetchConfig().query(2))
    *     .where().gt(&quot;id&quot;, 0)
    *     .orderBy(&quot;id&quot;)
    *     .setMaxRows(2);
-   * 
-   * query.findVisit(new QueryResultVisitor&lt;Customer&gt;() {
-   * 
-   *   public boolean accept(Customer customer) {
+   *
+   * query.findEachWhile((Customer customer) -> {
+   *
    *     // do something with customer
    *     System.out.println(&quot;-- visit &quot; + customer);
-   *     return true;
-   *   }
+   *
+   *     // return true to continue processing or false to stop
+   *     return (customer.getId() < 40);
    * });
    * </pre>
-   * 
-   * @param visitor
-   *          the visitor used to process the queried beans.
+   *
+   * @param consumer
+   *          the consumer used to process the queried beans.
    */
-  public void findVisit(QueryResultVisitor<T> visitor);
+  public void findEachWhile(QueryEachWhileConsumer<T> consumer);
 
   /**
    * Execute the query returning the list of objects.
@@ -589,21 +676,14 @@ public interface Query<T> extends Serializable {
   /**
    * Execute find list query in a background thread.
    * <p>
-   * Deprecated with a view to simplifying internals.
+   * This query will execute in it's own PersistenceContext and using its own transaction.
+   * What that means is that it will not share any bean instances with other queries.
    * </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)}.
-   * 
-   * @deprecated
-   */
-  public PagingList<T> findPagingList(int pageSize);
-
   /**
    * Return a PagedList for this query.
    * <p>

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

@@ -0,0 +1,41 @@
+package com.avaje.ebean;
+
+/**
+ * Used to process a query result one bean at a time via a callback to this
+ * visitor.
+ * <p>
+ * If you wish to stop further processing return false from the accept method.
+ * </p>
+ * <p>
+ * Unlike findList() and findSet() using a QueryResultVisitor does not require
+ * all the beans in the query result to be held in memory at once. This makes
+ * QueryResultVisitor useful for processing large queries.
+ * </p>
+ *
+ * <pre 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

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

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

@@ -1,6 +1,7 @@
 package com.avaje.ebean;
 
 import java.io.Serializable;
+import java.sql.ResultSet;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -135,18 +136,33 @@ 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;
 
-  protected RawSql(Sql sql, 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;
     this.sql = sql;
     this.columnMapping = columnMapping;
   }
@@ -158,6 +174,14 @@ 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.
    */
@@ -169,6 +193,9 @@ 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();
   }
 
@@ -329,6 +356,7 @@ 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;
@@ -364,6 +392,26 @@ 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,5 +1,7 @@
 package com.avaje.ebean;
 
+import java.sql.ResultSet;
+
 import com.avaje.ebean.RawSql.ColumnMapping;
 import com.avaje.ebean.RawSql.Sql;
 
@@ -10,8 +12,6 @@ import com.avaje.ebean.RawSql.Sql;
  * named query.
  * </p>
  * 
- * @author rbygrave
- * 
  * @see RawSql
  */
 public class RawSqlBuilder {
@@ -21,10 +21,23 @@ 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
@@ -58,9 +71,17 @@ 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;
   }
 
   /**
@@ -92,7 +113,7 @@ public class RawSqlBuilder {
    * has been defined.
    */
   public RawSql create() {
-    return new RawSql(sql, columnMapping.createImmutableCopy());
+    return new RawSql(resultSet, sql, columnMapping.createImmutableCopy());
   }
 
   /**
@@ -101,4 +122,6 @@ public class RawSqlBuilder {
   protected Sql getSql() {
     return sql;
   }
+  
+
 }

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

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

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

@@ -91,6 +91,11 @@ 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,6 +35,11 @@ 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

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

@@ -0,0 +1,42 @@
+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/annotation/ColumnHstore.java

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

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

@@ -31,6 +31,13 @@ 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.
@@ -47,14 +54,6 @@ public interface BeanCollection<E> extends Serializable {
    */
   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).
@@ -108,11 +107,6 @@ 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.
    */
@@ -137,22 +131,6 @@ 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);
-
   /**
    * 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/EntityBeanIntercept.java

@@ -39,8 +39,6 @@ public final class EntityBeanIntercept implements Serializable {
   private transient PersistenceContext persistenceContext;
 
   private transient BeanLoader beanLoader;
-  
-  private int beanLoaderIndex;
 
   private String ebeanServerName;
 
@@ -200,34 +198,22 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Return the index position for batch loading via BeanLoader.
+   * Set the BeanLoader with PersistenceContext.
    */
-  public int getBeanLoaderIndex() {
-    return beanLoaderIndex;
-  }
-
-  /**
-   * Set Lazy Loading by ebeanServerName.
-   * <p>
-   * This is for reference beans created by themselves.
-   * </p>
-   */
-  public void setBeanLoaderByServerName(String ebeanServerName) {
-    this.beanLoaderIndex = 0;
-    this.beanLoader = null;
-    this.ebeanServerName = ebeanServerName;
-  }
-
-  /**
-   * Set the BeanLoader for general lazy loading.
-   */
-  public void setBeanLoader(int index, BeanLoader beanLoader, PersistenceContext ctx) {
-    this.beanLoaderIndex = index;
+  public void setBeanLoader(BeanLoader beanLoader, PersistenceContext ctx) {
     this.beanLoader = beanLoader;
     this.persistenceContext = ctx;
     this.ebeanServerName = beanLoader.getName();
   }
-  
+
+  /**
+   * Set the BeanLoader.
+   */
+  public void setBeanLoader(BeanLoader beanLoader) {
+    this.beanLoader = beanLoader;
+    this.ebeanServerName = beanLoader.getName();
+  }
+
   public boolean isFullyLoadedBean() {
     return fullyLoadedBean;
   }

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

@@ -1,7 +1,6 @@
 package com.avaje.ebean.bean;
 
 import java.io.Serializable;
-import java.util.Objects;
 
 /**
  * Identifies a unique node of an object graph.
@@ -70,7 +69,7 @@ public final class ObjectGraphNode implements Serializable {
   
   public int hashCode() {
     int hc = 31 * originQueryPoint.hashCode();
-    hc = 31 * hc + Objects.hashCode(path);
+    hc = 31 * hc + (path == null ? 0 : path.hashCode());
     return hc;
   }
   
@@ -83,7 +82,7 @@ public final class ObjectGraphNode implements Serializable {
     }
     
     ObjectGraphNode e = (ObjectGraphNode) obj;
-    return Objects.equals(e.path, path) 
+    return  ((e.path == path) || (e.path != null && e.path.equals(path)))
         && e.originQueryPoint.equals(originQueryPoint);
   }
 }

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

@@ -38,18 +38,12 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   /**
    * The owning bean (used for lazy fetch).
    */
-  protected final EntityBean ownerBean;
+  protected EntityBean ownerBean;
 
   /**
    * The name of this property in the owning bean (used for lazy fetch).
    */
-  protected final String propertyName;
-
-  /**
-   * 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 String propertyName;
 
   protected ModifyHolder<E> modifyHolder;
 
@@ -68,8 +62,6 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
    * Constructor not non-lazy loading collection.
    */
   public AbstractBeanCollection() {
-    this.ownerBean = null;
-    this.propertyName = null;
   }
 
   /**
@@ -91,10 +83,6 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     return propertyName;
   }
 
-  public int getLoaderIndex() {
-    return loaderIndex;
-  }
-
   public ExpressionList<?> getFilterMany() {
     return filterMany;
   }
@@ -151,26 +139,6 @@ 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;
-  }
-
   protected void checkReadOnly() {
     if (readOnly) {
       String msg = "This collection is in ReadOnly mode";

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

@@ -46,6 +46,14 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     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());
@@ -130,13 +138,6 @@ 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.
    */
@@ -153,7 +154,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   }
 
   public String toString() {
-    StringBuffer sb = new StringBuffer();
+    StringBuffer sb = new StringBuffer(50);
     sb.append("BeanList ");
     if (isReadOnly()) {
       sb.append("readOnly ");
@@ -163,7 +164,6 @@ 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();

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

@@ -39,7 +39,15 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
   public BeanMap(BeanCollectionLoader ebeanServer, EntityBean 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());
   }
@@ -146,15 +154,8 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
 
   }
 
-  /**
-   * Returns the underlying map.
-   */
-  public Object getActualCollection() {
-    return map;
-  }
-
   public String toString() {
-    StringBuffer sb = new StringBuffer();
+    StringBuilder sb = new StringBuilder(50);
     sb.append("BeanMap ");
     if (isReadOnly()) {
       sb.append("readOnly ");
@@ -164,7 +165,6 @@ 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();

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

@@ -40,6 +40,14 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
     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());
   }
@@ -143,7 +151,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   }
 
   public String toString() {
-    StringBuffer sb = new StringBuffer();
+    StringBuffer sb = new StringBuffer(50);
     sb.append("BeanSet ");
     if (isReadOnly()) {
       sb.append("readOnly ");
@@ -153,7 +161,6 @@ 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();

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

@@ -9,7 +9,7 @@ import org.slf4j.LoggerFactory;
 
 /**
  * Provides some base implementation for NamingConventions.
- * 
+ *
  * @author emcgreal
  */
 public abstract class AbstractNamingConvention implements NamingConvention {
@@ -41,7 +41,7 @@ public abstract class AbstractNamingConvention implements NamingConvention {
   /** Used to trim off extra prefix for M2M. */
   protected int rhsPrefixLength = 3;
 
-  protected boolean useForeignKeyPrefix = true;
+  protected boolean useForeignKeyPrefix;
 
   /**
    * Construct with a sequence format and useForeignKeyPrefix setting.
@@ -53,12 +53,12 @@ public abstract class AbstractNamingConvention implements NamingConvention {
 
   /**
    * Construct with a sequence format.
-   * 
-   * @param sequenceFormat
-   *          the sequence format
+   *
+   * @param sequenceFormat the sequence format
    */
   public AbstractNamingConvention(String sequenceFormat) {
     this.sequenceFormat = sequenceFormat;
+    this.useForeignKeyPrefix = true;
   }
 
   /**
@@ -125,10 +125,9 @@ public abstract class AbstractNamingConvention implements NamingConvention {
    * The format should include "{table}". When generating the sequence name
    * {table} is replaced with the actual table name.
    * </p>
-   * 
-   * @param sequenceFormat
-   *          string containing "{table}" which is replaced with the actual
-   *          table name to generate the sequence name.
+   *
+   * @param sequenceFormat string containing "{table}" which is replaced with the actual
+   *                       table name to generate the sequence name.
    */
   public void setSequenceFormat(String sequenceFormat) {
     this.sequenceFormat = sequenceFormat;
@@ -173,7 +172,7 @@ public abstract class AbstractNamingConvention implements NamingConvention {
    * This first checks for the @Table annotation and if not present uses the
    * naming convention to define the table name.
    * </p>
-   * 
+   *
    * @see #getTableNameFromAnnotation(Class)
    * @see #getTableNameByConvention(Class)
    */
@@ -240,8 +239,7 @@ public abstract class AbstractNamingConvention implements NamingConvention {
     if (t != null && !isEmpty(t.name())) {
       // Note: empty catalog and schema are converted to null
       // Only need to convert quoted identifiers from annotations
-      return new TableName(quoteIdentifiers(t.catalog()), quoteIdentifiers(t.schema()),
-          quoteIdentifiers(t.name()));
+      return new TableName(quoteIdentifiers(t.catalog()), quoteIdentifiers(t.schema()),  quoteIdentifiers(t.name()));
     }
 
     // No annotation
@@ -279,4 +277,16 @@ public abstract class AbstractNamingConvention implements NamingConvention {
     }
     return false;
   }
+
+  /**
+   * Load settings from properties.
+   */
+  @Override
+  public void loadFromProperties(PropertiesWrapper properties) {
+
+    useForeignKeyPrefix = properties.getBoolean("namingConvention.useForeignKeyPrefix", useForeignKeyPrefix);
+    sequenceFormat = properties.get("namingConvention.sequenceFormat", sequenceFormat);
+    schema = properties.get("namingConvention.schema", schema);
+  }
+
 }

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

@@ -155,14 +155,6 @@ public class AutofetchConfig {
     return logDirectory;
   }
 
-  /**
-   * Return the log directory substituting any expressions such as
-   * ${catalina.base} etc.
-   */
-  public String getLogDirectoryWithEval() {
-    return GlobalProperties.evaluateExpressions(logDirectory);
-  }
-
   /**
    * Set the directory to put the autofetch log in.
    */
@@ -234,22 +226,20 @@ public class AutofetchConfig {
   /**
    * Load the settings from the properties file.
    */
-  public void loadSettings(GlobalProperties.PropertySource p) {
+  public void loadSettings(PropertiesWrapper p) {
 
-    logDirectory = p.get("autofetch.logDirectory", null);
-    queryTuning = p.getBoolean("autofetch.querytuning", false);
-    queryTuningAddVersion = p.getBoolean("autofetch.queryTuningAddVersion", false);
-    garbageCollectionOnShutdown = p.getBoolean("autofetch.garbageCollectionOnShutdown", false);
+    logDirectory = p.get("autofetch.logDirectory", logDirectory);
+    queryTuning = p.getBoolean("autofetch.querytuning", queryTuning);
+    queryTuningAddVersion = p.getBoolean("autofetch.queryTuningAddVersion", queryTuningAddVersion);
+    garbageCollectionOnShutdown = p.getBoolean("autofetch.garbageCollectionOnShutdown", garbageCollectionOnShutdown);
     
-    profiling = p.getBoolean("autofetch.profiling", false);
-    mode = p.getEnum(AutofetchMode.class, "autofetch.implicitmode", AutofetchMode.DEFAULT_ONIFEMPTY);
+    profiling = p.getBoolean("autofetch.profiling", profiling);
+    mode = p.getEnum(AutofetchMode.class, "autofetch.implicitmode", mode);
 
-    profilingMin = p.getInt("autofetch.profiling.min", 1);
-    profilingBase = p.getInt("autofetch.profiling.base", 10);
+    profilingMin = p.getInt("autofetch.profiling.min", profilingMin);
+    profilingBase = p.getInt("autofetch.profiling.base", profilingBase);
 
-    String rate = p.get("autofetch.profiling.rate", "0.05");
-    profilingRate = Double.parseDouble(rate);
-
-    profileUpdateFrequency = p.getInt("autofetch.profiling.updatefrequency", 60);
+    profilingRate = p.getDouble("autofetch.profiling.rate", profilingRate);
+    profileUpdateFrequency = p.getInt("autofetch.profiling.updatefrequency", profileUpdateFrequency);
   }
 }

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

@@ -1,50 +0,0 @@
-package com.avaje.ebean.config;
-
-import com.avaje.ebean.config.GlobalProperties.PropertySource;
-
-/**
- * Helper to read server specific properties from ebean.properties.
- */
-class ConfigPropertyMap implements PropertySource {
-
-  private final String serverName;
-
-  public ConfigPropertyMap(String serverName) {
-    this.serverName = serverName;
-  }
-
-  public String getServerName() {
-    return serverName;
-  }
-
-  public String get(String key, String defaultValue) {
-    String namedKey = "ebean." + serverName + "." + key;
-    String inheritKey = "ebean." + key;
-    String value = GlobalProperties.get(namedKey, null);
-    if (value == null) {
-      value = GlobalProperties.get(inheritKey, null);
-    }
-    if (value == null) {
-      return defaultValue;
-    } else {
-      return value;
-    }
-  }
-
-  public int getInt(String key, int defaultValue) {
-
-    String value = get(key, String.valueOf(defaultValue));
-    return Integer.parseInt(value);
-  }
-
-  public boolean getBoolean(String key, boolean defaultValue) {
-
-    String value = get(key, String.valueOf(defaultValue));
-    return Boolean.parseBoolean(value);
-  }
-
-  public <T extends Enum<T>> T getEnum(Class<T> enumType, String key, T defaultValue) {
-    String level = get(key, defaultValue.name());
-    return Enum.valueOf(enumType, level.toUpperCase());
-  }
-}

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

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

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

@@ -2,6 +2,7 @@ package com.avaje.ebean.config;
 
 import java.sql.Connection;
 import java.util.Map;
+import java.util.Properties;
 
 import com.avaje.ebean.Transaction;
 import com.avaje.ebean.util.StringHelper;
@@ -32,6 +33,8 @@ public class DataSourceConfig {
 
   private int isolationLevel = Transaction.READ_COMMITTED;
 
+  private boolean autoCommit;
+  
   private String heartbeatSql;
   
   private int heartbeatFreqSecs = 30;
@@ -131,6 +134,20 @@ 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.
@@ -432,47 +449,63 @@ public class DataSourceConfig {
     this.customProperties = customProperties;
   }
 
+  /**
+   * Load the settings by reading the ebean.properties file.
+   *
+   * @param serverName name of the server
+   */
   public void loadSettings(String serverName) {
-    loadSettingsCustomPrefix("datasource." + serverName + ".", new GlobalProperties.DelegatedGlobalPropertySource(serverName));
+    loadSettings(new PropertiesWrapper("datasource", serverName, PropertyMap.defaultProperties()));
   }
 
   /**
-   * Load the settings from ebean.properties.
+   * Load the settings from the properties supplied.
+   * <p>
+   * You can use this when you have your own properties to use for configuration.
+   * </p>
+   *
+   * @param properties the properties to configure the datasource
+   * @param serverName the name of the specific datasource (optional)
    */
-  public void loadSettingsCustomPrefix(String prefix, GlobalProperties.PropertySource properties) {
+  public void loadSettings(Properties properties, String serverName) {
+    PropertiesWrapper dbProps = new PropertiesWrapper("datasource", serverName, properties);
+    loadSettings(dbProps);
+  }
 
-    this.username = properties.get(prefix + "username", null);
-    this.password = properties.get(prefix + "password", null);
+  /**
+   * Load the settings from the PropertiesWrapper.
+   */
+  public void loadSettings(PropertiesWrapper properties) {
 
-    String dbDriver = properties.get(prefix + "databaseDriver", null);
-    this.driver = properties.get(prefix + "driver", dbDriver);
+    username = properties.get("username", username);
+    password = properties.get("password", password);
+    driver = properties.get("driver", properties.get("databaseDriver", driver));
+    url = properties.get("url", properties.get("databaseUrl", url));
 
-    String dbUrl = properties.get(prefix + "databaseUrl", null);
-    this.url = properties.get(prefix + "url", dbUrl);
+    autoCommit = properties.getBoolean("autoCommit", autoCommit);
+    captureStackTrace = properties.getBoolean("captureStackTrace", captureStackTrace);
+    maxStackTraceSize = properties.getInt("maxStackTraceSize", maxStackTraceSize);
+    leakTimeMinutes = properties.getInt("leakTimeMinutes", leakTimeMinutes);
+    maxInactiveTimeSecs = properties.getInt("maxInactiveTimeSecs", maxInactiveTimeSecs);
+    trimPoolFreqSecs = properties.getInt("trimPoolFreqSecs", trimPoolFreqSecs);
+    maxAgeMinutes = properties.getInt("maxAgeMinutes", maxAgeMinutes);
 
-    this.captureStackTrace = properties.getBoolean(prefix + "captureStackTrace", false);
-    this.maxStackTraceSize = properties.getInt(prefix + "maxStackTraceSize", 5);
-    this.leakTimeMinutes = properties.getInt(prefix + "leakTimeMinutes", 30);
-    this.maxInactiveTimeSecs = properties.getInt(prefix + "maxInactiveTimeSecs", 720);
-    this.trimPoolFreqSecs = properties.getInt(prefix + "trimPoolFreqSecs", 59);
-    this.maxAgeMinutes = properties.getInt(prefix + "maxAgeMinutes", 0);
+    minConnections = properties.getInt("minConnections", minConnections);
+    maxConnections = properties.getInt("maxConnections", maxConnections);
+    pstmtCacheSize = properties.getInt("pstmtCacheSize", pstmtCacheSize);
+    cstmtCacheSize = properties.getInt("cstmtCacheSize", cstmtCacheSize);
 
-    this.minConnections = properties.getInt(prefix + "minConnections", 0);
-    this.maxConnections = properties.getInt(prefix + "maxConnections", 20);
-    this.pstmtCacheSize = properties.getInt(prefix + "pstmtCacheSize", 20);
-    this.cstmtCacheSize = properties.getInt(prefix + "cstmtCacheSize", 20);
+    waitTimeoutMillis = properties.getInt("waitTimeout", waitTimeoutMillis);
 
-    this.waitTimeoutMillis = properties.getInt(prefix + "waitTimeout", 1000);
+    heartbeatSql = properties.get("heartbeatSql", heartbeatSql);
+    heartbeatTimeoutSeconds =  properties.getInt("heartbeatTimeoutSeconds", heartbeatTimeoutSeconds);
+    poolListener = properties.get("poolListener", poolListener);
+    offline = properties.getBoolean("offline", offline);
 
-    this.heartbeatSql = properties.get(prefix + "heartbeatSql", null);
-    this.heartbeatTimeoutSeconds =  properties.getInt(prefix + "heartbeatTimeoutSeconds", 3);    
-    this.poolListener = properties.get(prefix + "poolListener", null);
-    this.offline = properties.getBoolean(prefix + "offline", false);
-
-    String isoLevel = properties.get(prefix + "isolationlevel", "READ_COMMITTED");
+    String isoLevel = properties.get("isolationlevel", getTransactionIsolationLevel(isolationLevel));
     this.isolationLevel = getTransactionIsolationLevel(isoLevel);
 
-    String customProperties = properties.get(prefix + "customProperties", null);
+    String customProperties = properties.get("customProperties", null);
     if (customProperties != null && customProperties.length() > 0) {
       Map<String, String> custProps = StringHelper.delimitedToMap(customProperties, ";", "=");
       this.customProperties = custProps;
@@ -481,7 +514,21 @@ public class DataSourceConfig {
   }
 
   /**
-   * return the isolation level for a given string description.
+   * Return the isolation level description from the associated Connection int value.
+   */
+  public String getTransactionIsolationLevel(int level) {
+    switch (level) {
+      case Connection.TRANSACTION_NONE : return "NONE";
+      case Connection.TRANSACTION_READ_COMMITTED : return "READ_COMMITTED";
+      case Connection.TRANSACTION_READ_UNCOMMITTED : return "READ_UNCOMMITTED";
+      case Connection.TRANSACTION_REPEATABLE_READ : return "REPEATABLE_READ";
+      case Connection.TRANSACTION_SERIALIZABLE : return "SERIALIZABLE";
+      default: throw new RuntimeException("Transaction Isolation level [" + level + "] is not known.");
+    }
+  }
+
+  /**
+   * Return the isolation level for a given string description.
    */
   public int getTransactionIsolationLevel(String level) {
     level = level.toUpperCase();
@@ -505,6 +552,6 @@ public class DataSourceConfig {
       return Connection.TRANSACTION_SERIALIZABLE;
     }
 
-    throw new RuntimeException("Transaction Isolaction level [" + level + "] is not known.");
+    throw new RuntimeException("Transaction Isolation level [" + level + "] is not known.");
   }
 }

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

@@ -1,211 +0,0 @@
-package com.avaje.ebean.config;
-
-import java.util.Map;
-import java.util.Map.Entry;
-
-import javax.servlet.ServletContext;
-
-import com.avaje.ebean.util.ClassUtil;
-
-/**
- * Provides access to properties loaded from the ebean.properties file.
- */
-public final class GlobalProperties {
-
-  private static volatile PropertyMap globalMap;
-
-  private static boolean skipPrimaryServer;
-
-  /**
-   * Set whether to skip automatically creating the primary server.
-   */
-  public static synchronized void setSkipPrimaryServer(boolean skip) {
-    skipPrimaryServer = skip;
-  }
-
-  /**
-   * Return true to skip automatically creating the primary server.
-   */
-  public static synchronized boolean isSkipPrimaryServer() {
-    return skipPrimaryServer;
-  }
-
-  /**
-   * Parse the string replacing any expressions like ${catalina.base}.
-   * <p>
-   * This will evaluate expressions using first environment variables, than java
-   * system variables and lastly properties in ebean.properties - in that order.
-   * </p>
-   * <p>
-   * Expressions start with "${" and end with "}".
-   * </p>
-   */
-  public static String evaluateExpressions(String val) {
-    return getPropertyMap().eval(val);
-  }
-
-  /**
-   * Parse and evaluate any expressions that have not already been evaluated.
-   */
-  public static synchronized void evaluateExpressions() {
-    getPropertyMap().evaluateProperties();
-  }
-
-  /**
-   * In a servlet container environment this will additionally look in WEB-INF
-   * for the ebean.properties file.
-   */
-  public static synchronized void setServletContext(ServletContext servletContext) {
-
-    PropertyMapLoader.setServletContext(servletContext);
-  }
-
-  /**
-   * Return the ServletContext (if setup in a servlet container environment).
-   */
-  public static synchronized ServletContext getServletContext() {
-
-    return PropertyMapLoader.getServletContext();
-  }
-
-  private static void initPropertyMap() {
-
-    String fileName = System.getenv("EBEAN_PROPS_FILE");
-    if (fileName == null) {
-      fileName = System.getProperty("ebean.props.file");
-      if (fileName == null) {
-        fileName = "ebean.properties";
-      }
-    }
-
-    globalMap = PropertyMapLoader.load(null, fileName);
-    if (globalMap == null) {
-      // ebean.properties file was not found... but that
-      // is ok because we are likely doing programmatic config
-      globalMap = new PropertyMap();
-    }
-
-    String loaderCn = globalMap.get("ebean.properties.loader");
-    if (loaderCn != null) {
-      // a Runnable that can be used to customise the initialisation
-      // of the GlobalProperties
-      try {
-        Runnable r = (Runnable) ClassUtil.newInstance(loaderCn);
-        r.run();
-      } catch (Exception e) {
-        String m = "Error creating or running properties loader " + loaderCn;
-        throw new RuntimeException(m, e);
-      }
-    }
-  }
-
-  /**
-   * Return the property map loading it if required.
-   */
-  private static synchronized PropertyMap getPropertyMap() {
-
-    if (globalMap == null) {
-      initPropertyMap();
-    }
-
-    return globalMap;
-  }
-
-  /**
-   * Return a String property with a default value.
-   */
-  public static synchronized String get(String key, String defaultValue) {
-    return getPropertyMap().get(key, defaultValue);
-  }
-
-  /**
-   * Return a int property with a default value.
-   */
-  public static synchronized int getInt(String key, int defaultValue) {
-    return getPropertyMap().getInt(key, defaultValue);
-  }
-
-  /**
-   * Return a boolean property with a default value.
-   */
-  public static synchronized boolean getBoolean(String key, boolean defaultValue) {
-    return getPropertyMap().getBoolean(key, defaultValue);
-  }
-
-  /**
-   * Set a property return the previous value. This will evaluate any
-   * expressions in the value.
-   */
-  public static synchronized String put(String key, String value) {
-    return getPropertyMap().putEval(key, value);
-  }
-
-  /**
-   * Set a Map of key value properties.
-   */
-  public static synchronized void putAll(Map<String, String> keyValueMap) {
-    for (Entry<String, String> e : keyValueMap.entrySet()) {
-      getPropertyMap().putEval(e.getKey(), e.getValue());
-    }
-  }
-
-  public static PropertySource getPropertySource(String name) {
-    return new ConfigPropertyMap(name);
-  }
-
-  public static interface PropertySource {
-
-    /**
-     * Return the name of the server. This is also the dataSource name.
-     */
-    public String getServerName();
-
-    /**
-     * Get a property. This will prepend "ebean" and the server name to lookup
-     * the value.
-     */
-    public String get(String key, String defaultValue);
-
-    public int getInt(String key, int defaultValue);
-
-    public boolean getBoolean(String key, boolean defaultValue);
-
-    public <T extends Enum<T>> T getEnum(Class<T> enumType, String key, T defaultValue);
-
-  }
-
-  public static class DelegatedGlobalPropertySource implements PropertySource {
-
-    private String serverName;
-
-    public DelegatedGlobalPropertySource(String serverName) {
-      this.serverName = serverName;
-    }
-
-    @Override
-    public String getServerName() {
-      return serverName;
-    }
-
-    @Override
-    public String get(String key, String defaultValue) {
-      return GlobalProperties.get(key, defaultValue);
-    }
-
-    @Override
-    public int getInt(String key, int defaultValue) {
-      return GlobalProperties.getInt(key, defaultValue);
-    }
-
-    @Override
-    public boolean getBoolean(String key, boolean defaultValue) {
-      return GlobalProperties.getBoolean(key, defaultValue);
-    }
-
-    @Override
-    public <T extends Enum<T>> T getEnum(Class<T> enumType, String key, T defaultValue) {
-      String level = get(key, defaultValue.name());
-      return Enum.valueOf(enumType, level.toUpperCase());
-    }
-  }
-}

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

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

@@ -112,4 +112,9 @@ public interface NamingConvention {
    */
   public boolean isUseForeignKeyPrefix();
 
+  /**
+   * Load setting from properties.
+   */
+  public void loadFromProperties(PropertiesWrapper properties);
+
 }

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

@@ -0,0 +1,148 @@
+package com.avaje.ebean.config;
+
+import java.util.Properties;
+
+public class PropertiesWrapper {
+
+  protected final Properties properties;
+
+  protected final String prefix;
+
+  protected final String serverName;
+
+  protected final PropertyMap propertyMap;
+
+  /**
+   * Construct with a prefix, serverName and properties.
+   */
+  public PropertiesWrapper(String prefix, String serverName, Properties properties) {
+    this.serverName = serverName;
+    this.prefix = prefix;
+    this.propertyMap = PropertyMapLoader.load(null, properties);
+    this.properties = propertyMap.asProperties();
+  }
+
+  /**
+   * Construct without prefix of serverName.
+   */
+  public PropertiesWrapper(Properties properties) {
+    this(null, null, properties);
+  }
+
+  /**
+   * Internal copy constructor when changing prefix.
+   */
+  protected PropertiesWrapper(String prefix, String serverName, PropertyMap propertyMap, Properties properties) {
+    this.serverName = serverName;
+    this.prefix = prefix;
+    this.propertyMap = propertyMap;
+    this.properties = properties;
+  }
+
+  /**
+   * Return a PropertiesWrapper instance with a different prefix but same underlying properties.
+   * <p/>
+   * Used when wanting to use "datasource" as the prefix rather than "ebean".
+   * <p/>
+   * The returning instance should only be used in a read only fashion.
+   */
+  public PropertiesWrapper withPrefix(String prefix) {
+    return new PropertiesWrapper(prefix, serverName, propertyMap, properties);
+  }
+
+  /**
+   * Return the serverName (optional).
+   */
+  public String getServerName() {
+    return serverName;
+  }
+
+  /**
+   * Return as Properties with lower case keys and after evaluation and additional properties loading has occurred.
+   * <p>
+   * Ebean has historically ignored the case of keys hence returning the Properties with all the keys lower cased.
+   * </p>
+   */
+  public Properties asPropertiesLowerCase() {
+    return properties;
+  }
+
+  /**
+   * Get a property with no default value.
+   */
+  public String get(String key) {
+    return get(key, null);
+  }
+
+  /**
+   * Get a property with a default value.
+   * <p>
+   * This performs a search using the prefix and server name (if supplied) to search for the property
+   * value in order based on:
+   * <pre>{@code
+   *   prefix.serverName.key
+   *   prefix.key
+   *   key
+   * }</pre>
+   * </p>
+   */
+  public String get(String key, String defaultValue) {
+
+    String value = null;
+    if (serverName != null && prefix != null) {
+      value = propertyMap.get(prefix + "." + serverName + "." + key, null);
+    }
+    if (value == null && prefix != null) {
+      value = propertyMap.get(prefix + "." + key, null);
+    }
+    if (value == null) {
+      value = propertyMap.get(key, null);
+    }
+    return value == null ? defaultValue : value;
+  }
+
+  /**
+   * Return a double property value.
+   */
+  public double getDouble(String key, double defaultValue) {
+
+    String value = get(key, String.valueOf(defaultValue));
+    return Double.parseDouble(value);
+  }
+
+  /**
+   * Return an int property value.
+   */
+  public int getInt(String key, int defaultValue) {
+
+    String value = get(key, String.valueOf(defaultValue));
+    return Integer.parseInt(value);
+  }
+
+  /**
+   * Return a long property value.
+   */
+  public long getLong(String key, long defaultValue) {
+
+    String value = get(key, String.valueOf(defaultValue));
+    return Long.parseLong(value);
+  }
+
+  /**
+   * Return a boolean property value.
+   */
+  public boolean getBoolean(String key, boolean defaultValue) {
+
+    String value = get(key, String.valueOf(defaultValue));
+    return Boolean.parseBoolean(value);
+  }
+
+  /**
+   * Return a Enum property value.
+   */
+  public <T extends Enum<T>> T getEnum(Class<T> enumType, String key, T defaultValue) {
+    String level = get(key, defaultValue.name());
+    return Enum.valueOf(enumType, level.toUpperCase());
+  }
+
+}

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

@@ -1,25 +1,43 @@
 package com.avaje.ebean.config;
 
 import java.io.Serializable;
-import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.Set;
 import java.util.Map.Entry;
+import java.util.Properties;
+import java.util.Set;
 
 /**
  * A map like structure of properties.
+ * <p/>
+ * Handles evaluation of expressions like ${home} and provides convenience methods for int, long and boolean.
  */
-final class PropertyMap implements Serializable {
+public final class PropertyMap implements Serializable {
 
   private static final long serialVersionUID = 1L;
 
   private LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
 
+  public static Properties defaultProperties() {
+    PropertyMap propertyMap = PropertyMapLoader.loadGlobalProperties();
+    return (propertyMap == null) ? new Properties() : propertyMap.asProperties();
+  }
+
   public String toString() {
     return map.toString();
   }
 
+  /**
+   * Return as standard Properties.
+   */
+  public Properties asProperties() {
+    Properties properties = new Properties();
+    for (Entry<String, String> e : entrySet()) {
+      properties.put(e.getKey(), e.getValue());
+    }
+    return properties;
+  }
+
   /**
    * Go through all the properties and evaluate any expressions that have not
    * been resolved.
@@ -36,10 +54,16 @@ final class PropertyMap implements Serializable {
     }
   }
 
+  /**
+   * Returns the value with expressions like ${home} evaluated using system properties and environment variables.
+   */
   public synchronized String eval(String val) {
     return PropertyExpression.eval(val, this);
   }
 
+  /**
+   * Return the boolean property value with a given default.
+   */
   public synchronized boolean getBoolean(String key, boolean defaultValue) {
     String value = get(key);
     if (value == null) {
@@ -49,6 +73,9 @@ final class PropertyMap implements Serializable {
     }
   }
 
+  /**
+   * Return the int property value with a given default.
+   */
   public synchronized int getInt(String key, int defaultValue) {
     String value = get(key);
     if (value == null) {
@@ -58,37 +85,69 @@ final class PropertyMap implements Serializable {
     }
   }
 
+  /**
+   * Return the long property value with a given default.
+   */
+  public synchronized long getLong(String key, long defaultValue) {
+    String value = get(key);
+    if (value == null) {
+      return defaultValue;
+    } else {
+      return Long.parseLong(value);
+    }
+  }
+
+  /**
+   * Return the string property value with a given default.
+   */
   public synchronized String get(String key, String defaultValue) {
     String value = map.get(key.toLowerCase());
     return value == null ? defaultValue : value;
   }
 
+  /**
+   * Return the property value returning null if there is no value defined.
+   */
   public synchronized String get(String key) {
     return map.get(key.toLowerCase());
   }
 
-  synchronized void putAll(Map<String, String> keyValueMap) {
-    Iterator<Entry<String, String>> it = keyValueMap.entrySet().iterator();
-    while (it.hasNext()) {
-      Map.Entry<String, String> entry = it.next();
-      put(entry.getKey(), entry.getValue());
+  /**
+   * Put all evaluating any expressions in the values.
+   */
+  public synchronized void putEvalAll(Map<String, String> keyValueMap) {
+
+    for (Map.Entry<String, String> entry : keyValueMap.entrySet()) {
+      putEval(entry.getKey(), entry.getValue());
     }
   }
 
-  synchronized String putEval(String key, String value) {
+  /**
+   * Put a single key value evaluating any expressions in the value.
+   */
+  public synchronized String putEval(String key, String value) {
     value = PropertyExpression.eval(value, this);
     return map.put(key.toLowerCase(), value);
   }
 
-  synchronized String put(String key, String value) {
+  /**
+   * Put a single key value with no expression evaluation.
+   */
+  public synchronized String put(String key, String value) {
     return map.put(key.toLowerCase(), value);
   }
 
-  synchronized String remove(String key) {
+  /**
+   * Remove an entry.
+   */
+  public synchronized String remove(String key) {
     return map.remove(key.toLowerCase());
   }
 
-  synchronized Set<Entry<String, String>> entrySet() {
+  /**
+   * Return the entries.
+   */
+  public synchronized Set<Entry<String, String>> entrySet() {
     return map.entrySet();
   }
 

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

@@ -3,40 +3,28 @@ 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.io.*;
 import java.util.Map;
 import java.util.Properties;
-import java.util.Map.Entry;
-
-import javax.servlet.ServletContext;
 
 /**
- * Helper used to load the PropertyMap.
+ * Helper used to load the ebean.properties into a PropertyMap.
  */
 final class PropertyMapLoader {
 
   private static final Logger logger = LoggerFactory.getLogger(PropertyMapLoader.class);
 
-  private static ServletContext servletContext;
+  public static PropertyMap loadGlobalProperties() {
 
-  /**
-   * Return the servlet context when in a web environment.
-   */
-  public static ServletContext getServletContext() {
-    return servletContext;
-  }
+    String fileName = System.getenv("EBEAN_PROPS_FILE");
+    if (fileName == null) {
+      fileName = System.getProperty("ebean.props.file");
+      if (fileName == null) {
+        fileName = "ebean.properties";
+      }
+    }
 
-  /**
-   * Set the ServletContext for when ebean.properties is in WEB-INF in a web
-   * application environment.
-   */
-  public static void setServletContext(ServletContext servletContext) {
-    PropertyMapLoader.servletContext = servletContext;
+    return load(null, fileName);
   }
 
   /**
@@ -66,24 +54,27 @@ final class PropertyMapLoader {
    * @param in
    *          the InputStream of the properties file to load.
    */
-  private static PropertyMap load(PropertyMap p, InputStream in) {
+  public static PropertyMap load(PropertyMap p, InputStream in) {
 
     Properties props = new Properties();
     try {
       props.load(in);
       in.close();
+      return load(p, props);
+
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
+  }
+
+  public static PropertyMap load(PropertyMap p, Properties props) {
 
     if (p == null) {
       p = new PropertyMap();
     }
 
     // put values in initially without any evaluation
-    Iterator<Entry<Object, Object>> it = props.entrySet().iterator();
-    while (it.hasNext()) {
-      Map.Entry<Object, Object> entry = it.next();
+    for (Map.Entry<Object, Object> entry : props.entrySet()) {
       String key = ((String) entry.getKey()).toLowerCase();
       String val = ((String) entry.getValue());
       if (val != null) {
@@ -121,18 +112,6 @@ final class PropertyMapLoader {
       throw new NullPointerException("fileName is null?");
     }
 
-    if (servletContext == null) {
-      logger.debug("No servletContext so not looking in WEB-INF for " + fileName);
-
-    } else {
-      // first look in WEB-INF ...
-      InputStream in = servletContext.getResourceAsStream("/WEB-INF/" + fileName);
-      if (in != null) {
-        logger.debug(fileName + " found in WEB-INF");
-        return in;
-      }
-    }
-
     try {
       File f = new File(fileName);
 

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

@@ -1,25 +1,21 @@
 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.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.event.*;
 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;
+import java.util.Properties;
 
 /**
  * The configuration used for creating a EbeanServer.
@@ -34,9 +30,9 @@ import com.avaje.ebean.util.ClassUtil;
  * classes and listeners etc.
  * </p>
  * 
- * <pre class="code">
+ * <pre>{@code
  * ServerConfig c = new ServerConfig();
- * c.setName(&quot;ordh2&quot;);
+ * c.setName("ordh2");
  * 
  * // read the ebean.properties and load
  * // those settings into this serverConfig object
@@ -47,18 +43,18 @@ import com.avaje.ebean.util.ClassUtil;
  * c.setDdlRun(true);
  * 
  * // add any classes found in the app.data package
- * c.addPackage(&quot;app.data&quot;);
+ * c.addPackage("app.data");
  * 
  * // add the names of Jars that contain entities
- * c.addJar(&quot;myJarContainingEntities.jar&quot;);
- * c.addJar(&quot;someOtherJarContainingEntities.jar&quot;);
+ * c.addJar("myJarContainingEntities.jar");
+ * c.addJar("someOtherJarContainingEntities.jar");
  * 
  * // register as the 'Default' server
  * c.setDefaultServer(true);
  * 
  * EbeanServer server = EbeanServerFactory.create(c);
  * 
- * </pre>
+ * }</pre>
  * 
  * @see EbeanServerFactory
  * 
@@ -66,27 +62,19 @@ import com.avaje.ebean.util.ClassUtil;
  * @author rbygrave
  */
 public class ServerConfig {
-  
-  /**
-   * The Constant DEFAULT_QUERY_BATCH_SIZE. Default: 100 
-   */
-  private final static int DEFAULT_QUERY_BATCH_SIZE = 100;
 
   /**
    * The EbeanServer name.
    */
   private String name;
 
+  private ContainerConfig containerConfig;
+
   /**
    * The resource directory.
    */
   private String resourceDirectory;
 
-  /**
-   * The enhance log level. Used with subclass generation.
-   */
-  private int enhanceLogLevel;
-
   /**
    * Set to true to register this EbeanServer with the Ebean singleton.
    */
@@ -115,11 +103,21 @@ public class ServerConfig {
    */
   private List<String> searchJars = new ArrayList<String>();
 
+  /**
+   * Class name of a classPathReader implementation.
+   */
+  private String classPathReaderClassName;
+
   /** 
    * Config controlling the autofetch behaviour.
    */
   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.  
    */
@@ -142,12 +140,14 @@ public class ServerConfig {
   /** 
    * The default batch size for lazy loading 
    */
-  private int lazyLoadBatchSize = 1;
+  private int lazyLoadBatchSize = 10;
 
   /** 
-   * The query batch size. 
+   * The default batch size for 'query joins'.
    */
-  private int queryBatchSize = -1;
+  private int queryBatchSize = 100;
+
+  private boolean eagerFetchLobs;
 
   private boolean ddlGenerate;
 
@@ -175,6 +175,13 @@ public class ServerConfig {
    */
   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. 
    */
@@ -193,7 +200,7 @@ public class ServerConfig {
   /** 
    * The naming convention. 
    */
-  private NamingConvention namingConvention;
+  private NamingConvention namingConvention = new UnderscoreNamingConvention();
 
   /** 
    * Behaviour of update to include on the change properties. 
@@ -209,10 +216,10 @@ public class ServerConfig {
    * 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>();
@@ -230,17 +237,86 @@ public class ServerConfig {
 
   private ServerCacheManager serverCacheManager;
 
-  private boolean collectQueryStatsByNode;
+  private boolean collectQueryStatsByNode = true;
+
+  private boolean collectQueryOrigins = true;
 
-  private boolean collectQueryOrigins;
-  
   /**
-   * Construct a Server Configuration for programmatically creating an
-   * EbeanServer.
+   * 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;
+
+  private int maxCallStack = 5;
+
+  private boolean transactionRollbackOnChecked = true;
+
+  private boolean registerJmxMBeans = true;
+
+  // configuration for the background executor service (thread pool)
+
+  private int backgroundExecutorSchedulePoolSize = 1;
+  private int backgroundExecutorCorePoolSize = 1;
+  private int backgroundExecutorMaxPoolSize = 8;
+  private int backgroundExecutorIdleSecs = 60;
+  private int backgroundExecutorShutdownSecs = 30;
+
+  // defaults for the L2 bean caching
+
+  private int cacheWarmingDelay = 30;
+  private int cacheMaxSize = 10000;
+  private int cacheMaxIdleTime = 600;
+  private int cacheMaxTimeToLive = 60*60*6;
+
+  // defaults for the L2 query caching
+
+  private int queryCacheMaxSize = 1000;
+  private int queryCacheMaxIdleTime = 600;
+  private int queryCacheMaxTimeToLive = 60*60*6;
+
+  /**
+   * 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.
@@ -256,6 +332,26 @@ public class ServerConfig {
     this.name = name;
   }
 
+  /**
+   * Return the container / clustering configuration.
+   * <p/>
+   * The container holds all the EbeanServer instances and provides clustering communication
+   * services to all the EbeanServer instances.
+   */
+  public ContainerConfig getContainerConfig() {
+    return containerConfig;
+  }
+
+  /**
+   * Set the container / clustering configuration.
+   * <p/>
+   * The container holds all the EbeanServer instances and provides clustering communication
+   * services to all the EbeanServer instances.
+   */
+  public void setContainerConfig(ContainerConfig containerConfig) {
+    this.containerConfig = containerConfig;
+  }
+
   /**
    * Return true if this server should be registered with the Ebean singleton
    * when it is created.
@@ -312,15 +408,6 @@ public class ServerConfig {
     return persistBatching;
   }
 
-  /**
-   * Use isPersistBatching() instead.
-   * 
-   * @deprecated
-   */
-  public boolean isUsePersistBatching() {
-    return persistBatching;
-  }
-
   /**
    * Set to true if you what to use JDBC batching for persisting and deleting
    * beans.
@@ -469,17 +556,231 @@ public class ServerConfig {
   }
 
   /**
-   * Return the log level used for "subclassing" enhancement.
+   * Return true if LOB's should default to fetch eager.
+   * By default this is set to false and LOB's must be explicitly fetched.
    */
-  public int getEnhanceLogLevel() {
-    return enhanceLogLevel;
+  public boolean isEagerFetchLobs() {
+    return eagerFetchLobs;
   }
 
   /**
-   * Set the log level used for "subclassing" enhancement.
+   * Set to true if you want LOB's to be fetch eager by default.
+   * By default this is set to false and LOB's must be explicitly fetched.
    */
-  public void setEnhanceLogLevel(int enhanceLogLevel) {
-    this.enhanceLogLevel = enhanceLogLevel;
+  public void setEagerFetchLobs(boolean eagerFetchLobs) {
+    this.eagerFetchLobs = eagerFetchLobs;
+  }
+
+  /**
+   * Return the max call stack to use for origin location.
+   */
+  public int getMaxCallStack() {
+    return maxCallStack;
+  }
+
+  /**
+   * Set the max call stack to use for origin location.
+   */
+  public void setMaxCallStack(int maxCallStack) {
+    this.maxCallStack = maxCallStack;
+  }
+
+  /**
+   * Return true if transactions should rollback on checked exceptions.
+   */
+  public boolean isTransactionRollbackOnChecked() {
+    return transactionRollbackOnChecked;
+  }
+
+  /**
+   * Set to true if transactions should by default rollback on checked exceptions.
+   */
+  public void setTransactionRollbackOnChecked(boolean transactionRollbackOnChecked) {
+    this.transactionRollbackOnChecked = transactionRollbackOnChecked;
+  }
+
+  /**
+   * Return true if the server should register JMX MBeans.
+   */
+  public boolean isRegisterJmxMBeans() {
+    return registerJmxMBeans;
+  }
+
+  /**
+   * Set if the server should register JMX MBeans.
+   */
+  public void setRegisterJmxMBeans(boolean registerJmxMBeans) {
+    this.registerJmxMBeans = registerJmxMBeans;
+  }
+
+  /**
+   * Return the Background executor schedule pool size. Defaults to 1.
+   */
+  public int getBackgroundExecutorSchedulePoolSize() {
+    return backgroundExecutorSchedulePoolSize;
+  }
+
+  /**
+   * Set the Background executor schedule pool size.
+   */
+  public void setBackgroundExecutorSchedulePoolSize(int backgroundExecutorSchedulePoolSize) {
+    this.backgroundExecutorSchedulePoolSize = backgroundExecutorSchedulePoolSize;
+  }
+
+  /**
+   * Return the Background executor core pool size.
+   */
+  public int getBackgroundExecutorCorePoolSize() {
+    return backgroundExecutorCorePoolSize;
+  }
+
+  /**
+   * Set the Background executor core pool size.
+   */
+  public void setBackgroundExecutorCorePoolSize(int backgroundExecutorCorePoolSize) {
+    this.backgroundExecutorCorePoolSize = backgroundExecutorCorePoolSize;
+  }
+
+  /**
+   * Return the Background executor max pool size.
+   */
+  public int getBackgroundExecutorMaxPoolSize() {
+    return backgroundExecutorMaxPoolSize;
+  }
+
+  /**
+   * Set the Background executor max pool size.
+   */
+  public void setBackgroundExecutorMaxPoolSize(int backgroundExecutorMaxPoolSize) {
+    this.backgroundExecutorMaxPoolSize = backgroundExecutorMaxPoolSize;
+  }
+
+  /**
+   * Return the Background executor idle seconds.
+   */
+  public int getBackgroundExecutorIdleSecs() {
+    return backgroundExecutorIdleSecs;
+  }
+
+  /**
+   * Set the Background executor idle seconds.
+   */
+  public void setBackgroundExecutorIdleSecs(int backgroundExecutorIdleSecs) {
+    this.backgroundExecutorIdleSecs = backgroundExecutorIdleSecs;
+  }
+
+  /**
+   * Return the Background executor shutdown seconds. This is the time allowed for the pool to shutdown nicely
+   * before it is forced shutdown.
+   */
+  public int getBackgroundExecutorShutdownSecs() {
+    return backgroundExecutorShutdownSecs;
+  }
+
+  /**
+   * Set the Background executor shutdown seconds. This is the time allowed for the pool to shutdown nicely
+   * before it is forced shutdown.
+   */
+  public void setBackgroundExecutorShutdownSecs(int backgroundExecutorShutdownSecs) {
+    this.backgroundExecutorShutdownSecs = backgroundExecutorShutdownSecs;
+  }
+
+  /**
+   * Return the cache warming delay in seconds.
+   */
+  public int getCacheWarmingDelay() {
+    return cacheWarmingDelay;
+  }
+
+  /**
+   * Set the cache warming delay in seconds.
+   */
+  public void setCacheWarmingDelay(int cacheWarmingDelay) {
+    this.cacheWarmingDelay = cacheWarmingDelay;
+  }
+
+  /**
+   * Return the L2 cache default max size.
+   */
+  public int getCacheMaxSize() {
+    return cacheMaxSize;
+  }
+
+  /**
+   * Set the L2 cache default max size.
+   */
+  public void setCacheMaxSize(int cacheMaxSize) {
+    this.cacheMaxSize = cacheMaxSize;
+  }
+
+  /**
+   * Return the L2 cache default max idle time in seconds.
+   */
+  public int getCacheMaxIdleTime() {
+    return cacheMaxIdleTime;
+  }
+
+  /**
+   * Set the L2 cache default max idle time in seconds.
+   */
+  public void setCacheMaxIdleTime(int cacheMaxIdleTime) {
+    this.cacheMaxIdleTime = cacheMaxIdleTime;
+  }
+
+  /**
+   * Return the L2 cache default max time to live in seconds.
+   */
+  public int getCacheMaxTimeToLive() {
+    return cacheMaxTimeToLive;
+  }
+
+  /**
+   * Set the L2 cache default max time to live in seconds.
+   */
+  public void setCacheMaxTimeToLive(int cacheMaxTimeToLive) {
+    this.cacheMaxTimeToLive = cacheMaxTimeToLive;
+  }
+
+  /**
+   * Return the L2 query cache default max size.
+   */
+  public int getQueryCacheMaxSize() {
+    return queryCacheMaxSize;
+  }
+
+  /**
+   * Set the L2 query cache default max size.
+   */
+  public void setQueryCacheMaxSize(int queryCacheMaxSize) {
+    this.queryCacheMaxSize = queryCacheMaxSize;
+  }
+
+  /**
+   * Return the L2 query cache default max idle time in seconds.
+   */
+  public int getQueryCacheMaxIdleTime() {
+    return queryCacheMaxIdleTime;
+  }
+
+  /**
+   * Set the L2 query cache default max idle time in seconds.
+   */
+  public void setQueryCacheMaxIdleTime(int queryCacheMaxIdleTime) {
+    this.queryCacheMaxIdleTime = queryCacheMaxIdleTime;
+  }
+
+  /**
+   * Return the L2 query cache default max time to live in seconds.
+   */
+  public int getQueryCacheMaxTimeToLive() {
+    return queryCacheMaxTimeToLive;
+  }
+
+  /**
+   * Set the L2 query cache default max time to live in seconds.
+   */
+  public void setQueryCacheMaxTimeToLive(int queryCacheMaxTimeToLive) {
+    this.queryCacheMaxTimeToLive = queryCacheMaxTimeToLive;
   }
 
   /**
@@ -582,6 +883,20 @@ 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.
@@ -817,6 +1132,43 @@ public class ServerConfig {
     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.
    */
@@ -948,6 +1300,23 @@ public class ServerConfig {
     this.searchJars = searchJars;
   }
 
+  /**
+   * Return the class name of a classPathReader implementation.
+   */
+  public String getClassPathReaderClassName() {
+    return classPathReaderClassName;
+  }
+
+  /**
+   * Set the class name of a classPathReader implementation.
+   *
+   * Refer to server.util.ClassPathReader, this should really by a plugin but doing this for now
+   * to be relatively compatible with current implementation.
+   */
+  public void setClassPathReaderClassName(String classPathReaderClassName) {
+    this.classPathReaderClassName = classPathReaderClassName;
+  }
+
   /**
    * Set the list of classes (entities, listeners, scalarTypes etc) that should
    * be used for this server.
@@ -1153,14 +1522,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;
   }
 
@@ -1199,49 +1568,60 @@ 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;
   }
 
   /**
-   * Load the settings from the ebean.properties file.
+   * 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 settings from ebean.properties.
    */
   public void loadFromProperties() {
-    ConfigPropertyMap p = new ConfigPropertyMap(name);
+    loadFromProperties(PropertyMap.defaultProperties());
+  }
+
+  /**
+   * Load the settings from the given properties
+   */
+  public void loadFromProperties(Properties properties) {
+    PropertiesWrapper p = new PropertiesWrapper("ebean", name, properties);
     loadSettings(p);
   }
 
-  /**
-   * Return a PropertySource for this server.
-   */
-  public PropertySource getPropertySource() {
-    return GlobalProperties.getPropertySource(name);
-  }
-
-  /**
-   * Return a configuration property using a default value.
-   */
-  public String getProperty(String propertyName, String defaultValue) {
-    PropertySource p = new ConfigPropertyMap(name);
-    return p.get(propertyName, defaultValue);
-  }
-
-  /**
-   * Return a configuration property.
-   */
-  public String getProperty(String propertyName) {
-    return getProperty(propertyName, null);
-  }
 
   @SuppressWarnings("unchecked")
-  private <T> T createInstance(PropertySource p, Class<T> type, String key) {
+  private <T> T createInstance(PropertiesWrapper p, Class<T> pluginType, String key) {
 
     String classname = p.get(key, null);
-    if (classname == null) {
-      return null;
-    }
-
-    return (T) ClassUtil.newInstance(classname);
+    return classname == null ? null : (T) ClassUtil.newInstance(classname);
   }
 
   /**
@@ -1251,37 +1631,37 @@ public class ServerConfig {
    *
    * @param p - The defined property source passed to load settings
    */
-  protected void loadDataSourceSettings(PropertySource p) {
-    dataSourceConfig.loadSettings(p.getServerName());
+  protected void loadDataSourceSettings(PropertiesWrapper p) {
+    dataSourceConfig.loadSettings(p.withPrefix("datasource"));
   }
 
   /**
    * 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) {
+  protected void loadAutofetchSettings(PropertiesWrapper p) {
     autofetchConfig.loadSettings(p);
   }
 
   /**
    * Load the configuration settings from the properties file.
    */
-  protected void loadSettings(PropertySource p) {
+  protected void loadSettings(PropertiesWrapper p) {
 
+    if (namingConvention != null) {
+      namingConvention.loadFromProperties(p);
+    }
     if (autofetchConfig == null) {
       autofetchConfig = new AutofetchConfig();
     }
-
-    loadAutofetchConfig(p);
+    loadAutofetchSettings(p);
 
     if (dataSourceConfig == null) {
       dataSourceConfig = new DataSourceConfig();
     }
-
     loadDataSourceSettings(p);
 
-    useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", false);
+    autoCommitMode = p.getBoolean("autoCommitMode", autoCommitMode);
+    useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
     namingConvention = createNamingConvention(p);
     databasePlatform = createInstance(p, DatabasePlatform.class, "databasePlatform");
     encryptKeyManager = createInstance(p, EncryptKeyManager.class, "encryptKeyManager");
@@ -1296,56 +1676,66 @@ public class ServerConfig {
       searchJars = getSearchJarsPackages(jarsProp);
     }
 
-    String packagesProp = p.get("search.packages", p.get("packages", null));
     if (packages != null) {
+      String packagesProp = p.get("search.packages", p.get("packages", null));
       packages = getSearchJarsPackages(packagesProp);
     }
 
-    collectQueryStatsByNode = p.getBoolean("collectQueryStatsByNode", true);
-    collectQueryOrigins = p.getBoolean("collectQueryOrigins", true);
+    collectQueryStatsByNode = p.getBoolean("collectQueryStatsByNode", collectQueryStatsByNode);
+    collectQueryOrigins = p.getBoolean("collectQueryOrigins", collectQueryOrigins);
 
-    updateChangesOnly = p.getBoolean("updateChangesOnly", true);
+    updateChangesOnly = p.getBoolean("updateChangesOnly", updateChangesOnly);
     
-    boolean defaultDeleteMissingChildren = p.getBoolean("defaultDeleteMissingChildren", true);
+    boolean defaultDeleteMissingChildren = p.getBoolean("defaultDeleteMissingChildren", updatesDeleteMissingChildren);
     updatesDeleteMissingChildren = p.getBoolean("updatesDeleteMissingChildren", defaultDeleteMissingChildren);
 
-    boolean batchMode = p.getBoolean("batch.mode", false);
+    boolean batchMode = p.getBoolean("batch.mode", persistBatching);
     persistBatching = p.getBoolean("persistBatching", batchMode);
 
-    int batchSize = p.getInt("batch.size", 20);
+    int batchSize = p.getInt("batch.size", persistBatchSize);
     persistBatchSize = p.getInt("persistBatchSize", batchSize);
 
-    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);
+    persistenceContextScope = PersistenceContextScope.valueOf(p.get("persistenceContextScope","TRANSACTION"));
 
-    lazyLoadBatchSize = p.getInt("lazyLoadBatchSize", 1);
-    queryBatchSize = p.getInt("queryBatchSize", DEFAULT_QUERY_BATCH_SIZE);
+    dataSourceJndiName = p.get("dataSourceJndiName", dataSourceJndiName);
+    databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", databaseSequenceBatchSize);
+    databaseBooleanTrue = p.get("databaseBooleanTrue", databaseBooleanTrue);
+    databaseBooleanFalse = p.get("databaseBooleanFalse", databaseBooleanFalse);
+    databasePlatformName = p.get("databasePlatformName", databasePlatformName);
+    uuidStoreAsBinary = p.getBoolean("uuidStoreAsBinary", uuidStoreAsBinary);
+    localTimeWithNanos = p.getBoolean("localTimeWithNanos", localTimeWithNanos);
 
-    ddlGenerate = p.getBoolean("ddl.generate", false);
-    ddlRun = p.getBoolean("ddl.run", false);
+    lazyLoadBatchSize = p.getInt("lazyLoadBatchSize", lazyLoadBatchSize);
+    queryBatchSize = p.getInt("queryBatchSize", queryBatchSize);
+
+    String jsonDateTimeFormat = p.get("jsonDateTime", null);
+    if (jsonDateTimeFormat != null) {
+      jsonDateTime = JsonConfig.DateTime.valueOf(jsonDateTimeFormat);
+    } else {
+      jsonDateTime = JsonConfig.DateTime.MILLIS;
+    }
+
+    ddlGenerate = p.getBoolean("ddl.generate", ddlGenerate);
+    ddlRun = p.getBoolean("ddl.run", ddlRun);
 
     classes = getClasses(p);
   }
 
-  private NamingConvention createNamingConvention(PropertySource p) {
+  private NamingConvention createNamingConvention(PropertiesWrapper properties) {
 
-    NamingConvention nc = createInstance(p, NamingConvention.class, "namingconvention");
+    NamingConvention nc = createInstance(properties, NamingConvention.class, "namingconvention");
     if (nc == null) {
       return null;
     }
     if (nc instanceof AbstractNamingConvention) {
       AbstractNamingConvention anc = (AbstractNamingConvention) nc;
-      String v = p.get("namingConvention.useForeignKeyPrefix", null);
+      String v = properties.get("namingConvention.useForeignKeyPrefix", null);
       if (v != null) {
         boolean useForeignKeyPrefix = Boolean.valueOf(v);
         anc.setUseForeignKeyPrefix(useForeignKeyPrefix);
       }
 
-      String sequenceFormat = p.get("namingConvention.sequenceFormat", null);
+      String sequenceFormat = properties.get("namingConvention.sequenceFormat", null);
       if (sequenceFormat != null) {
         anc.setSequenceFormat(sequenceFormat);
       }
@@ -1356,20 +1746,20 @@ public class ServerConfig {
   /**
    * Build the list of classes from the comma delimited string.
    * 
-   * @param p
-   *          the p
+   * @param properties
+   *          the properties
    * 
    * @return the classes
    */
-  private ArrayList<Class<?>> getClasses(PropertySource p) {
+  private List<Class<?>> getClasses(PropertiesWrapper properties) {
 
-    String classNames = p.get("classes", null);
+    String classNames = properties.get("classes", null);
     if (classNames == null) {
 
       return null;
     }
 
-    ArrayList<Class<?>> classes = new ArrayList<Class<?>>();
+    List<Class<?>> classes = new ArrayList<Class<?>>();
 
     String[] split = classNames.split("[ ,;]");
     for (int i = 0; i < split.length; i++) {
@@ -1399,5 +1789,4 @@ public class ServerConfig {
     }
     return hitList;
   }
-
 }

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

@@ -57,6 +57,13 @@ 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();
   }
@@ -121,6 +128,18 @@ 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,6 +6,7 @@ import javax.sql.DataSource;
 
 import com.avaje.ebean.BackgroundExecutor;
 import com.avaje.ebean.Query;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -14,42 +15,67 @@ 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 name. */
+  /** 
+   * The database platform name. 
+   */
   protected String name = "generic";
 
+  protected String columnAliasPrefix = "c";
+
+  protected String tableAliasPlaceHolder = "${ta}";
+
   /**
    * Use a BackTick ` at the beginning and end of table or column names that you
    * want to use quoted identifiers for. The backticks get converted to the
@@ -57,6 +83,11 @@ 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;
@@ -139,6 +170,34 @@ public class DatabasePlatform {
     return dbDdlSyntax;
   }
 
+  /**
+   * Return the column alias prefix.
+   */
+  public String getColumnAliasPrefix() {
+    return columnAliasPrefix;
+  }
+
+  /**
+   * Set the column alias prefix.
+   */
+  public void setColumnAliasPrefix(String columnAliasPrefix) {
+    this.columnAliasPrefix = columnAliasPrefix;
+  }
+
+  /**
+   * Return the table alias placeholder.
+   */
+  public String getTableAliasPlaceHolder() {
+    return tableAliasPlaceHolder;
+  }
+
+  /**
+   * Set the table alias placeholder.
+   */
+  public void setTableAliasPlaceHolder(String tableAliasPlaceHolder) {
+    this.tableAliasPlaceHolder = tableAliasPlaceHolder;
+  }
+
   /**
    * Return the close quote for quoted identifiers.
    * 
@@ -299,4 +358,13 @@ 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,5 +1,7 @@
 package com.avaje.ebean.config.dbplatform;
 
+import com.avaje.ebean.config.TableName;
+
 /**
  * Used to support DB specific syntax for DDL generation.
  */
@@ -9,7 +11,7 @@ public class DbDdlSyntax {
 
   private boolean inlinePrimaryKeyConstraint = false;
 
-  private boolean addOneToOneUniqueContraint = false;
+  private boolean addOneToOneUniqueContraint = true;
 
   private int maxConstraintNameLength = 32;
 
@@ -43,6 +45,17 @@ 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.
    */
@@ -248,26 +261,29 @@ 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();
-    buffer.append("ix_");
-    buffer.append(table);
-    buffer.append("_");
-    buffer.append(propName);
+
+    StringBuilder buffer = new StringBuilder(30);
+    buffer.append("ix_").append(TableName.parse(table));
+    buffer.append("_").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();
-    buffer.append("fk_");
-    buffer.append(table);
-    buffer.append("_");
-    buffer.append(propName);
+    StringBuilder buffer = new StringBuilder(30);
+    buffer.append("fk_").append(TableName.parse(table));
+    buffer.append("_").append(propName);
 
     addSuffix(buffer, fkCount);
 
@@ -276,15 +292,10 @@ public class DbDdlSyntax {
 
   /**
    * Adds the suffix.
-   * 
-   * @param buffer
-   *          the buffer
-   * @param count
-   *          the count
    */
   protected void addSuffix(StringBuilder buffer, int count) {
-    final String suffixNr = Integer.toString(count);
-    final int suffixLen = suffixNr.length() + 1;
+    String suffixNr = Integer.toString(count);
+    int suffixLen = suffixNr.length() + 1;
 
     if (buffer.length() + suffixLen > maxConstraintNameLength) {
       buffer.setLength(maxConstraintNameLength - suffixLen);

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

@@ -1,7 +1,6 @@
 package com.avaje.ebean.config.dbplatform;
 
 import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.config.GlobalProperties;
 
 import javax.sql.DataSource;
 
@@ -14,14 +13,13 @@ public class H2Platform extends DatabasePlatform {
     super();
     this.name = "h2";
     this.dbEncrypt = new H2DbEncrypt();
+    // like ? escape'' not working in the latest version H2 so just using no
+    // escape clause for now noting that backslash is an escape char for like in H2
+    this.likeClause = "like ?";
 
     // only support getGeneratedKeys with non-batch JDBC
     // so generally use SEQUENCE instead of IDENTITY for H2
-    boolean useIdentity = GlobalProperties.getBoolean("ebean.h2platform.useIdentity", false);
-
-    IdType idType = useIdentity ? IdType.IDENTITY : IdType.SEQUENCE;
-    this.dbIdentity.setIdType(idType);
-
+    this.dbIdentity.setIdType(IdType.SEQUENCE);
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsSequence(true);
     this.dbIdentity.setSupportsIdentity(true);

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

@@ -1,11 +1,9 @@
 package com.avaje.ebean.config.dbplatform;
 
-import java.sql.Types;
+import com.avaje.ebean.BackgroundExecutor;
 
 import javax.sql.DataSource;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.config.GlobalProperties;
+import java.sql.Types;
 
 /**
  * H2 specific platform.
@@ -16,14 +14,7 @@ public class HsqldbPlatform extends DatabasePlatform {
     super();
     this.name = "hsqldb";
     this.dbEncrypt = new H2DbEncrypt();
-
-    // only support getGeneratedKeys with non-batch JDBC
-    // so generally use SEQUENCE instead of IDENTITY for H2
-    boolean useIdentity = GlobalProperties.getBoolean("ebean.hsqldb.useIdentity", true);
-
-    IdType idType = useIdentity ? IdType.IDENTITY : IdType.SEQUENCE;
-    this.dbIdentity.setIdType(idType);
-
+    this.dbIdentity.setIdType(IdType.IDENTITY);
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsSequence(true);
     this.dbIdentity.setSupportsIdentity(true);

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

@@ -17,22 +17,21 @@ public class LimitOffsetSqlLimiter implements SqlLimiter {
 
   public SqlLimitResponse limit(SqlLimitRequest request) {
 
-    StringBuilder sb = new StringBuilder(512);
+    String dbSql = request.getDbSql();
+    
+    StringBuilder sb = new StringBuilder(50 + dbSql.length());
     sb.append("select ");
     if (request.isDistinct()) {
       sb.append("distinct ");
     }
 
-    sb.append(request.getDbSql());
+    sb.append(dbSql);
 
     int firstRow = request.getFirstRow();
     int maxRows = request.getMaxRows();
-    if (maxRows > 0) {
-      maxRows = maxRows + 1;
-    }
 
     if (maxRows > 0 || firstRow > 0) {
-      sb.append(" ").append(NEW_LINE).append(LIMIT).append(" ").append(maxRows);
+      sb.append(" ").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,9 +26,7 @@ public class MsSqlServer2005SqlLimiter implements SqlLimiter {
 
     int lastRow = request.getMaxRows();
     if (lastRow > 0) {
-      // fetch 1 more than we return so that
-      // we know if more rows are available
-      lastRow = lastRow + firstRow + 1;
+      lastRow = lastRow + firstRow;
     }
 
     if (firstRow < 1) {

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

@@ -20,6 +20,7 @@ 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/Oracle10DbEncrypt.java

@@ -1,7 +1,5 @@
 package com.avaje.ebean.config.dbplatform;
 
-import com.avaje.ebean.config.GlobalProperties;
-
 /**
  * Oracle encryption support.
  * 
@@ -48,12 +46,19 @@ import com.avaje.ebean.config.GlobalProperties;
 public class Oracle10DbEncrypt extends AbstractDbEncrypt {
 
   /**
-   * Constructs the Oracle10DbEncrypt.
+   * Constructs the Oracle10DbEncrypt with default encrypt and decrypt stored procedures.
    */
   public Oracle10DbEncrypt() {
+    this("eb_encrypt", "eb_decrypt");
+  }
 
-    String encryptfunction = GlobalProperties.get("ebean.oracle.encryptfunction", "eb_encrypt");
-    String decryptfunction = GlobalProperties.get("ebean.oracle.decryptfunction", "eb_decrypt");
+  /**
+   * Constructs the Oracle10DbEncrypt specifying encrypt and decrypt stored procedures.
+   *
+   * @param encryptfunction the encrypt stored procedure
+   * @param decryptfunction the decrypt stored procedure
+   */
+  public Oracle10DbEncrypt(String encryptfunction, String decryptfunction) {
 
     this.varcharEncryptFunction = new OraVarcharFunction(encryptfunction, decryptfunction);
     this.dateEncryptFunction = new OraDateFunction(encryptfunction, decryptfunction);

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

@@ -0,0 +1,67 @@
+package com.avaje.ebean.config.dbplatform;
+
+import com.avaje.ebean.BackgroundExecutor;
+
+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);
+
+    this.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

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

@@ -1,43 +1,48 @@
 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.
+ * Postgres v9 specific platform.
  * <p>
- * No support for getGeneratedKeys.
+ * Uses serial types and 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();
 
-    this.dbIdentity.setSupportsGetGeneratedKeys(false);
-    this.dbIdentity.setIdType(IdType.SEQUENCE);
+    // Use Identity and getGeneratedKeys
+    this.dbIdentity.setIdType(IdType.IDENTITY);
+    this.dbIdentity.setSupportsGetGeneratedKeys(true);
     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.columnAliasPrefix = "as c";
 
     this.openQuote = "\"";
     this.closeQuote = "\"";
 
-    // dbTypeMap.put(Types.BOOLEAN, new DbType("bit default 0"));
-
+    dbTypeMap.put(TYPE_HSTORE, new DbType("hstore"));
+    
     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, ";
 
-  final String rowNumberWindowAlias;
+  private final String rowNumberWindowAlias;
 
   /**
    * Specify the name of the rowNumberWindowAlias.
@@ -30,16 +30,18 @@ public class RowNumberSqlLimiter implements SqlLimiter {
 
   public SqlLimitResponse limit(SqlLimitRequest request) {
 
-    StringBuilder sb = new StringBuilder(500);
+    String dbSql = request.getDbSql();
+    
+    StringBuilder sb = new StringBuilder(60 + dbSql.length());
 
     int firstRow = request.getFirstRow();
 
     int lastRow = request.getMaxRows();
     if (lastRow > 0) {
-      lastRow = lastRow + firstRow + 1;
+      lastRow = lastRow + firstRow;
     }
 
-    sb.append("select * from (").append(NEW_LINE);
+    sb.append("select * from ( ");
 
     sb.append("select ");
     if (request.isDistinct()) {
@@ -50,9 +52,9 @@ public class RowNumberSqlLimiter implements SqlLimiter {
     sb.append(request.getDbOrderBy());
     sb.append(ROW_NUMBER_AS);
 
-    sb.append(request.getDbSql());
+    sb.append(dbSql);
 
-    sb.append(NEW_LINE).append(") ");
+    sb.append(" ) ");
     sb.append(rowNumberWindowAlias);
     sb.append(" where ");
     if (firstRow > 0) {

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

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

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

@@ -40,7 +40,7 @@ public abstract class SequenceIdGenerator implements IdGenerator {
 
   protected final BackgroundExecutor backgroundExecutor;
 
-  protected final ArrayList<Integer> idList = new ArrayList<Integer>(50);
+  protected final ArrayList<Long> idList = new ArrayList<Long>(50);
 
   protected int batchSize;
 
@@ -117,7 +117,7 @@ public abstract class SequenceIdGenerator implements IdGenerator {
       if (idList.size() == 0) {
         loadMoreIds(batchSize, t);
       }
-      Integer nextId = idList.remove(0);
+      Long nextId = idList.remove(0);
 
       if (batchSize > 1) {
         if (idList.size() <= batchSize / 2) {
@@ -158,7 +158,7 @@ public abstract class SequenceIdGenerator implements IdGenerator {
 
   protected void loadMoreIds(final int numberToLoad, Transaction t) {
 
-    ArrayList<Integer> newIds = getMoreIds(numberToLoad, t);
+    ArrayList<Long> newIds = getMoreIds(numberToLoad, t);
 
     if (logger.isDebugEnabled()) {
       logger.debug("... seq:" + seqName + " loaded:" + numberToLoad + " ids:" + newIds);
@@ -174,11 +174,11 @@ public abstract class SequenceIdGenerator implements IdGenerator {
   /**
    * Get more Id's by executing a query and reading the Id's returned.
    */
-  protected ArrayList<Integer> getMoreIds(int loadSize, Transaction t) {
+  protected ArrayList<Long> getMoreIds(int loadSize, Transaction t) {
 
     String sql = getSql(loadSize);
 
-    ArrayList<Integer> newIds = new ArrayList<Integer>(loadSize);
+    ArrayList<Long> newIds = new ArrayList<Long>(loadSize);
 
     boolean useTxnConnection = t != null;
 
@@ -191,12 +191,10 @@ public abstract class SequenceIdGenerator implements IdGenerator {
       pstmt = c.prepareStatement(sql);
       rset = pstmt.executeQuery();
       while (rset.next()) {
-        int val = rset.getInt(1);
-        newIds.add(Integer.valueOf(val));
+        newIds.add(rset.getLong(1));
       }
       if (newIds.size() == 0) {
-        String m = "Always expecting more than 1 row from " + sql;
-        throw new PersistenceException(m);
+        throw new PersistenceException("Always expecting more than 1 row from " + sql);
       }
 
       return newIds;

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

@@ -8,15 +8,12 @@ public class SqlAnywhereLimiter implements SqlLimiter {
 
   public SqlLimitResponse limit(SqlLimitRequest request) {
 
-    StringBuilder sb = new StringBuilder(500);
+    String dbSql = request.getDbSql();
+    
+    StringBuilder sb = new StringBuilder(60 + dbSql.length());
 
     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 ...
@@ -31,7 +28,7 @@ public class SqlAnywhereLimiter implements SqlLimiter {
     if (firstRow > 0) {
       sb.append("start at ").append(firstRow + 1).append(" ");
     }
-    sb.append(request.getDbSql());
+    sb.append(dbSql);
 
     String sql = request.getDbPlatform().completeSql(sb.toString(), request.getOrmQuery());
 

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

@@ -5,8 +5,6 @@ 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

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

@@ -33,11 +33,17 @@ 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 {@link ServerConfig#add(BeanPersistListener<?>)}}.
  * </p>
  * @see ServerConfig#add(BeanPersistListener)
  */
-public interface BeanPersistListener<T> {
+public interface BeanPersistListener {
+
+  /**
+   * Return true if this BeanPersistListener should be registered for events
+   * on this entity type.
+   */
+  public boolean isRegisterFor(Class<?> cls);
 
   /**
    * Notified that a bean has been inserted locally. Return true if you want the
@@ -46,7 +52,7 @@ public interface BeanPersistListener<T> {
    * @param bean
    *          The bean that was inserted.
    */
-  public boolean inserted(T bean);
+  public boolean inserted(Object bean);
 
   /**
    * Notified that a bean has been updated locally. Return true if you want the
@@ -57,7 +63,7 @@ public interface BeanPersistListener<T> {
    * @param updatedProperties
    *          The properties that were modified by this update.
    */
-  public boolean updated(T bean, Set<String> updatedProperties);
+  public boolean updated(Object bean, Set<String> updatedProperties);
 
   /**
    * Notified that a bean has been deleted locally. Return true if you want the
@@ -66,7 +72,7 @@ public interface BeanPersistListener<T> {
    * @param bean
    *          The bean that was deleted.
    */
-  public boolean deleted(T bean);
+  public boolean deleted(Object bean);
 
   /**
    * Notify that a bean was inserted on another node of the cluster.

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

@@ -19,9 +19,6 @@ import com.avaje.ebean.Query;
  * properties and applying that to both what to fetch (ORM query) and what to
  * render (JAX-RS JSON / XML).
  * </p>
- * 
- * @author rbygrave
- * 
  */
 public class PathProperties {
 

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

@@ -53,6 +53,9 @@ class PathPropertiesParser {
       case '(':
         return currentWord();
       default:
+        if (pos == 1) {
+          return "";
+        }
       }
     } while (pos < eof);
     throw new RuntimeException("Hit EOF while reading sectionTitle from " + startPos);
@@ -91,6 +94,10 @@ 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 occured typically in processing CSV, JSON or XML.
+ * An exception occurred typically in processing CSV, JSON or XML.
  * 
  * @author rbygrave
  */

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

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

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

@@ -0,0 +1,209 @@
+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,5 +1,9 @@
 package com.avaje.ebean.text.json;
 
+import com.avaje.ebean.text.PathProperties;
+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;
@@ -7,125 +11,136 @@ 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);
+  public <T> T toBean(Class<T> rootType, String json) throws JsonIOException;
 
   /**
    * 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);
-
-  /**
-   * 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);
+  public <T> T toBean(Class<T> rootType, Reader json) throws JsonIOException;
 
   /**
    * 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);
-
-  /**
-   * 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);
+  public <T> List<T> toList(Class<T> rootType, String json) throws JsonIOException;
 
   /**
    * 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);
-
-  /**
-   * 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);
+  public <T> List<T> toList(Class<T> rootType, Reader json) throws JsonIOException;
 
   /**
    * 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, JsonReadOptions options);
+  public Object toObject(Type genericType, Reader json) throws JsonIOException;
 
   /**
    * 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, JsonReadOptions options);
+  public Object toObject(Type genericType, String json) throws JsonIOException;
 
   /**
-   * Write the bean or collection in JSON format to the writer with default
-   * options.
-   * 
-   * @param o
-   *          the bean or collection of beans to write
-   * @param writer
-   *          used to write the json output to
+   * Return the bean or collection as JSON string.
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public void toJsonWriter(Object o, Writer writer);
+  public String toJson(Object value) throws JsonIOException;
 
   /**
-   * With additional pretty output option.
+   * Write the bean or collection in JSON format to the writer.
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public void toJsonWriter(Object o, Writer writer, boolean pretty);
+  public void toJson(Object value, Writer writer) throws JsonIOException;
 
   /**
-   * With additional options to specify JsonValueAdapter and
-   * JsonWriteBeanVisitor's.
-   * 
-   * @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
+   * Write the bean or collection to the JsonGenerator.
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public void toJsonWriter(Object o, Writer writer, boolean pretty, JsonWriteOptions options);
+  public void toJson(Object value, JsonGenerator generator) throws JsonIOException;
 
   /**
-   * With additional JSONP callback function.
+   * Return the bean or collection as JSON string using PathProperties.
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public void toJsonWriter(Object o, Writer writer, boolean pretty, JsonWriteOptions options,
-      String callback);
+  public String toJson(Object value, PathProperties pathProperties) throws JsonIOException;
 
   /**
-   * Convert a bean or collection to json string using default options.
+   * Write the bean or collection as json to the writer using the PathProperties.
    */
-  public String toJsonString(Object o);
+  public void toJson(Object value, Writer writer, PathProperties pathProperties) throws JsonIOException;
 
   /**
-   * Convert a bean or collection to json string with pretty format using
-   * default options.
+   * Write the bean or collection to the JsonGenerator using the PathProperties.
    */
-  public String toJsonString(Object o, boolean pretty);
+  public void toJson(Object value, JsonGenerator generator, PathProperties pathProperties) throws JsonIOException;
 
   /**
-   * Convert a bean or collection to json string using options.
+   * Deprecated in favour of using PathProperties by itself.
+   * Write json to the JsonGenerator using the JsonWriteOptions.
+   *
+   * @deprecated
    */
-  public String toJsonString(Object o, boolean pretty, JsonWriteOptions options);
+  public void toJson(Object value, JsonGenerator generator, JsonWriteOptions options) throws JsonIOException;
 
   /**
-   * Convert a bean or collection to json string using a JSONP callback.
+   * Deprecated in favour of using PathProperties by itself.
+   * With additional options.
+   *
+   * @throws JsonIOException When IOException occurs
+   *
+   * @deprecated
    */
-  public String toJsonString(Object o, boolean pretty, JsonWriteOptions options, String callback);
+  public void toJson(Object value, Writer writer, JsonWriteOptions options) throws JsonIOException;
 
   /**
-   * Return true if the type is known as an Entity or Xml type or a List Set or
-   * Map of known bean types.
+   * Deprecated in favour of using PathProperties by itself.
+   * Convert a bean or collection to json string.
+   *
+   * @throws JsonIOException When IOException occurs
+   *
+   * @deprecated
+   */
+  public String toJson(Object value, JsonWriteOptions options) throws JsonIOException;
+
+  /**
+   * Return true if the type is known as an Entity bean or a List Set or
+   * Map of entity beans.
    */
   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

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

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

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

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

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

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

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

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

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

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

@@ -1,61 +0,0 @@
-/**
- * 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

@@ -1,33 +0,0 @@
-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,225 +1,42 @@
 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;
 
 /**
+ * Deprecated in favour of just using 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.toJsonString(list, true, writeOptions);
- * 
- * </pre>
- * 
- * @see JsonContext#toList(Class, String, JsonReadOptions)
- * 
- * @author rbygrave
- * 
+ * @deprecated
  */
 public class JsonWriteOptions {
 
-  protected String callback;
-
-  protected JsonValueAdapter valueAdapter;
-
-  protected Map<String, JsonWriteBeanVisitor<?>> visitorMap;
-
   protected PathProperties pathProperties;
 
   /**
    * Parse and return a PathProperties from nested string format like
    * (a,b,c(d,e),f(g)) where "c" is a path containing "d" and "e" and "f" is a
    * path containing "g" and the root path contains "a","b","c" and "f".
+   *
+   * @see com.avaje.ebean.text.PathProperties#parse(String)
    */
   public static JsonWriteOptions parsePath(String pathProperties) {
 
-    PathProperties p = PathProperties.parse(pathProperties);
+    return pathProperties(PathProperties.parse(pathProperties));
+  }
+
+  /**
+   * Construct JsonWriteOptions with the given pathProperties.
+   */
+  public static JsonWriteOptions pathProperties(PathProperties pathProperties) {
     JsonWriteOptions o = new JsonWriteOptions();
-    o.setPathProperties(p);
+    o.setPathProperties(pathProperties);
     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

@@ -1,28 +0,0 @@
-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,31 +19,10 @@
  *     .order().desc("id")
  *     .findList();
  * 
- * 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);
+ * JsonContext json = Ebean.json();
+ *
+ *  // output as a JSON string
+ * String jsonOutput = json.toJson(list);
  * 
  * </pre>
  */

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

@@ -31,6 +31,12 @@ 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() {  
 	}
 	
@@ -51,20 +57,33 @@ 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) {
-      hc = hc * 31 + param.queryBindCount();
+      tempBindCount = param.queryBindCount();
+      bc += tempBindCount;
+      hc = hc * 31 + tempBindCount;
     }
 
     for (Map.Entry<String, Param> entry : namedParameters.entrySet()) {
+      tempBindCount = entry.getValue().queryBindCount();
+      bc += tempBindCount;
       hc = hc * 31 + entry.getKey().hashCode();
-      hc = hc * 31 + entry.getValue().queryBindCount();
+      hc = hc * 31 + tempBindCount;
     }
 
-    int bindCount = positionedParameters.size() + namedParameters.size();
-    builder.add(hc).bind(bindCount);
+    return new int[]{hc, bc};
   }
- 
+
 	/**
 	 * Return a deep copy of the BindParams.
 	 */
@@ -110,7 +129,7 @@ public class BindParams implements Serializable {
 	 * parameters ordered.
 	 */
 	public boolean requiresNamedParamsPrepare() {
-		return !namedParameters.isEmpty() && positionedParameters.isEmpty();
+		return !namedParameters.isEmpty();
 	}
 
 	/**
@@ -150,7 +169,7 @@ public class BindParams implements Serializable {
 	}
 
 	private Param getParam(String name) {
-		Param p = (Param) namedParameters.get(name);
+		Param p = namedParameters.get(name);
 		if (p == null) {
 			p = new Param();
 			namedParameters.put(name, p);
@@ -165,7 +184,7 @@ public class BindParams implements Serializable {
 				positionedParameters.add(new Param());
 			}
 		}
-		return (Param) positionedParameters.get(position - 1);
+		return positionedParameters.get(position - 1);
 	}
 
 	/**
@@ -253,7 +272,29 @@ 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
@@ -327,8 +368,6 @@ public class BindParams implements Serializable {
 
 		private Object outValue;
 
-		private int textLocation;
-
 		/**
 		 * Construct a Parameter.
 		 */
@@ -368,17 +407,8 @@ public class BindParams implements Serializable {
 		}
 
 		public boolean equals(Object o) {
-			if (o == null) {
-				return false;
-			}
-			if (o == this) {
-				return true;
-			}
-			if (o instanceof Param) {
-				return hashCode() == o.hashCode();
-			}
-			return false;
-		}
+      return o != null && (o == this || (o instanceof Param) && hashCode() == o.hashCode());
+    }
 		
 		/**
 		 * Return true if this is an In parameter that needs to be bound before
@@ -463,21 +493,6 @@ 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/HashQueryPlan.java

@@ -1,7 +1,5 @@
 package com.avaje.ebeaninternal.api;
 
-import java.util.Objects;
-
 /**
  * A hash for a query plan.
  */
@@ -26,7 +24,7 @@ public class HashQueryPlan {
   public int hashCode() {
     int hc = planHash;
     hc = hc * 31 + bindCount;
-    hc = hc * 31 + Objects.hashCode(rawSql);
+    hc = hc * 31 + (rawSql == null ? 0 : rawSql.hashCode());
     return hc;
   }
   
@@ -41,6 +39,6 @@ public class HashQueryPlan {
     HashQueryPlan e = (HashQueryPlan) obj;
     return e.planHash == planHash 
         && e.bindCount == bindCount
-        && Objects.equals(e.rawSql, rawSql);
+        &&  ((e.rawSql == rawSql) || (e.rawSql != null && e.rawSql.equals(rawSql)));
   }
 }

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

@@ -1,7 +1,5 @@
 package com.avaje.ebeaninternal.api;
 
-import java.util.Objects;
-
 /**
  * Used to build HashQueryPlan instances.
  */
@@ -33,7 +31,7 @@ public class HashQueryPlanBuilder {
    * Add an object to the hash calculation.
    */
   public HashQueryPlanBuilder add(Object object) {
-    planHash = planHash * 31 + Objects.hashCode(object);
+    planHash = planHash * 31 + (object == null ? 0 : object.hashCode());
     return this;
   }
 

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

@@ -11,6 +11,8 @@ 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

@@ -59,4 +59,7 @@ 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, int defaultQueryBatch);
+	public void executeSecondaryQueries(OrmQueryRequest<?> parentRequest);
 
 	/**
 	 * Register any secondary queries (+query or +lazy) with their

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

@@ -13,6 +13,8 @@ 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

@@ -18,12 +18,11 @@ public class LoadManyRequest extends LoadRequest {
 
   private final boolean loadCache;
 
-  public LoadManyRequest(LoadManyBuffer loadContext, int batchSize, boolean lazy,boolean onlyIds, boolean loadCache) {
-    this(loadContext, null, batchSize, lazy, onlyIds, loadCache);
+  public LoadManyRequest(LoadManyBuffer loadContext, boolean lazy, boolean onlyIds, boolean loadCache) {
+    this(loadContext, null, lazy, onlyIds, loadCache);
   }
   
-  public LoadManyRequest(LoadManyBuffer loadContext, OrmQueryRequest<?> parentRequest, int batchSize, boolean lazy,
-      boolean onlyIds, boolean loadCache) {
+  public LoadManyRequest(LoadManyBuffer loadContext, OrmQueryRequest<?> parentRequest,  boolean lazy, boolean onlyIds, boolean loadCache) {
 
     super(parentRequest, lazy);
     this.loadContext = loadContext;
@@ -69,4 +68,10 @@ public class LoadManyRequest extends LoadRequest {
     return loadCache;
   }
 
+  /**
+   * Return the batch size used for this load context.
+   */
+  public int getBatchSize() {
+    return loadContext.getBatchSize();
+  }
 }

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

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

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

@@ -53,13 +53,15 @@ 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);
-            String secondaryTableJoinPrefix = p.getSecondaryTableJoinPrefix();
-            if (secondaryTableJoinPrefix != null) {
-              addJoin(join+"."+secondaryTableJoinPrefix);
+            if (p != null) {
+              String secondaryTableJoinPrefix = p.getSecondaryTableJoinPrefix();
+              if (secondaryTableJoinPrefix != null) {
+                addJoin(join+"."+secondaryTableJoinPrefix);
+              }
             }
             addParentJoins(join);
         }

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

@@ -2,10 +2,7 @@ package com.avaje.ebeaninternal.api;
 
 import java.util.List;
 
-import com.avaje.ebean.EbeanServer;
-import com.avaje.ebean.Query;
-import com.avaje.ebean.Transaction;
-import com.avaje.ebean.TxScope;
+import com.avaje.ebean.*;
 import com.avaje.ebean.bean.BeanCollectionLoader;
 import com.avaje.ebean.bean.BeanLoader;
 import com.avaje.ebean.bean.CallStack;
@@ -63,6 +60,11 @@ 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/SpiExpressionFactory.java

@@ -1,13 +1,12 @@
 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();//FilterExprPath prefix);
-    
+  /**
+   * Create another expression factory with a given sub path.
+   */
+  public ExpressionFactory createExpressionFactory();
+
 }

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

@@ -44,9 +44,14 @@ 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();
+
+  /**
+   * Increments the parameter index and returns that value.
+   */
+  public int nextParameter();
+
+  /**
+   * Append a DB Like clause.
+   */
+  public void appendLike();
 }

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

@@ -5,6 +5,7 @@ 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;
@@ -26,7 +27,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;
@@ -79,7 +80,20 @@ 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.
@@ -532,12 +546,24 @@ 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 uses DISTINCT.
+     * 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.
      */
     public boolean isDistinct();
-
+    
     /**
      * Set default select clauses where none have been explicitly defined.
      */

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

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