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

Add support for java.time types, tidy up ScalarTypes

README.md

@@ -7,6 +7,6 @@ Maven Dependency
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm</artifactId>
-      <version>4.1.8</version>
+      <version>4.3.0</version>
     </dependency>
     

pom.xml

@@ -9,7 +9,7 @@
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>4.2.0</version>
+  <version>4.3.0</version>
   <packaging>jar</packaging>
 
   <name>avaje-ebeanorm</name>
@@ -182,7 +182,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.1</version>
+        <version>3.2</version>
         <configuration>
           <source>1.6</source>
           <target>1.6</target>
@@ -233,7 +233,6 @@
           </archive>
         </configuration>
       </plugin>
-<!--
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-javadoc-plugin</artifactId>
@@ -241,7 +240,8 @@
         <configuration>
           <doctitle>Ebean 4</doctitle>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
-          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames>
+         <!-- <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames> -->
+          <additionalparam>-Xdoclint:none</additionalparam>
         </configuration>
         <executions>
           <execution>
@@ -253,7 +253,6 @@
           </execution>
         </executions>
       </plugin>
--->    
     </plugins>
 
   </build>

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

@@ -63,34 +63,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 +102,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);
@@ -242,12 +248,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'
@@ -281,7 +287,7 @@ 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);
   }
 
@@ -323,22 +329,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
@@ -372,6 +380,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.
    */
@@ -397,17 +418,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();
@@ -440,15 +463,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
@@ -485,16 +508,16 @@ public final class Ebean {
    * An unmodified bean that is saved or updated is normally skipped and this marks the bean as
    * dirty so that it is not skipped.
    * 
-   * <pre class="code">
+   * <pre>{@code
    * 
-   * Customer customer = Ebean.find(Customer, id);
+   *   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);
+   *   // mark the bean as dirty so that a save() or update() will
+   *   // increment the version property
+   *   Ebean.markAsDirty(customer);
+   *   Ebean.save(customer);
    * 
-   * </pre>
+   * }</pre>
    */
   public static void markAsDirty(Object bean) throws OptimisticLockException {
     serverMgr.getPrimaryServer().markAsDirty(bean);
@@ -523,15 +546,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)
@@ -665,12 +688,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.
@@ -687,16 +712,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
@@ -726,23 +753,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
@@ -756,41 +783,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
@@ -802,7 +831,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
@@ -860,15 +889,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);
@@ -883,12 +914,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
@@ -911,14 +944,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
@@ -943,40 +977,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) {
 
@@ -995,21 +1032,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) {
 
@@ -1040,38 +1078,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
@@ -1131,19 +1168,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
@@ -1164,19 +1203,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)
@@ -1192,18 +1233,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);
@@ -1216,20 +1258,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);
@@ -1242,18 +1286,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) {
@@ -1271,22 +1317,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);
@@ -1307,7 +1355,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.

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,7 +435,7 @@ 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
@@ -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);
 
@@ -846,7 +879,7 @@ public interface EbeanServer {
    * An unmodified bean that is saved or updated is normally skipped and this marks the bean as
    * dirty so that it is not skipped.
    * 
-   * <pre class="code">
+   * <pre>{@code
    * 
    * Customer customer = ebeanServer.find(Customer, id);
    * 
@@ -855,7 +888,7 @@ public interface EbeanServer {
    * ebeanServer.markAsDirty(customer);
    * ebeanServer.save(customer);
    * 
-   * </pre>   
+   * }</pre>
    */
   public void markAsDirty(Object bean);
   
@@ -882,15 +915,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)

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

@@ -102,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);
 
@@ -245,24 +261,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#fetch(String)
-   * @deprecated
-   */
-  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#fetch(String,String)
-   * @deprecated
-   */
-  public Query<T> join(String assocProperty, String assocProperties);
-
   /**
    * Set the first row to fetch.
    * 

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

@@ -328,6 +328,37 @@ public abstract class Model {
       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>

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

@@ -301,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.
    */
@@ -325,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).
    */
@@ -446,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.

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/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/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.
    */

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

@@ -38,12 +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;
+  protected String propertyName;
 
   protected ModifyHolder<E> modifyHolder;
 
@@ -62,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;
   }
 
   /**
@@ -85,10 +83,6 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     return propertyName;
   }
 
-  public int getLoaderIndex() {
-    return loaderIndex;
-  }
-
   public ExpressionList<?> getFilterMany() {
     return filterMany;
   }

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.
    */

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(50);
+    StringBuilder sb = new StringBuilder(50);
     sb.append("BeanMap ");
     if (isReadOnly()) {
       sb.append("readOnly ");

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());
   }

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

@@ -1,27 +1,22 @@
 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;
+
 /**
  * The configuration used for creating a EbeanServer.
  * <p>
@@ -121,6 +116,11 @@ public class ServerConfig {
    */
   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.  
    */
@@ -217,10 +217,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>();
@@ -241,12 +241,20 @@ public class ServerConfig {
   private boolean collectQueryStatsByNode;
 
   private boolean collectQueryOrigins;
-  
-  private JsonFactory jsonFactory;
 
   /**
-   * 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;
+
+  /**
+   * Construct a Server Configuration for programmatically creating an EbeanServer.
    */
   public ServerConfig() {
 
@@ -270,6 +278,20 @@ public class ServerConfig {
     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.
    */
@@ -859,6 +881,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.
    */
@@ -1195,14 +1254,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;
   }
 
@@ -1241,10 +1300,39 @@ public class ServerConfig {
    * BeanPersistListener instances one at a time.
    * </p>
    */
-  public void setPersistListeners(List<BeanPersistListener<?>> persistListeners) {
+  public void setPersistListeners(List<BeanPersistListener> persistListeners) {
     this.persistListeners = persistListeners;
   }
 
+  /**
+   * Return the default PersistenceContextScope to be used if one is not explicitly set on a query.
+   * <p/>
+   * The PersistenceContextScope can specified on each query via {@link com.avaje.ebean
+   * .Query#setPersistenceContextScope(com.avaje.ebean.PersistenceContextScope)}. If it
+   * is not set on the query this default scope is used.
+   *
+   * @see com.avaje.ebean.Query#setPersistenceContextScope(com.avaje.ebean.PersistenceContextScope)
+   */
+  public PersistenceContextScope getPersistenceContextScope() {
+    // if somehow null return TRANSACTION scope
+    return persistenceContextScope == null ? PersistenceContextScope.TRANSACTION : persistenceContextScope;
+  }
+
+  /**
+   * Set the PersistenceContext scope to be used if one is not explicitly set on a query.
+   * <p/>
+   * This defaults to {@link PersistenceContextScope#TRANSACTION}.
+   * <p/>
+   * The PersistenceContextScope can specified on each query via {@link com.avaje.ebean
+   * .Query#setPersistenceContextScope(com.avaje.ebean.PersistenceContextScope)}. If it
+   * is not set on the query this scope is used.
+   *
+   * @see com.avaje.ebean.Query#setPersistenceContextScope(com.avaje.ebean.PersistenceContextScope)
+   */
+  public void setPersistenceContextScope(PersistenceContextScope persistenceContextScope) {
+    this.persistenceContextScope = persistenceContextScope;
+  }
+
   /**
    * Load the settings from the ebean.properties file.
    */
@@ -1299,8 +1387,6 @@ public class ServerConfig {
 
   /**
    * This is broken out for the same reason as above - preserve existing behaviour but let it be overridden.
-   *
-   * @param p
    */
   protected void loadAutofetchConfig(PropertySource p) {
     autofetchConfig.loadSettings(p);
@@ -1358,16 +1444,26 @@ public class ServerConfig {
     int batchSize = p.getInt("batch.size", 20);
     persistBatchSize = p.getInt("persistBatchSize", batchSize);
 
+    persistenceContextScope = PersistenceContextScope.valueOf(p.get("persistenceContextScope","TRANSACTION"));
+
     dataSourceJndiName = p.get("dataSourceJndiName", null);
     databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", 20);
     databaseBooleanTrue = p.get("databaseBooleanTrue", null);
     databaseBooleanFalse = p.get("databaseBooleanFalse", null);
     databasePlatformName = p.get("databasePlatformName", null);
     uuidStoreAsBinary = p.getBoolean("uuidStoreAsBinary", false);
+    localTimeWithNanos = p.getBoolean("localTimeWithNanos", false);
 
     lazyLoadBatchSize = p.getInt("lazyLoadBatchSize", 1);
     queryBatchSize = p.getInt("queryBatchSize", DEFAULT_QUERY_BATCH_SIZE);
 
+    String jsonDateTimeFormat = p.get("jsonDateTime", null);
+    if (jsonDateTimeFormat != null) {
+      jsonDateTime = JsonConfig.DateTime.valueOf(jsonDateTimeFormat);
+    } else {
+      jsonDateTime = JsonConfig.DateTime.MILLIS;
+    }
+
     ddlGenerate = p.getBoolean("ddl.generate", false);
     ddlRun = p.getBoolean("ddl.run", false);
 

src/main/java/com/avaje/ebean/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/json/JsonContext.java

@@ -1,14 +1,13 @@
 package com.avaje.ebean.text.json;
 
-import java.io.IOException;
+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;
 import java.util.List;
 
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonParser;
-
 /**
  * Converts objects to and from JSON format.
  */
@@ -16,70 +15,82 @@ public interface JsonContext {
 
   /**
    * Convert json string input into a Bean of a specific type.
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public <T> T toBean(Class<T> rootType, String json) throws IOException;
+  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) throws IOException;
+  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) throws IOException;
+  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 IOException 
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public <T> List<T> toList(Class<T> rootType, Reader json) throws IOException;
+  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) throws IOException;
+  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) throws IOException;
+  public Object toObject(Type genericType, String json) throws JsonIOException;
 
   /**
    * Write the bean or collection in JSON format to the writer with default
    * options.
-   * 
-   * @param value
-   *          the bean or collection of beans to write
-   * @param writer
-   *          used to write the json output to
+   *
+   * @param value  the bean or collection of beans to write
+   * @param writer used to write the json output to
+   * @throws JsonIOException When IOException occurs
    */
-  public void toJson(Object value, Writer writer) throws IOException;
+  public void toJson(Object value, Writer writer) throws JsonIOException;
 
   /**
    * With additional options to specify JsonValueAdapter and
    * JsonWriteBeanVisitor's.
-   * 
-   * @param value
-   *          the bean or collection of beans to write
-   * @param writer
-   *          used to write the json output to
-   * @param options
-   *          additional options to control the JSON output
+   *
+   * @param value   the bean or collection of beans to write
+   * @param writer  used to write the json output to
+   * @param options additional options to control the JSON output
+   * @throws JsonIOException When IOException occurs
    */
-  public void toJson(Object value, Writer writer, JsonWriteOptions options) throws IOException;
+  public void toJson(Object value, Writer writer, JsonWriteOptions options) throws JsonIOException;
 
   /**
    * Convert a bean or collection to json string using default options.
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public String toJson(Object value) throws IOException;
+  public String toJson(Object value) throws JsonIOException;
 
   /**
    * Convert a bean or collection to json string.
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public String toJson(Object value, JsonWriteOptions options) throws IOException;
+  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
@@ -89,11 +100,15 @@ public interface JsonContext {
 
   /**
    * Create and return a new JsonGenerator for the given writer.
+   *
+   * @throws JsonIOException When IOException occurs
    */
-  public JsonGenerator createGenerator(Writer writer) throws IOException;
-  
+  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 IOException;
+  public JsonParser createParser(Reader reader) throws JsonIOException;
 }

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

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);
 }

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

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

src/main/java/com/avaje/ebeaninternal/server/cache/DefaultServerCacheManager.java

@@ -40,10 +40,13 @@ public class DefaultServerCacheManager implements ServerCacheManager {
 		cacheFactory.init(server);
 		this.ebeanServer = (SpiEbeanServer)server;
 	}
-	
-    public void setCaching(Class<?> beanType, boolean useCache) {
-		ebeanServer.getBeanDescriptor(beanType).getCacheOptions().setUseCache(useCache);
-    }
+
+  /**
+   * Set bean caching on or off for a given bean type.
+   */
+  public void setCaching(Class<?> beanType, boolean useCache) {
+    ebeanServer.getBeanDescriptor(beanType).setUseCache(useCache);
+  }
 
 	/**
 	 * Clear both the bean cache and the query cache for a 

src/main/java/com/avaje/ebeaninternal/server/core/BootupClasses.java

@@ -56,7 +56,7 @@ public class BootupClasses implements ClassPathSearchMatcher {
     private ArrayList<ServerConfigStartup> serverConfigStartupInstances = new ArrayList<ServerConfigStartup>();
 
     private List<BeanPersistController> persistControllerInstances = new ArrayList<BeanPersistController>();
-    private List<BeanPersistListener<?>> persistListenerInstances = new ArrayList<BeanPersistListener<?>>();
+    private List<BeanPersistListener> persistListenerInstances = new ArrayList<BeanPersistListener>();
     private List<BeanQueryAdapter> queryAdapterInstances = new ArrayList<BeanQueryAdapter>();
     private List<TransactionEventListener> transactionEventListenerInstances = new ArrayList<TransactionEventListener>();
 
@@ -145,9 +145,9 @@ public class BootupClasses implements ClassPathSearchMatcher {
         }
     }
 
-    public void addPersistListeners(List<BeanPersistListener<?>> listenerInstances) {
+    public void addPersistListeners(List<BeanPersistListener> listenerInstances) {
         if (listenerInstances != null) {
-            for (BeanPersistListener<?> l : listenerInstances) {
+            for (BeanPersistListener l : listenerInstances) {
                 this.persistListenerInstances.add(l);
         		// don't automatically instantiate
 	            this.beanListenerList.remove(l.getClass());
@@ -181,12 +181,12 @@ public class BootupClasses implements ClassPathSearchMatcher {
         return queryAdapterInstances;
     }
 
-    public List<BeanPersistListener<?>> getBeanPersistListeners() {
+    public List<BeanPersistListener> getBeanPersistListeners() {
         // add class registered BeanPersistController to the
         // already created instances
         for (Class<?> cls : beanListenerList) {
             try {
-                BeanPersistListener<?> newInstance = (BeanPersistListener<?>) cls.newInstance();
+                BeanPersistListener newInstance = (BeanPersistListener) cls.newInstance();
                 persistListenerInstances.add(newInstance);
             } catch (Exception e) {
                 String msg = "Error creating BeanPersistController " + cls;

src/main/java/com/avaje/ebeaninternal/server/core/DefaultBackgroundExecutor.java

@@ -8,8 +8,6 @@ import com.avaje.ebeaninternal.server.lib.DaemonThreadPool;
 
 /**
  * The default implementation of the BackgroundExecutor.
- * 
- * @author rbygrave
  */
 public class DefaultBackgroundExecutor implements SpiBackgroundExecutor {
 
@@ -20,7 +18,7 @@ public class DefaultBackgroundExecutor implements SpiBackgroundExecutor {
 	/**
 	 * Construct the default implementation of BackgroundExecutor.
 	 * 
-	 * @param mainPoolSize
+	 * @param corePoolSize
 	 *            the core size of the thread pool.
 	 * @param keepAliveSecs
 	 *            the time in seconds idle threads are keep alive

src/main/java/com/avaje/ebeaninternal/server/core/DefaultBeanLoader.java

@@ -40,7 +40,7 @@ public class DefaultBeanLoader {
     this.server = server;
   }
 
-	  /**
+  /**
    * Return a batch size that might be less than the requestedBatchSize.
    * <p>
    * This means we can have large and variable requestedBatchSizes.
@@ -51,7 +51,7 @@ public class DefaultBeanLoader {
    * </p>
    */
   private int getBatchSize(int batchSize) {
-    
+
     if (batchSize == 1) {
       // there is only one bean/collection to load
       return 1;
@@ -74,10 +74,10 @@ public class DefaultBeanLoader {
     }
     return batchSize;
   }
-	
-	public void refreshMany(EntityBean parentBean, String propertyName) {
-		refreshMany(parentBean, propertyName, null);
-	}
+
+  public void refreshMany(EntityBean parentBean, String propertyName) {
+    refreshMany(parentBean, propertyName, null);
+  }
 
   public void loadMany(LoadManyRequest loadRequest) {
 
@@ -113,7 +113,7 @@ public class DefaultBeanLoader {
     if (orderBy != null) {
       query.orderBy(orderBy);
     }
-    
+
     String extraWhere = many.getExtraWhere();
     if (extraWhere != null) {
       // replace special ${ta} placeholder with the base table alias 
@@ -121,7 +121,7 @@ public class DefaultBeanLoader {
       String ew = StringHelper.replaceString(extraWhere, "${ta}", "t0");
       query.where().raw(ew);
     }
-    
+
     query.setLazyLoadForParents(idList, many);
     many.addWhereParentIdIn(query, idList);
 
@@ -130,6 +130,11 @@ public class DefaultBeanLoader {
     String mode = loadRequest.isLazy() ? "+lazy" : "+query";
     query.setLoadDescription(mode, loadRequest.getDescription());
 
+    if (loadRequest.isLazy()) {
+      // cascade the batch size (if set) for further lazy loading
+      query.setLazyLoadBatchSize(loadRequest.getBatchSize());
+    }
+
     // potentially changes the joins and selected properties
     ctx.configureQuery(query);
 
@@ -153,7 +158,7 @@ public class DefaultBeanLoader {
         desc.cacheManyPropPut(many, bc, parentId);
       }
     }
-    
+
     // log the query (for testing secondary queries)
     loadRequest.logSecondaryQuery(query);
   }
@@ -163,18 +168,17 @@ public class DefaultBeanLoader {
     EntityBean parentBean = bc.getOwnerBean();
     String propertyName = bc.getPropertyName();
 
-    //ObjectGraphNode node = ctx == null ? null : ctx.getObjectGraphNode();
-
     loadManyInternal(parentBean, propertyName, null, false, null, onlyIds);
   }
 
-	public void refreshMany(EntityBean parentBean, String propertyName, Transaction t) {
-		loadManyInternal(parentBean, propertyName, t, true, null, false);
-	}
+  public void refreshMany(EntityBean parentBean, String propertyName, Transaction t) {
+    loadManyInternal(parentBean, propertyName, t, true, null, false);
+  }
 
-	private void loadManyInternal(EntityBean parentBean, String propertyName, Transaction t, boolean refresh, ObjectGraphNode node, boolean onlyIds) {
+  private void loadManyInternal(EntityBean parentBean, String propertyName, Transaction t, boolean refresh,
+                                ObjectGraphNode node, boolean onlyIds) {
 
-    EntityBeanIntercept ebi = ((EntityBean) parentBean)._ebean_getIntercept();
+    EntityBeanIntercept ebi = parentBean._ebean_getIntercept();
     PersistenceContext pc = ebi.getPersistenceContext();
 
     BeanDescriptor<?> parentDesc = server.getBeanDescriptor(parentBean.getClass());
@@ -182,7 +186,7 @@ public class DefaultBeanLoader {
 
     BeanCollection<?> beanCollection = null;
     ExpressionList<?> filterMany = null;
-    
+
     Object currentValue = many.getValue(parentBean);
     if (currentValue instanceof BeanCollection<?>) {
       beanCollection = (BeanCollection<?>) currentValue;
@@ -199,7 +203,7 @@ public class DefaultBeanLoader {
     boolean useManyIdCache = beanCollection != null && parentDesc.isManyPropCaching();
     if (useManyIdCache) {
       Boolean readOnly = null;
-      if (ebi != null && ebi.isReadOnly()) {
+      if (ebi.isReadOnly()) {
         readOnly = Boolean.TRUE;
       }
       if (parentDesc.cacheManyPropLoad(many, beanCollection, parentId, readOnly)) {
@@ -211,7 +215,7 @@ public class DefaultBeanLoader {
 
     if (refresh) {
       // populate a new collection
-      Object emptyCollection = many.createEmpty(false);
+      BeanCollection<?> emptyCollection = many.createEmpty(parentBean);
       many.setValue(parentBean, emptyCollection);
       query.setLoadDescription("+refresh", null);
     } else {
@@ -241,10 +245,8 @@ public class DefaultBeanLoader {
     query.setLazyLoadManyPath(many.getName());
     query.setPersistenceContext(pc);
 
-    if (ebi != null) {
-      if (ebi.isReadOnly()) {
-        query.setReadOnly(true);
-      }
+    if (ebi.isReadOnly()) {
+      query.setReadOnly(true);
     }
 
     server.findUnique(query, t);
@@ -315,6 +317,11 @@ public class DefaultBeanLoader {
     String mode = loadRequest.isLazy() ? "+lazy" : "+query";
     query.setLoadDescription(mode, loadRequest.getDescription());
 
+    if (loadRequest.isLazy()) {
+      // cascade the batch size (if set) for further lazy loading
+      query.setLazyLoadBatchSize(loadRequest.getBatchSize());
+    }
+
     ctx.configureQuery(query, loadRequest.getLazyLoadProperty());
 
     // make sure the query doesn't use the cache
@@ -329,7 +336,7 @@ public class DefaultBeanLoader {
 
     if (loadRequest.isLoadCache()) {
       for (int i = 0; i < list.size(); i++) {
-        desc.cacheBeanPutData((EntityBean)list.get(i));
+        desc.cacheBeanPutData((EntityBean) list.get(i));
       }
     }
 
@@ -338,48 +345,50 @@ public class DefaultBeanLoader {
       // necessary but allow processing to continue until it is accessed by client code
       ebis[i].checkLazyLoadFailure();
     }
-    
+
     // log the query (for testing secondary queries)
     loadRequest.logSecondaryQuery(query);
   }
 
-	public void refresh(EntityBean bean) {
-		refreshBeanInternal(bean, SpiQuery.Mode.REFRESH_BEAN, -1);
-	}
-	
-	public void loadBean(EntityBeanIntercept ebi) {
-		refreshBeanInternal(ebi.getOwner(), SpiQuery.Mode.LAZYLOAD_BEAN, -1);
-	}
+  public void refresh(EntityBean bean) {
+    refreshBeanInternal(bean, SpiQuery.Mode.REFRESH_BEAN, -1);
+  }
+
+  public void loadBean(EntityBeanIntercept ebi) {
+    refreshBeanInternal(ebi.getOwner(), SpiQuery.Mode.LAZYLOAD_BEAN, -1);
+  }
 
   private void refreshBeanInternal(EntityBean bean, SpiQuery.Mode mode, int embeddedOwnerIndex) {
 
-    EntityBeanIntercept ebi = ((EntityBean) bean)._ebean_getIntercept();;
+    EntityBeanIntercept ebi = bean._ebean_getIntercept();
     PersistenceContext pc = ebi.getPersistenceContext();
+    if (Mode.REFRESH_BEAN == mode) {
+      // need a new PersistenceContext for REFRESH
+      pc = null;
+    }
 
     BeanDescriptor<?> desc = server.getBeanDescriptor(bean.getClass());
     if (EntityType.EMBEDDED == desc.getEntityType()) {
       // lazy loading on an embedded bean property
-      EntityBean embeddedOwner = (EntityBean)ebi.getEmbeddedOwner();
+      EntityBean embeddedOwner = (EntityBean) ebi.getEmbeddedOwner();
       int ownerIndex = ebi.getEmbeddedOwnerIndex();
 
       refreshBeanInternal(embeddedOwner, mode, ownerIndex);
     }
-    
+
     Object id = desc.getId(bean);
 
     if (pc == null) {
       // a reference with no existing persistenceContext
       pc = new DefaultPersistenceContext();
       pc.put(id, bean);
-      if (ebi != null) {
-        ebi.setPersistenceContext(pc);
-      }
+      ebi.setPersistenceContext(pc);
     }
 
     if (embeddedOwnerIndex == -1) {
       if (SpiQuery.Mode.LAZYLOAD_BEAN.equals(mode) && desc.isBeanCaching()) {
         // lazy loading and the bean cache is active 
-        if (desc.cacheBeanLoad((EntityBean)bean, ebi, id)) {
+        if (desc.cacheBeanLoad(bean, ebi, id)) {
           return;
         }
       }
@@ -389,15 +398,13 @@ public class DefaultBeanLoader {
     }
 
     SpiQuery<?> query = (SpiQuery<?>) server.createQuery(desc.getBeanType());
-    if (ebi != null) {
-      query.setLazyLoadProperty(ebi.getLazyLoadProperty());
-    }
+    query.setLazyLoadProperty(ebi.getLazyLoadProperty());
 
     if (embeddedOwnerIndex > -1) {
       String embeddedBeanPropertyName = ebi.getProperty(embeddedOwnerIndex);
-      query.select("id,"+embeddedBeanPropertyName);
+      query.select("id," + embeddedBeanPropertyName);
     }
-    
+
     // don't collect autoFetch usage profiling information
     // as we just copy the data out of these fetched beans
     // and put the data into the original bean
@@ -415,7 +422,7 @@ public class DefaultBeanLoader {
     if (ebi.isReadOnly()) {
       query.setReadOnly(true);
     }
-    
+
     if (SpiQuery.Mode.REFRESH_BEAN.equals(mode)) {
       // explicitly state to load all properties on REFRESH.
       // Lobs default to fetch lazy so this forces lobs to be 
@@ -429,5 +436,7 @@ public class DefaultBeanLoader {
       throw new EntityNotFoundException(msg);
     }
 
+    desc.resetManyProperties(dbBean);
+
   }
 }

src/main/java/com/avaje/ebeaninternal/server/core/DefaultServer.java

@@ -17,36 +17,10 @@ import javax.management.MBeanServer;
 import javax.management.ObjectName;
 import javax.persistence.PersistenceException;
 
+import com.avaje.ebean.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.avaje.ebean.AdminAutofetch;
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.BeanState;
-import com.avaje.ebean.CallableSql;
-import com.avaje.ebean.Ebean;
-import com.avaje.ebean.ExpressionFactory;
-import com.avaje.ebean.Filter;
-import com.avaje.ebean.FutureIds;
-import com.avaje.ebean.FutureList;
-import com.avaje.ebean.FutureRowCount;
-import com.avaje.ebean.PagedList;
-import com.avaje.ebean.PagingList;
-import com.avaje.ebean.Query;
-import com.avaje.ebean.QueryIterator;
-import com.avaje.ebean.QueryResultVisitor;
-import com.avaje.ebean.SqlFutureList;
-import com.avaje.ebean.SqlQuery;
-import com.avaje.ebean.SqlRow;
-import com.avaje.ebean.SqlUpdate;
-import com.avaje.ebean.Transaction;
-import com.avaje.ebean.TxCallable;
-import com.avaje.ebean.TxIsolation;
-import com.avaje.ebean.TxRunnable;
-import com.avaje.ebean.TxScope;
-import com.avaje.ebean.TxType;
-import com.avaje.ebean.Update;
-import com.avaje.ebean.ValuePair;
 import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.CallStack;
 import com.avaje.ebean.bean.EntityBean;
@@ -163,7 +137,6 @@ public final class DefaultServer implements SpiEbeanServer {
 
   private final CQueryEngine cqueryEngine;
 
-  //@Deprecated
   private DdlGenerator ddlGenerator;
 
   private final ExpressionFactory expressionFactory;
@@ -183,6 +156,11 @@ public final class DefaultServer implements SpiEbeanServer {
    */
   private String mbeanName;
 
+  /**
+   * The default PersistenceContextScope used if it is not explicitly set on a query.
+   */
+  private final PersistenceContextScope defaultPersistenceContextScope;
+
   /**
    * The MBeanServer Ebean is registered with.
    */
@@ -241,6 +219,7 @@ public final class DefaultServer implements SpiEbeanServer {
     this.cqueryEngine = config.getCQueryEngine();
     this.expressionFactory = config.getExpressionFactory();
     this.encryptKeyManager = serverConfig.getEncryptKeyManager();
+    this.defaultPersistenceContextScope = serverConfig.getPersistenceContextScope();
 
     this.beanDescriptorManager = config.getBeanDescriptorManager();
     beanDescriptorManager.setEbeanServer(this);
@@ -273,17 +252,14 @@ public final class DefaultServer implements SpiEbeanServer {
     
     List<SpiEbeanPlugin> spiPlugins = new ArrayList<SpiEbeanPlugin>();
 
-    final Iterator<SpiEbeanPlugin> plugins = ServiceLoader.load(SpiEbeanPlugin.class).iterator();
-
-    while (plugins.hasNext()) {
-      SpiEbeanPlugin plugin = plugins.next();
+    for (SpiEbeanPlugin plugin : ServiceLoader.load(SpiEbeanPlugin.class)) {
       spiPlugins.add(plugin);
       plugin.setup(this, this.getDatabasePlatform(), config.getServerConfig());
 
       if (plugin instanceof DdlGenerator) {
         // backwards compatible
-        ddlGenerator = (DdlGenerator)plugin;
-      } 
+        ddlGenerator = (DdlGenerator) plugin;
+      }
     }
     
     if (ddlGenerator == null) {
@@ -677,6 +653,15 @@ public final class DefaultServer implements SpiEbeanServer {
     return (T) ref;
   }
 
+  @Override
+  public void register(TransactionCallback transactionCallback) {
+    Transaction transaction = currentTransaction();
+    if (transaction == null) {
+      throw new PersistenceException("Not currently active transaction when trying to register transactionCallback");
+    }
+    transaction.register(transactionCallback);
+  }
+
   /**
    * Creates a new Transaction that is NOT stored in TransactionThreadLocal. Use
    * this when you want a thread to have a second independent transaction.
@@ -1160,8 +1145,8 @@ public final class DefaultServer implements SpiEbeanServer {
       t = getCurrentServerTransaction();
     }
     PersistenceContext context = null;
-    if (t != null) {
-      // first look in the persistence context
+    if (t != null && useTransactionPersistenceContext(query)) {
+      // first look in the transaction scoped persistence context
       context = t.getPersistenceContext();
       if (context != null) {
         WithOption o = context.getWithOption(beanDescriptor.getBeanType(), query.getId());
@@ -1184,7 +1169,22 @@ public final class DefaultServer implements SpiEbeanServer {
     // Hit the L2 bean cache
     return beanDescriptor.cacheBeanGet(query, context);
   }
-    
+
+  /**
+   * Return true if transactions PersistenceContext should be used.
+   */
+  private <T> boolean useTransactionPersistenceContext(SpiQuery<T> query) {
+    return PersistenceContextScope.TRANSACTION.equals(getPersistenceContextScope(query));
+  }
+
+  /**
+   * Return the PersistenceContextScope to use defined at query or server level.
+   */
+  public PersistenceContextScope getPersistenceContextScope(SpiQuery<?> query) {
+    PersistenceContextScope scope = query.getPersistenceContextScope();
+    return (scope != null) ? scope : defaultPersistenceContextScope;
+  }
+
   @SuppressWarnings("unchecked")
   private <T> T findId(Query<T> query, Transaction t) {
 
@@ -1413,12 +1413,27 @@ public final class DefaultServer implements SpiEbeanServer {
 
     SpiOrmQueryRequest<T> request = createQueryRequest(Type.LIST, query, t);
 
-    try {
-      request.initTransIfRequired();
-      request.findVisit(visitor);
-    } finally {
-      // do nothing - findVisit garuntee's cleanup of the transaction if required
-    }
+    request.initTransIfRequired();
+    request.findVisit(visitor);
+    // no try finally - findVisit guarantee's cleanup of the transaction if required
+  }
+
+  public <T> void findEach(Query<T> query, QueryEachConsumer<T> consumer, Transaction t) {
+
+    SpiOrmQueryRequest<T> request = createQueryRequest(Type.LIST, query, t);
+
+    request.initTransIfRequired();
+    request.findEach(consumer);
+    // no try finally - findVisit guarantee's cleanup of the transaction if required
+  }
+
+  public <T> void findEachWhile(Query<T> query, QueryEachWhileConsumer<T> consumer, Transaction t) {
+
+    SpiOrmQueryRequest<T> request = createQueryRequest(Type.LIST, query, t);
+
+    request.initTransIfRequired();
+    request.findEachWhile(consumer);
+    // no try finally - findVisit guarantee's cleanup of the transaction if required
   }
 
   public <T> QueryIterator<T> findIterate(Query<T> query, Transaction t) {
@@ -1542,7 +1557,7 @@ public final class DefaultServer implements SpiEbeanServer {
   
   @Override
   public void markAsDirty(Object bean) {
-    if (bean instanceof EntityBean == false) {
+    if (!(bean instanceof EntityBean)) {
       throw new IllegalArgumentException("This bean is not an EntityBean?");
     }
     // mark the bean as dirty (so that an update will not get skipped)
@@ -1650,7 +1665,7 @@ public final class DefaultServer implements SpiEbeanServer {
     if (bean == null) {
       throw new IllegalArgumentException(Message.msg("bean.isnull"));
     }
-    if (bean instanceof EntityBean == false) {
+    if (!(bean instanceof EntityBean)) {
       throw new IllegalArgumentException("Was expecting an EntityBean but got a "+bean.getClass());
     }
     return (EntityBean)bean;
@@ -1959,10 +1974,7 @@ public final class DefaultServer implements SpiEbeanServer {
   public boolean isSupportedType(java.lang.reflect.Type genericType) {
 
     TypeInfo typeInfo = ParamTypeHelper.getTypeInfo(genericType);
-    if (typeInfo == null) {
-      return false;
-    }
-    return getBeanDescriptor(typeInfo.getBeanType()) != null;
+    return typeInfo != null && getBeanDescriptor(typeInfo.getBeanType()) != null;
   }
 
   public Object getBeanId(Object bean) {

src/main/java/com/avaje/ebeaninternal/server/core/DefaultSqlUpdate.java

@@ -93,6 +93,11 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
 	 */
 	private final String sql;
 
+  /**
+   * The actual sql with named parameters converted.
+   */
+  private String generatedSql;
+
 	/**
 	 * Some descriptive text that can be put into the transaction log.
 	 */
@@ -170,7 +175,16 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
 		return this;
 	}
 
-	public String getSql() {
+  public String getGeneratedSql() {
+    return generatedSql;
+  }
+
+  @Override
+  public void setGeneratedSql(String generatedSql) {
+    this.generatedSql = generatedSql;
+  }
+
+  public String getSql() {
 		return sql;
 	}
 

src/main/java/com/avaje/ebeaninternal/server/core/OrmQueryRequest.java

@@ -6,9 +6,7 @@ import java.util.Set;
 
 import javax.persistence.PersistenceException;
 
-import com.avaje.ebean.QueryIterator;
-import com.avaje.ebean.QueryResultVisitor;
-import com.avaje.ebean.RawSql;
+import com.avaje.ebean.*;
 import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.PersistenceContext;
 import com.avaje.ebean.event.BeanFinder;
@@ -55,7 +53,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRe
   private HashQuery cacheKey;
 
   private HashQueryPlan queryPlanHash;
-  
+
   /**
    * Create the InternalQueryRequest.
    */
@@ -71,7 +69,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRe
     this.readOnly = query.isReadOnly();
   }
 
-  
+
   /**
    * Return the database platform like clause.
    */
@@ -80,8 +78,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRe
     return ebeanServer.getDatabasePlatform().getLikeClause();
   }
 
-  public void executeSecondaryQueries(int defaultQueryBatch) {
-    loadContext.executeSecondaryQueries(this, defaultQueryBatch);
+  public void executeSecondaryQueries() {
+    loadContext.executeSecondaryQueries(this);
   }
 
   /**
@@ -185,18 +183,21 @@ public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRe
     persistenceContext = new DefaultPersistenceContext();
     loadContext.setPersistenceContext(persistenceContext);
   }
-  
+
   /**
    * Get the TransactionContext either explicitly set on the query or
    * transaction scoped.
    */
   private PersistenceContext getPersistenceContext(SpiQuery<?> query, SpiTransaction t) {
 
+    // check if there is already a persistence context set which is the case
+    // when lazy loading or query joins are executed
     PersistenceContext ctx = query.getPersistenceContext();
-    if (ctx == null) {
-      ctx = t.getPersistenceContext();
-    }
-    return ctx;
+    if (ctx != null) return ctx;
+
+    // determine the scope (from the query and then server)
+    PersistenceContextScope scope = ebeanServer.getPersistenceContextScope(query);
+    return (scope == PersistenceContextScope.QUERY) ? new DefaultPersistenceContext() :  t.getPersistenceContext();
   }
 
   /**
@@ -234,6 +235,30 @@ public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRe
     return idList.getIdList();
   }
 
+  public void findEach(QueryEachConsumer<T> consumer) {
+    QueryIterator<T> it = queryEngine.findIterate(this);
+    try {
+      while (it.hasNext()) {
+        consumer.accept(it.next());
+      }
+    } finally {
+      it.close();
+    }
+  }
+
+  public void findEachWhile(QueryEachWhileConsumer<T> consumer) {
+    QueryIterator<T> it = queryEngine.findIterate(this);
+    try {
+      while (it.hasNext()) {
+        if (!consumer.accept(it.next())) {
+          break;
+        }
+      }
+    } finally {
+      it.close();
+    }
+  }
+
   public void findVisit(QueryResultVisitor<T> visitor) {
     QueryIterator<T> it = queryEngine.findIterate(this);
     try {
@@ -379,4 +404,12 @@ public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRe
     return query.isLogSecondaryQuery();
   }
 
+  /**
+   * Return the batch size for lazy loading on this bean query request.
+   */
+  public int getLazyLoadBatchSize() {
+
+    int batchSize = query.getLazyLoadBatchSize();
+    return (batchSize > 0) ? batchSize : ebeanServer.getLazyLoadBatchSize();
+  }
 }

src/main/java/com/avaje/ebeaninternal/server/core/PersistRequestBean.java

@@ -38,7 +38,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
   private final BeanDescriptor<T> beanDescriptor;
 
-  private final BeanPersistListener<T> beanPersistListener;
+  private final BeanPersistListener beanPersistListener;
 
   /**
    * For per post insert update delete control.
@@ -91,6 +91,12 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   private List<BeanPropertyAssocMany<?>> updatedManys;
 
+  /**
+   * Need to get and store the updated properties because the persist listener is notified
+   * later on a different thread and the bean has been reset at that point.
+   */
+  private Set<String> updatedProperties;
+
   public PersistRequestBean(SpiEbeanServer server, T bean, Object parentBean, BeanManager<T> mgr, SpiTransaction t,
       PersistExecute persistExecute, PersistRequest.Type type, boolean saveRecurse) {
 
@@ -188,7 +194,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
         return beanPersistListener.inserted(bean);
 
       case UPDATE:
-        return beanPersistListener.updated(bean, intercept.getDirtyPropertyNames());
+        return beanPersistListener.updated(bean, updatedProperties);
 
       case DELETE:
         return beanPersistListener.deleted(bean);
@@ -372,6 +378,10 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       return -1;
 
     case UPDATE:
+      if (beanPersistListener != null) {
+        // store the updated properties for sending later
+        updatedProperties = getUpdatedProperties();
+      }
       persistExecute.executeUpdateBean(this);
       return -1;
 

src/main/java/com/avaje/ebeaninternal/server/core/SpiOrmQueryRequest.java

@@ -4,6 +4,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import com.avaje.ebean.QueryEachConsumer;
+import com.avaje.ebean.QueryEachWhileConsumer;
 import com.avaje.ebean.QueryIterator;
 import com.avaje.ebean.QueryResultVisitor;
 import com.avaje.ebean.bean.BeanCollection;
@@ -65,7 +67,17 @@ public interface SpiOrmQueryRequest<T> {
      */
     public void findVisit(QueryResultVisitor<T> visitor);
 
-    /**
+  /**
+   * Execute the find returning a QueryIterator and visitor pattern.
+   */
+  public void findEach(QueryEachConsumer<T> consumer);
+
+  /**
+   * Execute the find returning a QueryIterator and visitor pattern.
+   */
+  public void findEachWhile(QueryEachWhileConsumer<T> consumer);
+
+  /**
      * Execute the find returning a QueryIterator.
      */
     public QueryIterator<T> findIterate();

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanCollectionHelp.java

@@ -1,8 +1,5 @@
 package com.avaje.ebeaninternal.server.deploy;
 
-import java.io.IOException;
-import java.util.Iterator;
-
 import com.avaje.ebean.EbeanServer;
 import com.avaje.ebean.Query;
 import com.avaje.ebean.Transaction;
@@ -12,6 +9,8 @@ import com.avaje.ebean.bean.BeanCollectionLoader;
 import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebeaninternal.server.text.json.WriteJson;
 
+import java.io.IOException;
+
 /**
  * Helper functions for performing tasks on Lists Sets or Maps.
  */
@@ -30,15 +29,15 @@ public interface BeanCollectionHelp<T> {
 	 */
 	public BeanCollectionAdd getBeanCollectionAdd(Object bc, String mapKey);
 
+  /**
+   * Create an empty collection of the correct type without a parent bean.
+   */
+  public BeanCollection<T> createEmptyNoParent();
+
 	/**
 	 * Create an empty collection of the correct type.
 	 */
-	public Object createEmpty(boolean vanilla);
-
-	/**
-	 * Create an iterator for reading the entries.
-	 */
-	public Iterator<?> getIterator(Object collection);
+	public BeanCollection<T> createEmpty(EntityBean bean);
 
 	/**
 	 * Add a bean to the List Set or Map.
@@ -48,7 +47,7 @@ public interface BeanCollectionHelp<T> {
 	/**
 	 * Create a lazy loading proxy for a List Set or Map.
 	 */
-	public BeanCollection<T> createReference(EntityBean parentBean, String propertyName);
+	public BeanCollection<T> createReference(EntityBean parentBean);
 
 	/**
 	 * Refresh the List Set or Map.

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanCollectionHelpFactory.java

@@ -9,6 +9,10 @@ import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
  */
 public class BeanCollectionHelpFactory {
 
+  static final BeanListHelp LIST_HELP = new BeanListHelp();
+
+  static final BeanSetHelp SET_HELP = new BeanSetHelp();
+
 	/**
 	 * Create the helper based on the many property.
 	 */
@@ -33,10 +37,10 @@ public class BeanCollectionHelpFactory {
 		SpiQuery.Type manyType = request.getQuery().getType();
 		
 		if (manyType.equals(SpiQuery.Type.LIST)){
-			return new BeanListHelp<T>();
+			return LIST_HELP;
 		
 		} else if (manyType.equals(SpiQuery.Type.SET)) {
-			return new BeanSetHelp<T>();
+			return SET_HELP;
 		
 		} else {
 			BeanDescriptor<T> target = request.getBeanDescriptor();

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanDescriptor.java

@@ -134,11 +134,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
 
   private final CompoundUniqueContraint[] compoundUniqueConstraints;
 
-  /**
-   * Extra deployment attributes.
-   */
-  private final Map<String, String> extraAttrMap;
-
   /**
    * The base database table.
    */
@@ -175,7 +170,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
   /**
    * Listens for post commit insert update and delete events.
    */
-  private volatile BeanPersistListener<T> persistListener;
+  private volatile BeanPersistListener persistListener;
 
   private volatile BeanQueryAdapter queryAdapter;
 
@@ -225,17 +220,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
   
   private final BeanPropertyAssocOne<?> unidirectional;
 
-  /**
-   * A hashcode of all the many property names. This is used to efficiently
-   * create sets of loaded property names (for partial objects).
-   */
-  private final int namesOfManyPropsHash;
-
-  /**
-   * The set of names of the many properties.
-   */
-  private final Set<String> namesOfManyProps;
-
   /**
    * list of properties that are Lists/Sets/Maps (Derived).
    */
@@ -376,8 +360,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     this.dependantTables = deploy.getDependantTables();
     this.compoundUniqueConstraints = deploy.getCompoundUniqueConstraints();
 
-    this.extraAttrMap = deploy.getExtraAttributeMap();
-
     this.baseTable = InternString.intern(deploy.getBaseTable());
 
     this.autoFetchTunable = EntityType.ORM.equals(entityType) && (beanFinder == null);
@@ -411,9 +393,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     this.propertiesManyDelete = listHelper.getManyDelete();
     this.propertiesManyToMany = listHelper.getManyToMany();
 
-    this.namesOfManyProps = deriveManyPropNames();
-    this.namesOfManyPropsHash = namesOfManyProps.hashCode();
-
     this.derivedTableJoins = listHelper.getTableJoin();
 
     boolean noRelationships = propertiesOne.length + propertiesMany.length == 0;
@@ -518,48 +497,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     }
   }
 
-  /**
-   * Determine the concurrency mode based on the existence of a non-null version
-   * property value.
-   */
-  public ConcurrencyMode determineConcurrencyMode(EntityBean bean) {
-
-    if (versionProperty == null) {
-      return ConcurrencyMode.NONE;
-    }
-    Object v = versionProperty.getValue(bean);
-    return (v == null) ? ConcurrencyMode.NONE : ConcurrencyMode.VERSION;
-  }
-
-  /**
-   * Return the Set of embedded beans that have changed.
-   */
-  public Set<String> getDirtyEmbeddedProperties(EntityBean bean) {
-
-    HashSet<String> dirtyProperties = null;
-
-    for (int i = 0; i < propertiesEmbedded.length; i++) {
-      Object embValue = propertiesEmbedded[i].getValue(bean);
-      if (embValue instanceof EntityBean) {
-        if (((EntityBean) embValue)._ebean_getIntercept().isDirty()) {
-          // this embedded is dirty so should be included in an update
-          if (dirtyProperties == null) {
-            dirtyProperties = new HashSet<String>();
-          }
-          dirtyProperties.add(propertiesEmbedded[i].getName());
-        }
-      } else {
-        // must assume it is dirty
-        if (dirtyProperties == null) {
-          dirtyProperties = new HashSet<String>();
-        }
-        dirtyProperties.add(propertiesEmbedded[i].getName());
-      }
-    }
-
-    return dirtyProperties;
-  }
-
   /**
    * Return the EbeanServer instance that owns this BeanDescriptor.
    */
@@ -667,10 +604,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     cacheHelp.initialise();
   }
 
-  protected boolean hasInheritance() {
-    return inheritInfo != null;
-  }
-
   public SqlUpdate deleteById(Object id, List<Object> idList) {
     if (id != null) {
       return deleteById(id);
@@ -792,6 +725,13 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     return inheritInfo == null || inheritInfo.isRoot();
   }
 
+  /**
+   * Set the bean caching on or off.
+   */
+  public void setUseCache(boolean useCache) {
+    cacheHelp.setUseCache(useCache);
+  }
+
   /**
    * Return true if there is currently query caching for this type of bean.
    */
@@ -838,8 +778,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     cacheHelp.queryCachePut(id, query);
   }
 
-
-
   /**
    * Try to load the beanCollection from cache return true if successful.
    */
@@ -1030,11 +968,10 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
   /**
    * Execute the postLoad if a BeanPersistController exists for this bean.
    */
-  @SuppressWarnings("unchecked")
   public void postLoad(Object bean, Set<String> includedProperties) {
     BeanPersistController c = persistController;
     if (c != null) {
-      c.postLoad((T) bean, includedProperties);
+      c.postLoad(bean, includedProperties);
     }
   }
 
@@ -1060,13 +997,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     updatePlanCache.put(key, plan);
   }
 
-  /**
-   * Return the TypeManager.
-   */
-  public TypeManager getTypeManager() {
-    return typeManager;
-  }
-
   /**
    * Return true if updates should only include changed properties. Otherwise
    * all loaded properties are included in the update.
@@ -1194,7 +1124,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
   public T createReference(Boolean readOnly, Object id) {
 
     if (cacheSharableBeans && !Boolean.FALSE.equals(readOnly)) {
-      CachedBeanData d = (CachedBeanData) cacheHelp.beanCacheGetData(id);
+      CachedBeanData d = cacheHelp.beanCacheGetData(id);
       if (d != null) {
         Object shareableBean = d.getSharableBean();
         if (shareableBean != null) {
@@ -1220,13 +1150,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     }
   }
 
-  /**
-   * Return the BeanProperty for the given deployment name.
-   */
-  public BeanProperty getBeanPropertyFromDbColumn(String dbColumn) {
-    return propMapByDbColumn.get(dbColumn);
-  }
-
   /**
    * Return the bean property traversing the object graph and taking into
    * account inheritance.
@@ -1355,14 +1278,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     return (idProperty == null) ? null : idProperty.getValue(bean);
   }
 
-  /**
-   * Return false if the id is a simple scalar and false if it is embedded or
-   * concatenated.
-   */
-  public boolean isComplexId() {
-    return idBinder.isComplexId();
-  }
-
   /**
    * Return the default order by that may need to be added if a many property is
    * included in the query.
@@ -1393,7 +1308,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
    * Get a BeanProperty by its name.
    */
   public BeanProperty getBeanProperty(String propName) {
-    return (BeanProperty) propMap.get(propName);
+    return propMap.get(propName);
   }
 
   public void sort(List<T> list, String sortByClause) {
@@ -1572,11 +1487,15 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     return prop;
   }
 
-  protected Object getBeanPropertyWithInheritance(EntityBean bean, String propName) {
+  /**
+   * Reset the many properties to empty state ready for reloading.
+   */
+  public void resetManyProperties(Object dbBean) {
 
-    BeanDescriptor<?> desc = getBeanDescriptor(bean.getClass());
-    BeanProperty beanProperty = desc.findBeanProperty(propName);
-    return beanProperty.getValue(bean);
+    EntityBean bean = (EntityBean)dbBean;
+    for (int i = 0; i < propertiesMany.length; i++) {
+      propertiesMany[i].resetMany(bean);
+    }
   }
 
   /**
@@ -1619,17 +1538,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     return EntityType.EMBEDDED.equals(entityType);
   }
 
-  public boolean isBaseTableType() {
-    return EntityType.ORM.equals(entityType);
-  }
-
-  /**
-   * Return the concurrency mode used for beans of this type.
-   */
-  public ConcurrencyMode getConcurrencyMode() {
-    return concurrencyMode;
-  }
-
   /**
    * Return the tables this bean is dependent on. This implies that if any of
    * these tables are modified then cached beans may be invalidated.
@@ -1648,7 +1556,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
   /**
    * Return the beanListener.
    */
-  public BeanPersistListener<T> getPersistListener() {
+  public BeanPersistListener getPersistListener() {
     return persistListener;
   }
 
@@ -1670,16 +1578,16 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
    * De-register the BeanPersistListener.
    */
   @SuppressWarnings("unchecked")
-  public void deregister(BeanPersistListener<?> listener) {
+  public void deregister(BeanPersistListener listener) {
     // volatile read...
-    BeanPersistListener<T> currListener = persistListener;
+    BeanPersistListener currListener = persistListener;
     if (currListener == null) {
       // nothing to deregister
     } else {
-      BeanPersistListener<T> deregListener = (BeanPersistListener<T>) listener;
-      if (currListener instanceof ChainedBeanPersistListener<?>) {
+      BeanPersistListener deregListener = listener;
+      if (currListener instanceof ChainedBeanPersistListener) {
         // remove it from the existing chain
-        persistListener = ((ChainedBeanPersistListener<T>) currListener).deregister(deregListener);
+        persistListener = ((ChainedBeanPersistListener) currListener).deregister(deregListener);
       } else if (currListener.equals(deregListener)) {
         persistListener = null;
       }
@@ -1692,9 +1600,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
   public void deregister(BeanPersistController controller) {
     // volatile read...
     BeanPersistController c = persistController;
-    if (c == null) {
-      // nothing to deregister
-    } else {
+    if (c != null) {
       if (c instanceof ChainedBeanPersistController) {
         // remove it from the existing chain
         persistController = ((ChainedBeanPersistController) c).deregister(controller);
@@ -1708,23 +1614,20 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
    * Register the new BeanPersistController.
    */
   @SuppressWarnings("unchecked")
-  public void register(BeanPersistListener<?> newPersistListener) {
+  public void register(BeanPersistListener newPersistListener) {
 
-    if (!PersistListenerManager.isRegisterFor(beanType, newPersistListener)) {
-      // skip
-    } else {
-      BeanPersistListener<T> newListener = (BeanPersistListener<T>) newPersistListener;
+    if (newPersistListener.isRegisterFor(beanType)) {
       // volatile read...
-      BeanPersistListener<T> currListener = persistListener;
+      BeanPersistListener currListener = persistListener;
       if (currListener == null) {
-        persistListener = newListener;
+        persistListener = newPersistListener;
       } else {
-        if (currListener instanceof ChainedBeanPersistListener<?>) {
+        if (currListener instanceof ChainedBeanPersistListener) {
           // add it to the existing chain
-          persistListener = ((ChainedBeanPersistListener<T>) currListener).register(newListener);
+          persistListener = ((ChainedBeanPersistListener) currListener).register(newPersistListener);
         } else {
           // build new chain of the 2
-          persistListener = new ChainedBeanPersistListener<T>(currListener, newListener);
+          persistListener = new ChainedBeanPersistListener(currListener, newPersistListener);
         }
       }
     }
@@ -1735,9 +1638,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
    */
   public void register(BeanPersistController newController) {
 
-    if (!newController.isRegisterFor(beanType)) {
-      // skip
-    } else {
+    if (newController.isRegisterFor(beanType)) {
       // volatile read...
       BeanPersistController c = persistController;
       if (c == null) {
@@ -1781,13 +1682,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     return baseTable;
   }
 
-  /**
-   * Get a named extra attribute.
-   */
-  public String getExtraAttribute(String key) {
-    return (String) extraAttrMap.get(key);
-  }
-
   /**
    * Return the identity generation type.
    */
@@ -1906,17 +1800,11 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
   }
   
   public boolean hasIdProperty(EntityBeanIntercept ebi) {
-    if (idPropertyIndex > -1) {
-      return ebi.isLoadedProperty(idPropertyIndex);
-    }
-    return false;
+    return idPropertyIndex > -1 && ebi.isLoadedProperty(idPropertyIndex);
   }
 
   public boolean hasVersionProperty(EntityBeanIntercept ebi) {
-    if (versionPropertyIndex > -1) {
-      return ebi.isLoadedProperty(versionPropertyIndex);
-    }
-    return false;
+    return versionPropertyIndex > -1 && ebi.isLoadedProperty(versionPropertyIndex);
   }
 
   /**
@@ -1979,16 +1867,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     return propertiesOneImportedDelete;
   }
 
-  /**
-   * Returns OneToOnes that are on the exported side of a OneToOne.
-   * <p>
-   * These associations do not own the relationship.
-   * </p>
-   */
-  public BeanPropertyAssocOne<?>[] propertiesOneExported() {
-    return propertiesOneExported;
-  }
-
   /**
    * Exported assoc ones with cascade save.
    */
@@ -2003,32 +1881,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     return propertiesOneExportedDelete;
   }
 
-  private Set<String> deriveManyPropNames() {
-
-    LinkedHashSet<String> names = new LinkedHashSet<String>();
-    for (int i = 0; i < propertiesMany.length; i++) {
-      names.add(propertiesMany[i].getName());
-    }
-
-    return Collections.unmodifiableSet(names);
-  }
-
-  /**
-   * Return a hash of the names of the many properties on this bean type. This
-   * is used for efficient building of included properties sets for partial
-   * objects.
-   */
-  public int getNamesOfManyPropsHash() {
-    return namesOfManyPropsHash;
-  }
-
-  /**
-   * Returns the set of many property names for this bean type.
-   */
-  public Set<String> getNamesOfManyProps() {
-    return namesOfManyProps;
-  }
-
   /**
    * All Non Assoc Many's for this descriptor.
    */
@@ -2075,20 +1927,6 @@ public class BeanDescriptor<T> implements MetaBeanInfo {
     return versionProperty;
   }
 
-  /**
-   * Return true if this is an Update (rather than insert) given that the bean
-   * is involved in a stateless update.
-   */
-  public boolean isStatelessUpdate(EntityBean bean) {
-    if (versionProperty == null) {
-      Object versionValue = getId(bean);
-      return !DmlUtil.isNullOrZero(versionValue);
-    } else {
-      Object versionValue = versionProperty.getValue(bean);
-      return !DmlUtil.isNullOrZero(versionValue);
-    }
-  }
-
   /**
    * Scalar properties without the unique id or secondary table properties.
    */

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanDescriptorCacheHelp.java

@@ -105,7 +105,16 @@ public final class BeanDescriptorCacheHelp<T> {
       }
     }
   }
-  
+
+  public void setUseCache(boolean useCache) {
+    if (useCache) {
+      getBeanCache();
+    } else {
+      beanCacheClear();
+      beanCache = null;
+    }
+  }
+
   /**
    * Return true if there is currently query caching for this type of bean.
    */

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanDescriptorManager.java

@@ -62,10 +62,10 @@ import com.avaje.ebeaninternal.server.deploy.parse.ReadAnnotations;
 import com.avaje.ebeaninternal.server.deploy.parse.TransientProperties;
 import com.avaje.ebeaninternal.server.idgen.UuidIdGenerator;
 import com.avaje.ebeaninternal.server.lib.util.Dnode;
-import com.avaje.ebeaninternal.server.reflect.BeanReflect;
-import com.avaje.ebeaninternal.server.reflect.BeanReflectFactory;
-import com.avaje.ebeaninternal.server.reflect.BeanReflectProperties;
-import com.avaje.ebeaninternal.server.reflect.EnhanceBeanReflectFactory;
+import com.avaje.ebeaninternal.server.properties.BeanPropertyInfo;
+import com.avaje.ebeaninternal.server.properties.BeanPropertyInfoFactory;
+import com.avaje.ebeaninternal.server.properties.BeanPropertiesReader;
+import com.avaje.ebeaninternal.server.properties.EnhanceBeanPropertyInfoFactory;
 import com.avaje.ebeaninternal.server.type.TypeManager;
 
 /**
@@ -86,7 +86,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
    */
   private final DeployInherit deplyInherit;
 
-  private final BeanReflectFactory reflectFactory;
+  private final BeanPropertyInfoFactory reflectFactory;
 
   private final DeployUtil deployUtil;
 
@@ -1274,9 +1274,9 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     }
   }
 
-  private BeanReflectFactory createReflectionFactory() {
+  private BeanPropertyInfoFactory createReflectionFactory() {
 
-    return new EnhanceBeanReflectFactory();
+    return new EnhanceBeanPropertyInfoFactory();
   }
 
   /**
@@ -1295,9 +1295,9 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
     Class<?> beanType = desc.getBeanType();
 
-    BeanReflectProperties reflectProps = new BeanReflectProperties(beanType);
+    BeanPropertiesReader reflectProps = new BeanPropertiesReader(beanType);
     
-    BeanReflect beanReflect = reflectFactory.create(beanType);
+    BeanPropertyInfo beanReflect = reflectFactory.create(beanType);
     desc.setBeanReflect(beanReflect);
     desc.setProperties(reflectProps.getProperties());
 

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanListHelp.java

@@ -22,29 +22,36 @@ public final class BeanListHelp<T> implements BeanCollectionHelp<T> {
 
   private final BeanPropertyAssocMany<T> many;
   private final BeanDescriptor<T> targetDescriptor;
+  private final String propertyName;
+
   private BeanCollectionLoader loader;
 
   public BeanListHelp(BeanPropertyAssocMany<T> many) {
     this.many = many;
     this.targetDescriptor = many.getTargetDescriptor();
+    this.propertyName = many.getName();
   }
 
   public BeanListHelp() {
     this.many = null;
     this.targetDescriptor = null;
+    this.propertyName = null;
   }
 
+  @Override
   public void setLoader(BeanCollectionLoader loader) {
     this.loader = loader;
   }
-
+
   /**
    * Internal add bypassing any modify listening.
    */
+  @Override
   public void add(BeanCollection<?> collection, EntityBean bean) {
     collection.internalAdd(bean);
   }
 
+  @Override
   public BeanCollectionAdd getBeanCollectionAdd(Object bc, String mapKey) {
 
     if (bc instanceof BeanList<?>) {
@@ -54,57 +61,42 @@ public final class BeanListHelp<T> implements BeanCollectionHelp<T> {
         bl.setActualList(new ArrayList<Object>());
       }
       return bl;
-    } else if (bc instanceof List<?>) {
-      return new VanillaAdd((List<?>) bc);
 
     } else {
       throw new RuntimeException("Unhandled type " + bc);
     }
   }
 
-  @SuppressWarnings("unchecked")
-  static class VanillaAdd implements BeanCollectionAdd {
-
-    @SuppressWarnings("rawtypes")
-    private final List list;
-
-    private VanillaAdd(List<?> list) {
-      this.list = list;
-    }
-
-    public void addBean(EntityBean bean) {
-      list.add(bean);
-    }
+  @Override
+  public BeanCollection<T> createEmptyNoParent() {
+    return new BeanList<T>();
   }
 
-  public Iterator<?> getIterator(Object collection) {
-    return ((List<?>) collection).iterator();
-  }
-
-  public Object createEmpty(boolean vanilla) {
-    if (vanilla) {
-      return new ArrayList<T>();
-    }
-    BeanList<T> beanList = new BeanList<T>();
+  @Override
+  public BeanCollection<T> createEmpty(EntityBean parentBean) {
+    BeanList<T> beanList = new BeanList<T>(loader, parentBean, propertyName);
     if (many != null) {
       beanList.setModifyListening(many.getModifyListenMode());
     }
     return beanList;
   }
 
-  public BeanCollection<T> createReference(EntityBean parentBean, String propertyName) {
+  @Override
+  public BeanCollection<T> createReference(EntityBean parentBean) {
 
     BeanList<T> beanList = new BeanList<T>(loader, parentBean, propertyName);
     beanList.setModifyListening(many.getModifyListenMode());
     return beanList;
   }
 
+  @Override
   public void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
 
     BeanList<?> newBeanList = (BeanList<?>) server.findList(query, t);
     refresh(newBeanList, parentBean);
   }
 
+  @Override
   public void refresh(BeanCollection<?> bc, EntityBean parentBean) {
 
     BeanList<?> newBeanList = (BeanList<?>) bc;
@@ -129,6 +121,7 @@ public final class BeanListHelp<T> implements BeanCollectionHelp<T> {
     }
   }
 
+  @Override
   public void jsonWrite(WriteJson ctx, String name, Object collection, boolean explicitInclude) throws IOException {
 
     List<?> list;
@@ -150,7 +143,7 @@ public final class BeanListHelp<T> implements BeanCollectionHelp<T> {
 
     ctx.writeStartArray(name);
     for (int j = 0; j < list.size(); j++) {
-      targetDescriptor.jsonWrite(ctx, (EntityBean)list.get(j));
+      targetDescriptor.jsonWrite(ctx, (EntityBean) list.get(j));
     }
     ctx.writeEndArray();
   }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanMapHelp.java

@@ -1,11 +1,5 @@
 package com.avaje.ebeaninternal.server.deploy;
 
-import java.io.IOException;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
 import com.avaje.ebean.EbeanServer;
 import com.avaje.ebean.Query;
 import com.avaje.ebean.Transaction;
@@ -16,174 +10,175 @@ import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.common.BeanMap;
 import com.avaje.ebeaninternal.server.text.json.WriteJson;
 
+import java.io.IOException;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
 /**
  * Helper specifically for dealing with Maps.
  */
 public final class BeanMapHelp<T> implements BeanCollectionHelp<T> {
 
-	private final BeanPropertyAssocMany<T> many;
-	private final BeanDescriptor<T> targetDescriptor;
-	private final BeanProperty beanProperty;
-	private BeanCollectionLoader loader;
-	//private final String mapKey;
-	
-	/**
-	 * When created for a given query that will return a map.
-	 */
-	public BeanMapHelp(BeanDescriptor<T> targetDescriptor, String mapKey) {
-		this(null, targetDescriptor, mapKey);
-	}
+  private final BeanPropertyAssocMany<T> many;
+  private final BeanDescriptor<T> targetDescriptor;
+  private final String propertyName;
+  private final BeanProperty beanProperty;
+  private BeanCollectionLoader loader;
 
-	public BeanMapHelp(BeanPropertyAssocMany<T> many){
-		this(many, many.getTargetDescriptor(), many.getMapKey());
-	}
-	
-	/**
-	 * When help is attached to a specific many property.
-	 */
-	private BeanMapHelp(BeanPropertyAssocMany<T> many, BeanDescriptor<T> targetDescriptor, String mapKey){
-		this.many = many;
-		this.targetDescriptor = targetDescriptor;
-		//this.mapKey = mapKey;
-		this.beanProperty = targetDescriptor.getBeanProperty(mapKey);
-	}
-	
-	/**
-	 * Return an iterator of the values.
-	 */
-    public Iterator<?> getIterator(Object collection) {
-        return ((Map<?,?>) collection).values().iterator();
+  /**
+   * When created for a given query that will return a map.
+   */
+  public BeanMapHelp(BeanDescriptor<T> targetDescriptor, String mapKey) {
+    this.targetDescriptor = targetDescriptor;
+    this.beanProperty = targetDescriptor.getBeanProperty(mapKey);
+    this.many = null;
+    this.propertyName = null;
+  }
+
+  /**
+   * When help is attached to a specific many property.
+   */  public BeanMapHelp(BeanPropertyAssocMany<T> many) {
+    this.many = many;
+    this.targetDescriptor = many.getTargetDescriptor();
+    this.propertyName = many.getName();
+    this.beanProperty = targetDescriptor.getBeanProperty(many.getMapKey());
+  }
+
+  @Override
+  public void setLoader(BeanCollectionLoader loader) {
+    this.loader = loader;
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public BeanCollectionAdd getBeanCollectionAdd(Object bc, String mapKey) {
+
+    if (mapKey == null) {
+      mapKey = many.getMapKey();
     }
-	
-	public void setLoader(BeanCollectionLoader loader){
-		this.loader = loader;
-	}
+    BeanProperty beanProp = targetDescriptor.getBeanProperty(mapKey);
 
-    @SuppressWarnings("unchecked")
-	public BeanCollectionAdd getBeanCollectionAdd(Object bc, String mapKey) {
-		
-		if(mapKey == null){
-			mapKey = many.getMapKey();
-		}
-		BeanProperty beanProp = targetDescriptor.getBeanProperty(mapKey);
-		
-		if (bc instanceof BeanMap<?,?>){
-    		BeanMap<Object, Object> bm = (BeanMap<Object, Object>)bc;
-    		Map<Object, Object> actualMap = bm.getActualMap();
-    		if (actualMap == null){
-    			actualMap = new LinkedHashMap<Object, Object>();
-    			bm.setActualMap(actualMap);
-    		}
-    		return new Adder(beanProp, actualMap);
-		
-		} else if (bc instanceof Map<?,?>) {
-            return new Adder(beanProp, (Map<Object, Object>)bc);		    
-		
-		} else {
-            throw new RuntimeException("Unhandled type "+bc);
-        }
-	}
+    if (bc instanceof BeanMap<?, ?>) {
+      BeanMap<Object, Object> bm = (BeanMap<Object, Object>) bc;
+      Map<Object, Object> actualMap = bm.getActualMap();
+      if (actualMap == null) {
+        actualMap = new LinkedHashMap<Object, Object>();
+        bm.setActualMap(actualMap);
+      }
+      return new Adder(beanProp, actualMap);
 
-	static class Adder implements BeanCollectionAdd {
-		
-		private final BeanProperty beanProperty;
-		
-		private final Map<Object, Object> map;
-		
-		Adder(BeanProperty beanProperty, Map<Object, Object> map) {
-			this.beanProperty = beanProperty;
-			this.map = map;
-		}
-		
-		public void addBean(EntityBean bean) {
-			Object keyValue = beanProperty.getValue(bean);
-			map.put(keyValue, bean);
-		}
-	}
+    } else {
+      throw new RuntimeException("Unhandled type " + bc);
+    }
+  }
 
-	@SuppressWarnings("rawtypes")
-    public Object createEmpty(boolean vanilla) {
-	  if (vanilla) {
-	    return new LinkedHashMap();
-	  }
-		BeanMap beanMap = new BeanMap();
-		if (many != null) {
-		  beanMap.setModifyListening(many.getModifyListenMode());
-		}
-		return beanMap;
-	}
-	
-	public void add(BeanCollection<?> collection, EntityBean bean) {
+  static class Adder implements BeanCollectionAdd {
 
-		Object keyValue = beanProperty.getValueIntercept(bean);
+    private final BeanProperty beanProperty;
 
-		((BeanMap<?,?>) collection).internalPut(keyValue, bean);
-	}
+    private final Map<Object, Object> map;
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public BeanCollection<T> createReference(EntityBean parentBean, String propertyName) {
+    Adder(BeanProperty beanProperty, Map<Object, Object> map) {
+      this.beanProperty = beanProperty;
+      this.map = map;
+    }
 
-	  BeanMap beanMap = new BeanMap(loader, parentBean, propertyName);
+    public void addBean(EntityBean bean) {
+      Object keyValue = beanProperty.getValue(bean);
+      map.put(keyValue, bean);
+    }
+  }
+
+  @Override
+  public BeanCollection<T> createEmptyNoParent() {
+    return new BeanMap();
+  }
+
+  @Override
+  @SuppressWarnings("rawtypes")
+  public BeanCollection<T> createEmpty(EntityBean ownerBean) {
+
+    BeanMap beanMap = new BeanMap(loader, ownerBean, propertyName);
     if (many != null) {
       beanMap.setModifyListening(many.getModifyListenMode());
     }
     return beanMap;
-	}
+  }
 
-	public void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
-		BeanMap<?, ?> newBeanMap = (BeanMap<?, ?>) server.findMap(query, t);
-		refresh(newBeanMap, parentBean);
-	}
-	
-	public void refresh(BeanCollection<?> bc, EntityBean parentBean) {
+  @Override
+  public void add(BeanCollection<?> collection, EntityBean bean) {
 
-		BeanMap<?, ?> newBeanMap = (BeanMap<?, ?>) bc;
-		Map<?, ?> current = (Map<?, ?>) many.getValue(parentBean);
+    Object keyValue = beanProperty.getValueIntercept(bean);
+    ((BeanMap<?, ?>) collection).internalPut(keyValue, bean);
+  }
 
-		newBeanMap.setModifyListening(many.getModifyListenMode());
-		if (current == null) {
-			// the currentMap is null? Not really expecting this...
-			many.setValue(parentBean, newBeanMap);
+  @Override
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public BeanCollection<T> createReference(EntityBean parentBean) {
 
-		} else if (current instanceof BeanMap<?,?>) {
-			// normally this case, replace just the underlying list
-			BeanMap<?, ?> currentBeanMap = (BeanMap<?, ?>) current;
-			currentBeanMap.setActualMap(newBeanMap.getActualMap());
-			currentBeanMap.setModifyListening(many.getModifyListenMode());
+    BeanMap beanMap = new BeanMap(loader, parentBean, propertyName);
+    if (many != null) {
+      beanMap.setModifyListening(many.getModifyListenMode());
+    }
+    return beanMap;
+  }
 
-		} else {
-			// replace the entire set
-			many.setValue(parentBean, newBeanMap);
-		}
-	}
+  @Override
+  public void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
+    BeanMap<?, ?> newBeanMap = (BeanMap<?, ?>) server.findMap(query, t);
+    refresh(newBeanMap, parentBean);
+  }
 
-    public void jsonWrite(WriteJson ctx, String name, Object collection, boolean explicitInclude) throws IOException {
-        
-        Map<?,?> map;
-        if (collection instanceof BeanCollection<?>){
-            BeanMap<?,?> bc = (BeanMap<?,?>)collection;
-            if (!bc.isPopulated()){
-                if (explicitInclude){
-                    // invoke lazy loading as collection 
-                    // is explicitly included in the output
-                    bc.size();
-                } else {
-                    return;
-                }
-            } 
-            map = bc.getActualMap();
+  @Override
+  public void refresh(BeanCollection<?> bc, EntityBean parentBean) {
+
+    BeanMap<?, ?> newBeanMap = (BeanMap<?, ?>) bc;
+    Map<?, ?> current = (Map<?, ?>) many.getValue(parentBean);
+
+    newBeanMap.setModifyListening(many.getModifyListenMode());
+    if (current == null) {
+      // the currentMap is null? Not really expecting this...
+      many.setValue(parentBean, newBeanMap);
+
+    } else if (current instanceof BeanMap<?, ?>) {
+      // normally this case, replace just the underlying list
+      BeanMap<?, ?> currentBeanMap = (BeanMap<?, ?>) current;
+      currentBeanMap.setActualMap(newBeanMap.getActualMap());
+      currentBeanMap.setModifyListening(many.getModifyListenMode());
+
+    } else {
+      // replace the entire set
+      many.setValue(parentBean, newBeanMap);
+    }
+  }
+
+  @Override
+  public void jsonWrite(WriteJson ctx, String name, Object collection, boolean explicitInclude) throws IOException {
+
+    Map<?, ?> map;
+    if (collection instanceof BeanCollection<?>) {
+      BeanMap<?, ?> bc = (BeanMap<?, ?>) collection;
+      if (!bc.isPopulated()) {
+        if (explicitInclude) {
+          // invoke lazy loading as collection
+          // is explicitly included in the output
+          bc.size();
         } else {
-            map = (Map<?,?>)collection;
+          return;
         }
-        
-        ctx.writeStartArray(name);
-        Iterator<?> it = map.entrySet().iterator();
-        while (it.hasNext()) {
-            Entry<?, ?> entry = (Entry<?, ?>)it.next();
-            //FIXME: json write map key ...
-            targetDescriptor.jsonWrite(ctx, (EntityBean) entry.getValue());
-        }
-        ctx.writeEndArray();
+      }
+      map = bc.getActualMap();
+    } else {
+      map = (Map<?, ?>) collection;
     }
 
+    ctx.writeStartArray(name);
+    for (Entry<?, ?> entry : map.entrySet()) {
+      //FIXME: json write map key ...
+      targetDescriptor.jsonWrite(ctx, (EntityBean) entry.getValue());
+    }
+    ctx.writeEndArray();
+  }
+
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanProperty.java

@@ -27,8 +27,8 @@ import com.avaje.ebeaninternal.server.el.ElPropertyValue;
 import com.avaje.ebeaninternal.server.lib.util.StringHelper;
 import com.avaje.ebeaninternal.server.query.SqlBeanLoad;
 import com.avaje.ebeaninternal.server.query.SqlJoinType;
-import com.avaje.ebeaninternal.server.reflect.BeanReflectGetter;
-import com.avaje.ebeaninternal.server.reflect.BeanReflectSetter;
+import com.avaje.ebeaninternal.server.properties.BeanPropertyGetter;
+import com.avaje.ebeaninternal.server.properties.BeanPropertySetter;
 import com.avaje.ebeaninternal.server.text.json.WriteJson;
 import com.avaje.ebeaninternal.server.type.DataBind;
 import com.avaje.ebeaninternal.server.type.ScalarType;
@@ -41,29 +41,6 @@ import com.fasterxml.jackson.core.JsonToken;
  */
 public class BeanProperty implements ElPropertyValue {
 
-    /**
-     * Advanced bean deployment. To exclude this property from update where
-     * clause.
-     */
-    public static final String EXCLUDE_FROM_UPDATE_WHERE = "EXCLUDE_FROM_UPDATE_WHERE";
-
-    /**
-     * Advanced bean deployment. To exclude this property from delete where
-     * clause.
-     */
-    public static final String EXCLUDE_FROM_DELETE_WHERE = "EXCLUDE_FROM_DELETE_WHERE";
-
-    /**
-     * Advanced bean deployment. To exclude this property from insert.
-     */
-    public static final String EXCLUDE_FROM_INSERT = "EXCLUDE_FROM_INSERT";
-
-    /**
-     * Advanced bean deployment. To exclude this property from update set
-     * clause.
-     */
-    public static final String EXCLUDE_FROM_UPDATE = "EXCLUDE_FROM_UPDATE";
-
     /**
      * Flag to mark this at part of the unique id.
      */
@@ -219,9 +196,9 @@ public class BeanProperty implements ElPropertyValue {
      */
     final GeneratedProperty generatedProperty;
 
-    final BeanReflectGetter getter;
+    final BeanPropertyGetter getter;
 
-    final BeanReflectSetter setter;
+    final BeanPropertySetter setter;
 
     final BeanDescriptor<?> descriptor;
 
@@ -488,15 +465,7 @@ public class BeanProperty implements ElPropertyValue {
      * Return true if the underlying type is mutable.
      */
     public boolean isMutableScalarType() {
-        if (scalarType == null) {
-            return false;
-        }
-        return scalarType.isMutable();
-    }
-
-    public void copyProperty(EntityBean sourceBean, EntityBean destBean) {
-        Object value = getValue(sourceBean);
-        setValue(destBean, value);
+      return scalarType != null && scalarType.isMutable();
     }
 
     /**
@@ -506,10 +475,6 @@ public class BeanProperty implements ElPropertyValue {
         return descriptor.getEncryptKey(this);
     }
 
-    public String getDecryptProperty() {
-        return dbEncryptFunction.getDecryptSql(this.getName());
-    }
-
     public String getDecryptProperty(String propertyName) {
         return dbEncryptFunction.getDecryptSql(propertyName);
     }
@@ -575,24 +540,6 @@ public class BeanProperty implements ElPropertyValue {
         return owningType.isAssignableFrom(type);
     }
 
-    public Object readSetOwning(DbReadContext ctx, EntityBean bean, Class<?> type) throws SQLException {
-
-        try {
-            Object value = scalarType.read(ctx.getDataReader());
-            if (value == null || bean == null) {
-                // not setting the value...
-            } else {
-                if (owningType.equals(type)) {
-                    setValue(bean, value);
-                }
-            }
-            return value;
-        } catch (Exception e) {
-            String msg = "Error readSet on " + descriptor + "." + name;
-            throw new PersistenceException(msg, e);
-        }
-    }
-
     public void loadIgnore(DbReadContext ctx) {
         scalarType.loadIgnore(ctx.getDataReader());
     }
@@ -616,16 +563,13 @@ public class BeanProperty implements ElPropertyValue {
     public Object readSet(DbReadContext ctx, EntityBean bean, Class<?> type) throws SQLException {
 
         try {
-            Object value = scalarType.read(ctx.getDataReader());
-            if (bean == null || (type != null && !owningType.isAssignableFrom(type))) {
-                // not setting the value...
-            } else {
-                setValue(bean, value);
-            }
-            return value;
+          Object value = scalarType.read(ctx.getDataReader());
+          if (bean != null && ((type == null || owningType.isAssignableFrom(type)))) {
+              setValue(bean, value);
+          }
+          return value;
         } catch (Exception e) {
-            String msg = "Error readSet on " + descriptor + "." + name;
-            throw new PersistenceException(msg, e);
+            throw new PersistenceException("Error readSet on " + descriptor + "." + name, e);
         }
     }
 
@@ -653,21 +597,6 @@ public class BeanProperty implements ElPropertyValue {
         return scalarType.readData(dataInput);
     }
 
-    public boolean isCascadeValidate() {
-        return cascadeValidate;
-    }
-
-    /**
-     * Checks to see if a bean is a reference (will be lazy loaded) or a
-     * BeanCollection that has not yet been populated.
-     * <p>
-     * For base types this returns true.
-     * </p>
-     */
-    public boolean isValueLoaded(Object value) {
-        return true;
-    }
-
     public BeanProperty getBeanProperty() {
         return this;
     }
@@ -737,16 +666,21 @@ public class BeanProperty implements ElPropertyValue {
         }
     }
 
-    private static Object[] NO_ARGS = new Object[0];
-
     public Object getCacheDataValue(EntityBean bean) {
         return getValue(bean);
-    }
+    }
 
     public void setCacheDataValue(EntityBean bean, Object cacheData) {
         setValue(bean, cacheData);
     }
-    
+
+    /**
+     * Get the property value from a compound value type.
+     */
+    public Object getValueObject(Object bean) {
+      throw new RuntimeException("Expected to be called only on BeanPropertyCompoundScalar");
+    }
+
     /**
      * Return the value of the property method.
      */
@@ -759,19 +693,6 @@ public class BeanProperty implements ElPropertyValue {
             throw new RuntimeException(msg, ex);
         }
     }
-    
-    /**
-     * Explicitly use reflection to get value.
-     */
-    public Object getValueViaReflection(Object bean) {
-    	try {
-            return readMethod.invoke(bean, NO_ARGS);
-        } catch (Exception ex) {
-            String beanType = bean == null ? "null" : bean.getClass().getName();
-            String msg = "get " + name + " on [" + descriptor + "] type[" + beanType + "] threw error.";
-            throw new RuntimeException(msg, ex);
-        }
-    }
 
     public Object getValueIntercept(EntityBean bean) {
         try {
@@ -826,13 +747,6 @@ public class BeanProperty implements ElPropertyValue {
         return name;
     }
 
-    /**
-     * This is a full ElGetValue.
-     */
-    public boolean isDeployOnly() {
-        return false;
-    }
-
     @Override
     public boolean containsFormulaWithJoin() {
         return formula && sqlFormulaJoin != null;
@@ -902,7 +816,7 @@ public class BeanProperty implements ElPropertyValue {
     /**
      * Return the scalarType.
      */
-    public ScalarType<?> getScalarType() {
+    public ScalarType<Object> getScalarType() {
         return scalarType;
     }
 
@@ -923,7 +837,7 @@ public class BeanProperty implements ElPropertyValue {
     }
 
     public Object parseDateTime(long systemTimeMillis) {
-        return scalarType.parseDateTime(systemTimeMillis);
+        return scalarType.convertFromMillis(systemTimeMillis);
     }
 
     /**
@@ -1031,10 +945,6 @@ public class BeanProperty implements ElPropertyValue {
         return version;
     }
 
-    public String getDeployProperty() {
-        return dbColumn;
-    }
-
     /**
      * The database column name this is mapped to.
      */
@@ -1168,13 +1078,6 @@ public class BeanProperty implements ElPropertyValue {
         return embedded;
     }
 
-    /**
-     * Return an extra attribute set on this property.
-     */
-    public String getExtraAttribute(String key) {
-        return extraAttributeMap.get(key);
-    }
-
     /**
      * Return the default value.
      */

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyAssocMany.java

@@ -174,7 +174,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
   public void addBeanToCollectionWithCreate(EntityBean parentBean, EntityBean detailBean) {
     BeanCollection<?> bc = (BeanCollection<?>) super.getValue(parentBean);
     if (bc == null) {
-      bc = (BeanCollection<?>) help.createEmpty(false);
+      bc = help.createEmpty(parentBean);
       setValue(parentBean, bc);
     }
     help.add(bc, detailBean);
@@ -185,6 +185,22 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
     return val == null || (val instanceof BeanCollection<?>) && ((BeanCollection<?>) val).isEmptyAndUntouched();
   }
 
+  /**
+   * Reset the many properties to be empty and ready for reloading.
+   * <p>
+   * Used in bean refresh.
+   */
+  public void resetMany(EntityBean bean) {
+    Object value = getValue(bean);
+    if (value == null) {
+      // not expecting this - set an empty reference
+      createReference(bean);
+    } else {
+      // reset the collection back to empty
+      ((BeanCollection)value).reset(bean, name);
+    }
+  }
+
   @Override
   public Object getValue(EntityBean bean) {
     return super.getValue(bean);
@@ -385,12 +401,6 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
     return null;
   }
 
-
-  @Override
-  public boolean isValueLoaded(Object value) {
-    return !(value instanceof BeanCollection<?>) || ((BeanCollection<?>) value).isPopulated();
-  }
-
   public void add(BeanCollection<?> collection, EntityBean bean) {
     help.add(collection, bean);
   }
@@ -532,13 +542,13 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
 
   public BeanCollection<?> createReference(EntityBean parentBean) {
 
-    BeanCollection<?> ref = help.createReference(parentBean, name);
+    BeanCollection<?> ref = help.createReference(parentBean);
     setValue(parentBean, ref);
     return ref;
   }
 
-  public Object createEmpty(boolean vanilla) {
-    return help.createEmpty(vanilla);
+  public BeanCollection<T> createEmpty(EntityBean parentBean) {
+    return help.createEmpty(parentBean);
   }
 
   public BeanCollectionAdd getBeanCollectionAdd(Object bc, String mapKey) {

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonHelp.java

@@ -2,6 +2,7 @@ package com.avaje.ebeaninternal.server.deploy;
 
 import java.io.IOException;
 
+import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.BeanCollectionAdd;
 import com.avaje.ebean.bean.EntityBean;
 import com.fasterxml.jackson.core.JsonParseException;
@@ -30,7 +31,7 @@ public class BeanPropertyAssocManyJsonHelp {
       throw new JsonParseException("Unexpected token " + event + " - expecting start_array ", parser.getCurrentLocation());
     }
 
-    Object collection = many.createEmpty(false);
+    BeanCollection<?> collection = many.createEmpty(parentBean);
     BeanCollectionAdd add = many.getBeanCollectionAdd(collection, null);
     do {
       EntityBean detailBean = (EntityBean) many.targetDescriptor.jsonRead(parser, many.name);

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyAssocOne.java

@@ -265,14 +265,6 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> {
         }
     }
 
-    @Override
-    public boolean isValueLoaded(Object value) {
-        if (value instanceof EntityBean) {
-            return ((EntityBean) value)._ebean_getIntercept().isLoaded();
-        }
-        return true;
-    }
-
     /**
      * Return meta data for the deployment of the embedded bean specific to this
      * property.
@@ -403,13 +395,6 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> {
         return getTargetDescriptor().createEntityBean();
     }
 
-    /**
-     * Return an empty reference object.
-     */
-    public Object createEmptyReference() {
-        return targetDescriptor.createEntityBean();
-    }
-
     @Override
     public Object elGetReference(EntityBean bean) {
         Object value = getValueIntercept(bean);
@@ -473,7 +458,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> {
             }
         }
 
-        return (ExportedProperty[]) list.toArray(new ExportedProperty[list.size()]);
+        return list.toArray(new ExportedProperty[list.size()]);
     }
 
     /**

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyCompound.java

@@ -89,19 +89,6 @@ public class BeanPropertyCompound extends BeanProperty {
         }
     }
 
-    /**
-     * Get the underlying compound type.
-     */
-    @SuppressWarnings("unchecked")
-    public Object getValueUnderlying(EntityBean bean) {
-
-        Object value =  getValue(bean);
-        if (typeConverter != null){
-            value = typeConverter.unwrapValue(value);
-        }
-        return value;
-    }
- 
     public ElPropertyValue buildElPropertyValue(String propName, String remainder, ElPropertyChainBuilder chain, boolean propertyDeploy) {
 
         if (chain == null) {

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyCompoundRoot.java

@@ -7,7 +7,7 @@ import java.util.List;
 
 import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanProperty;
-import com.avaje.ebeaninternal.server.reflect.BeanReflectSetter;
+import com.avaje.ebeaninternal.server.properties.BeanPropertySetter;
 import com.avaje.ebeaninternal.server.type.CtCompoundProperty;
 
 /**
@@ -22,7 +22,7 @@ import com.avaje.ebeaninternal.server.type.CtCompoundProperty;
  */
 public class BeanPropertyCompoundRoot {
 
-    private final BeanReflectSetter setter;
+    private final BeanPropertySetter setter;
 
     /**
      * The method used to write the property.

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyCompoundScalar.java

@@ -6,93 +6,100 @@ import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanProperty;
 import com.avaje.ebeaninternal.server.type.CtCompoundProperty;
 
 /**
- * A BeanProperty owned by a Compound value object that maps to 
+ * A BeanProperty owned by a Compound value object that maps to
  * a real scalar type.
- * 
- * @author rbygrave
  */
 public class BeanPropertyCompoundScalar extends BeanProperty {
 
-    private final BeanPropertyCompoundRoot rootProperty;
-    
-    private final CtCompoundProperty ctProperty;
-    
-    @SuppressWarnings("rawtypes")
-    private final ScalarTypeConverter typeConverter;
-    
-    public BeanPropertyCompoundScalar(BeanPropertyCompoundRoot rootProperty, DeployBeanProperty scalarDeploy,
-            CtCompoundProperty ctProperty, ScalarTypeConverter<?, ?> typeConverter) {
-        
-        super(scalarDeploy);
-        this.rootProperty = rootProperty;
-        this.ctProperty = ctProperty;
-        this.typeConverter = typeConverter;
-    }
+  private final BeanPropertyCompoundRoot rootProperty;
 
-    @SuppressWarnings("unchecked")
-    @Override
-    public Object getValue(EntityBean valueObject) {
-      Object val = valueObject;  
-      if (typeConverter != null){
-            val = typeConverter.unwrapValue(val);
-        }
-        return ctProperty.getValue(val);
-    }
+  private final CtCompoundProperty ctProperty;
 
-    @Override
-    public void setValue(EntityBean bean, Object value) {
-        setValueInCompound(bean, value, false);        
-    }
-    
-    @SuppressWarnings("unchecked")
-    public void setValueInCompound(EntityBean bean, Object value, boolean intercept) {
-        
-        Object compoundValue = ctProperty.setValue(bean, value);
-        
-        if (compoundValue != null){
-            if (typeConverter != null){
-                compoundValue = typeConverter.wrapValue(compoundValue);
-            }
-            // we are at the top level and we have a compound value
-            // that we can set using the root property
-            if (intercept){
-                rootProperty.setRootValueIntercept(bean, compoundValue);
-            } else {
-                rootProperty.setRootValue(bean, compoundValue);
-            }
-        }
-    }
+  @SuppressWarnings("rawtypes")
+  private final ScalarTypeConverter typeConverter;
 
-    /**
-     * No interception on embedded scalar values inside a CVO.
-     */
-    @Override
-    public void setValueIntercept(EntityBean bean, Object value) {
-        setValueInCompound(bean, value, true);
-    }
+  public BeanPropertyCompoundScalar(BeanPropertyCompoundRoot rootProperty, DeployBeanProperty scalarDeploy,
+                                    CtCompoundProperty ctProperty, ScalarTypeConverter<?, ?> typeConverter) {
 
-    /**
-     * No interception on embedded scalar values inside a CVO.
-     */
-    @Override
-    public Object getValueIntercept(EntityBean bean) {
-        return getValue(bean);
-    }
+    super(scalarDeploy);
+    this.rootProperty = rootProperty;
+    this.ctProperty = ctProperty;
+    this.typeConverter = typeConverter;
+  }
 
-    @Override
-    public Object elGetReference(EntityBean bean) {
-        return getValue(bean);
+  /**
+   * Return one of the scalar values from a compound type.
+   */
+  public Object getValueObject(Object compoundValue) {
+    if (typeConverter != null) {
+      compoundValue = typeConverter.unwrapValue(compoundValue);
     }
+    return ctProperty.getValue(compoundValue);
+  }
 
-    @Override
-    public Object elGetValue(EntityBean bean) {
-        return getValue(bean);
+  @SuppressWarnings("unchecked")
+  @Override
+  public Object getValue(EntityBean valueObject) {
+    Object val = valueObject;
+    if (typeConverter != null) {
+      val = typeConverter.unwrapValue(val);
     }
+    return ctProperty.getValue(val);
+  }
 
-    @Override
-    public void elSetValue(EntityBean bean, Object value, boolean populate) {//, boolean reference) {
-        super.elSetValue(bean, value, populate);
+  @Override
+  public void setValue(EntityBean bean, Object value) {
+    setValueInCompound(bean, value, false);
+  }
+
+  @SuppressWarnings("unchecked")
+  public void setValueInCompound(EntityBean bean, Object value, boolean intercept) {
+
+    Object compoundValue = ctProperty.setValue(bean, value);
+
+    if (compoundValue != null) {
+      if (typeConverter != null) {
+        compoundValue = typeConverter.wrapValue(compoundValue);
+      }
+      // we are at the top level and we have a compound value
+      // that we can set using the root property
+      if (intercept) {
+        rootProperty.setRootValueIntercept(bean, compoundValue);
+      } else {
+        rootProperty.setRootValue(bean, compoundValue);
+      }
     }
+  }
+
+  /**
+   * No interception on embedded scalar values inside a CVO.
+   */
+  @Override
+  public void setValueIntercept(EntityBean bean, Object value) {
+    setValueInCompound(bean, value, true);
+  }
+
+  /**
+   * No interception on embedded scalar values inside a CVO.
+   */
+  @Override
+  public Object getValueIntercept(EntityBean bean) {
+    return getValue(bean);
+  }
+
+  @Override
+  public Object elGetReference(EntityBean bean) {
+    return getValue(bean);
+  }
+
+  @Override
+  public Object elGetValue(EntityBean bean) {
+    return getValue(bean);
+  }
+
+  @Override
+  public void elSetValue(EntityBean bean, Object value, boolean populate) {//, boolean reference) {
+    super.elSetValue(bean, value, populate);
+  }
 
-    
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanSetHelp.java

@@ -19,141 +19,131 @@ import com.avaje.ebeaninternal.server.text.json.WriteJson;
  * Helper specifically for dealing with Sets.
  */
 public final class BeanSetHelp<T> implements BeanCollectionHelp<T> {
-	
-	private final BeanPropertyAssocMany<T> many;
-	private final BeanDescriptor<T> targetDescriptor;
-	private BeanCollectionLoader loader;
-	
-	/**
-	 * When attached to a specific many property.
-	 */
-	public BeanSetHelp(BeanPropertyAssocMany<T> many){
-		this.many = many;
-		this.targetDescriptor = many.getTargetDescriptor();
-	}
-	
-	/**
-	 * For a query that returns a set.
-	 */
-	public BeanSetHelp(){
-		this.many = null;
-		this.targetDescriptor = null;
-	}
-	
-	public void setLoader(BeanCollectionLoader loader){
-		this.loader = loader;
-	}
-	
-    public Iterator<?> getIterator(Object collection) {
-        return ((Set<?>) collection).iterator();
-    }
-	
-	public BeanCollectionAdd getBeanCollectionAdd(Object bc,String mapKey) {
-	    if (bc instanceof BeanSet<?>){
-    		BeanSet<?> beanSet = (BeanSet<?>)bc;
-    		if (beanSet.getActualSet() == null){
-    			beanSet.setActualSet(new LinkedHashSet<Object>());
-    		}
-    		return beanSet;
-	    } else if (bc instanceof Set<?>) {
-	        return new VanillaAdd((Set<?>)bc);
-	        
-	    } else {
-	        throw new RuntimeException("Unhandled type "+bc);
-	    }
-	}
-	
 
-    @SuppressWarnings("unchecked")
-    static class VanillaAdd implements BeanCollectionAdd {
+  private final BeanPropertyAssocMany<T> many;
+  private final BeanDescriptor<T> targetDescriptor;
+  private final String propertyName;
+  private BeanCollectionLoader loader;
 
-        @SuppressWarnings("rawtypes")
-		private final Set set;
+  /**
+   * When attached to a specific many property.
+   */
+  public BeanSetHelp(BeanPropertyAssocMany<T> many) {
+    this.many = many;
+    this.targetDescriptor = many.getTargetDescriptor();
+    this.propertyName = many.getName();
+  }
 
-        private VanillaAdd(Set<?> set) {
-            this.set = set;
-        }
+  /**
+   * For a query that returns a set.
+   */
+  public BeanSetHelp() {
+    this.many = null;
+    this.targetDescriptor = null;
+    this.propertyName = null;
+  }
 
-        public void addBean(EntityBean bean) {
-            set.add(bean);
-        }
-    }
-	
-	public void add(BeanCollection<?> collection, EntityBean bean) {
-		collection.internalAdd(bean);
-	}
-    
-    public Object createEmpty(boolean vanilla) {
-      if (vanilla) {
-        return new LinkedHashSet<T>();
+  @Override
+  public void setLoader(BeanCollectionLoader loader) {
+    this.loader = loader;
+  }
+
+  @Override
+  public BeanCollectionAdd getBeanCollectionAdd(Object bc, String mapKey) {
+    if (bc instanceof BeanSet<?>) {
+      BeanSet<?> beanSet = (BeanSet<?>) bc;
+      if (beanSet.getActualSet() == null) {
+        beanSet.setActualSet(new LinkedHashSet<Object>());
       }
-	    BeanSet<T> beanSet = new BeanSet<T>();
-	    if (many != null) {
-	      beanSet.setModifyListening(many.getModifyListenMode());
-	    }
-	    return beanSet;
-	}
+      return beanSet;
 
-	public BeanCollection<T> createReference(EntityBean parentBean, String propertyName) {
-		
-	  BeanSet<T> beanSet = new BeanSet<T>(loader, parentBean, propertyName);
-	  beanSet.setModifyListening(many.getModifyListenMode());
-	  return beanSet;
-	}
-
-	public void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
-		
-		BeanSet<?> newBeanSet = (BeanSet<?>)server.findSet(query, t);
-		refresh(newBeanSet, parentBean);
-	}
-	
-	public void refresh(BeanCollection<?> bc, EntityBean parentBean) {
-		
-		BeanSet<?> newBeanSet = (BeanSet<?>)bc;
-		
-		Set<?> current = (Set<?>)many.getValue(parentBean);
-		
-		newBeanSet.setModifyListening(many.getModifyListenMode());
-		if (current == null){
-			// the currentList is null?  Not really expecting this...
-			many.setValue(parentBean,newBeanSet);
-			
-		} else if (current instanceof BeanSet<?>) {
-			// normally this case, replace just the underlying list
-			BeanSet<?> currentBeanSet = (BeanSet<?>)current;
-			currentBeanSet.setActualSet(newBeanSet.getActualSet());
-			currentBeanSet.setModifyListening(many.getModifyListenMode());
-
-		} else {
-			// replace the entire set 
-			many.setValue(parentBean, newBeanSet);
-		}
-	}
-	
-    public void jsonWrite(WriteJson ctx, String name, Object collection, boolean explicitInclude) throws IOException {
-        
-        Set<?> set;
-        if (collection instanceof BeanCollection<?>){
-            BeanSet<?> bc = (BeanSet<?>)collection;
-            if (!bc.isPopulated()){
-                if (explicitInclude){
-                    // invoke lazy loading as collection 
-                    // is explicitly included in the output
-                    bc.size();
-                } else {
-                    return;
-                }
-            } 
-            set = bc.getActualSet();
-        } else {
-            set = (Set<?>)collection;
-        }
-        
-        ctx.writeStartArray(name);
-        Iterator<?> it = set.iterator();
-        while (it.hasNext()) {
-            targetDescriptor.jsonWrite(ctx, (EntityBean)it.next());
-        }
-        ctx.writeEndArray();        
+    } else {
+      throw new RuntimeException("Unhandled type " + bc);
     }
+  }
+
+  public void add(BeanCollection<?> collection, EntityBean bean) {
+    collection.internalAdd(bean);
+  }
+
+  @Override
+  public BeanCollection<T> createEmptyNoParent() {
+    return new BeanSet();
+  }
+
+  @Override
+  public BeanCollection<T> createEmpty(EntityBean ownerBean) {
+    BeanSet<T> beanSet = new BeanSet<T>(loader, ownerBean, propertyName);
+    if (many != null) {
+      beanSet.setModifyListening(many.getModifyListenMode());
+    }
+    return beanSet;
+  }
+
+  @Override
+  public BeanCollection<T> createReference(EntityBean parentBean) {
+
+    BeanSet<T> beanSet = new BeanSet<T>(loader, parentBean, propertyName);
+    beanSet.setModifyListening(many.getModifyListenMode());
+    return beanSet;
+  }
+
+  @Override
+  public void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
+
+    BeanSet<?> newBeanSet = (BeanSet<?>) server.findSet(query, t);
+    refresh(newBeanSet, parentBean);
+  }
+
+  @Override
+  public void refresh(BeanCollection<?> bc, EntityBean parentBean) {
+
+    BeanSet<?> newBeanSet = (BeanSet<?>) bc;
+
+    Set<?> current = (Set<?>) many.getValue(parentBean);
+
+    newBeanSet.setModifyListening(many.getModifyListenMode());
+    if (current == null) {
+      // the currentList is null?  Not really expecting this...
+      many.setValue(parentBean, newBeanSet);
+
+    } else if (current instanceof BeanSet<?>) {
+      // normally this case, replace just the underlying list
+      BeanSet<?> currentBeanSet = (BeanSet<?>) current;
+      currentBeanSet.setActualSet(newBeanSet.getActualSet());
+      currentBeanSet.setModifyListening(many.getModifyListenMode());
+
+    } else {
+      // replace the entire set
+      many.setValue(parentBean, newBeanSet);
+    }
+  }
+
+  @Override
+  public void jsonWrite(WriteJson ctx, String name, Object collection, boolean explicitInclude) throws IOException {
+
+    Set<?> set;
+    if (collection instanceof BeanCollection<?>) {
+      BeanSet<?> bc = (BeanSet<?>) collection;
+      if (!bc.isPopulated()) {
+        if (explicitInclude) {
+          // invoke lazy loading as collection
+          // is explicitly included in the output
+          bc.size();
+        } else {
+          return;
+        }
+      }
+      set = bc.getActualSet();
+    } else {
+      set = (Set<?>) collection;
+    }
+
+    ctx.writeStartArray(name);
+    Iterator<?> it = set.iterator();
+    while (it.hasNext()) {
+      targetDescriptor.jsonWrite(ctx, (EntityBean) it.next());
+    }
+    ctx.writeEndArray();
+  }
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/ChainedBeanPersistListener.java

@@ -9,24 +9,30 @@ import com.avaje.ebean.event.BeanPersistListener;
 /**
  * Handles multiple BeanPersistListener's for a given entity type.
  */
-public class ChainedBeanPersistListener<T> implements BeanPersistListener<T> {
+public class ChainedBeanPersistListener implements BeanPersistListener {
 
-	private final List<BeanPersistListener<T>> list;
+	private final List<BeanPersistListener> list;
 	
-	private final BeanPersistListener<T>[] chain;
+	private final BeanPersistListener[] chain;
 	
 	/**
 	 * Construct adding 2 BeanPersistController's.
 	 */
-	public ChainedBeanPersistListener(BeanPersistListener<T> c1, BeanPersistListener<T> c2) {
+	public ChainedBeanPersistListener(BeanPersistListener c1, BeanPersistListener c2) {
 		this(addList(c1, c2));
 	}
-	
-	/**
+
+  @Override
+  public boolean isRegisterFor(Class<?> cls) {
+    // never called
+    return false;
+  }
+
+  /**
 	 * Helper method used to create a list from 2 BeanPersistListener.
 	 */
-	private static <T> List<BeanPersistListener<T>> addList(BeanPersistListener<T> c1, BeanPersistListener<T> c2) {
-		ArrayList<BeanPersistListener<T>> addList = new ArrayList<BeanPersistListener<T>>(2);
+	private static List<BeanPersistListener> addList(BeanPersistListener c1, BeanPersistListener c2) {
+		ArrayList<BeanPersistListener> addList = new ArrayList<BeanPersistListener>(2);
 		addList.add(c1);
 		addList.add(c2);
 		return addList;
@@ -36,8 +42,7 @@ public class ChainedBeanPersistListener<T> implements BeanPersistListener<T> {
 	 * Construct given the list of BeanPersistController's.
 	 * @param list
 	 */
-	@SuppressWarnings("unchecked")
-	public ChainedBeanPersistListener(List<BeanPersistListener<T>> list) {
+	public ChainedBeanPersistListener(List<BeanPersistListener> list) {
 		this.list = list;
 		this.chain = list.toArray(new BeanPersistListener[list.size()]);
 	}
@@ -45,35 +50,35 @@ public class ChainedBeanPersistListener<T> implements BeanPersistListener<T> {
 	/**
 	 * Register a new BeanPersistController and return the resulting chain.
 	 */
-	public ChainedBeanPersistListener<T> register(BeanPersistListener<T> c) {
+	public ChainedBeanPersistListener register(BeanPersistListener c) {
 		if (list.contains(c)){
 			return this;
 		} else {
-			List<BeanPersistListener<T>> newList = new ArrayList<BeanPersistListener<T>>();
+			List<BeanPersistListener> newList = new ArrayList<BeanPersistListener>();
 			newList.addAll(list);
 			newList.add(c);
 			
-			return new ChainedBeanPersistListener<T>(newList);
+			return new ChainedBeanPersistListener(newList);
 		}
 	}
 	
 	/**
 	 * De-register a BeanPersistController and return the resulting chain.
 	 */
-	public ChainedBeanPersistListener<T> deregister(BeanPersistListener<T> c) {
+	public ChainedBeanPersistListener deregister(BeanPersistListener c) {
 		if (!list.contains(c)){
 			return this;
 		} else {
-			ArrayList<BeanPersistListener<T>> newList = new ArrayList<BeanPersistListener<T>>();
+			ArrayList<BeanPersistListener> newList = new ArrayList<BeanPersistListener>();
 			newList.addAll(list);
 			newList.remove(c);
 			
-			return new ChainedBeanPersistListener<T>(newList);
+			return new ChainedBeanPersistListener(newList);
 		}
 	}
 
 
-	public boolean deleted(T bean) {
+	public boolean deleted(Object bean) {
 		boolean notifyCluster = false;
 		for (int i = 0; i < chain.length; i++) {
 			if (chain[i].deleted(bean)) {
@@ -83,7 +88,7 @@ public class ChainedBeanPersistListener<T> implements BeanPersistListener<T> {
 		return notifyCluster;
 	}
 
-	public boolean inserted(T bean) {
+	public boolean inserted(Object bean) {
 		boolean notifyCluster = false;
 		for (int i = 0; i < chain.length; i++) {
 			if (chain[i].inserted(bean)) {
@@ -111,7 +116,7 @@ public class ChainedBeanPersistListener<T> implements BeanPersistListener<T> {
 		}
 	}
 
-	public boolean updated(T bean, Set<String> updatedProperties) {
+	public boolean updated(Object bean, Set<String> updatedProperties) {
 		boolean notifyCluster = false;
 		for (int i = 0; i < chain.length; i++) {
 			if (chain[i].updated(bean, updatedProperties)) {

src/main/java/com/avaje/ebeaninternal/server/deploy/DRawSqlSelect.java

@@ -122,10 +122,6 @@ public class DRawSqlSelect {
 	 */
 	private SqlTree buildSqlTree(BeanDescriptor<?> desc){
 
-
-		SqlTree sqlTree = new SqlTree();
-		sqlTree.setSummary(desc.getName());
-
 		LinkedHashSet<String> includedProps = new LinkedHashSet<String>();
 		SqlTreeProperties selectProps = new SqlTreeProperties();
 
@@ -157,9 +153,8 @@ public class DRawSqlSelect {
 		}
 
 		SqlTreeNode sqlRoot = new SqlTreeNodeRoot(desc, selectProps, null, withId);
-		sqlTree.setRootNode(sqlRoot);
 
-		return sqlTree;
+    return new SqlTree(desc.getName(), sqlRoot);
 	}
 
 	/**

src/main/java/com/avaje/ebeaninternal/server/deploy/PersistListenerManager.java

@@ -18,7 +18,7 @@ public class PersistListenerManager {
 
 	private static final Logger logger = LoggerFactory.getLogger(PersistListenerManager.class);
 
-	private final List<BeanPersistListener<?>> list;
+	private final List<BeanPersistListener> list;
 
 	public PersistListenerManager(BootupClasses bootupClasses) {
 		list = bootupClasses.getBeanPersistListeners();
@@ -31,37 +31,15 @@ public class PersistListenerManager {
 	/**
 	 * Return the BeanPersistController for a given entity type.
 	 */
-	@SuppressWarnings("unchecked")
 	public <T> void addPersistListeners(DeployBeanDescriptor<T> deployDesc) {
 
 		for (int i = 0; i < list.size(); i++) {
-			BeanPersistListener<?> c = list.get(i);
-			if (isRegisterFor(deployDesc.getBeanType(), c)) {
-				logger.debug("BeanPersistListener on[" + deployDesc.getFullName() + "] " + c.getClass().getName());
-				deployDesc.addPersistListener((BeanPersistListener<T>) c);
+			BeanPersistListener listener = list.get(i);
+      if (listener.isRegisterFor(deployDesc.getBeanType())) {
+				logger.debug("BeanPersistListener on[{}] {}", deployDesc.getFullName(), listener.getClass().getName());
+				deployDesc.addPersistListener(listener);
 			}
 		}
 	}
 
-	public static boolean isRegisterFor(Class<?> beanType, BeanPersistListener<?> c) {
-		Class<?> listenerEntity = getEntityClass(c.getClass());
-		return beanType.equals(listenerEntity);
-	}
-	
-	/**
-	 * Find the entity class given the controller class.
-	 * <p>
-	 * This uses reflection to find the generics parameter type.
-	 * </p>
-	 */
-	private static Class<?> getEntityClass(Class<?> controller) {
-
-		Class<?> cls = ParamTypeUtil.findParamType(controller, BeanPersistListener.class);
-		if (cls == null) {
-			String msg = "Could not determine the entity class (generics parameter type) from " + controller
-					+ " using reflection.";
-			throw new PersistenceException(msg);
-		}
-		return cls;
-	}
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/generatedproperty/GeneratedInsertJavaTime.java

@@ -0,0 +1,78 @@
+package com.avaje.ebeaninternal.server.deploy.generatedproperty;
+
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZonedDateTime;
+
+/**
+ * Support java.time types as GeneratedProperty.
+ */
+public class GeneratedInsertJavaTime {
+
+  public static abstract class Base implements GeneratedProperty {
+
+    @Override
+    public boolean includeInUpdate() {
+      return false;
+    }
+
+    @Override
+    public boolean includeInAllUpdates() {
+      return false;
+    }
+
+    @Override
+    public boolean includeInInsert() {
+      return true;
+    }
+
+    @Override
+    public boolean isDDLNotNullable() {
+      return true;
+    }
+
+    @Override
+    public Object getUpdateValue(BeanProperty prop, EntityBean bean) {
+      return prop.getValue(bean);
+    }
+  }
+
+  /**
+   * LocalDateTime support.
+   */
+  public static class LocalDT extends Base {
+
+    @Override
+    public Object getInsertValue(BeanProperty prop, EntityBean bean) {
+      return LocalDateTime.now();
+    }
+  }
+
+  /**
+   * OffsetDateTime support.
+   */
+  public static class OffsetDT extends Base {
+
+    @Override
+    public Object getInsertValue(BeanProperty prop, EntityBean bean) {
+      return OffsetDateTime.now();
+    }
+
+  }
+
+  /**
+   * ZonedDateTime support.
+   */
+  public static class ZonedDT extends Base {
+
+    @Override
+    public Object getInsertValue(BeanProperty prop, EntityBean bean) {
+      return ZonedDateTime.now();
+    }
+
+  }
+
+}

src/main/java/com/avaje/ebeaninternal/server/deploy/generatedproperty/GeneratedUpdateJavaTime.java

@@ -0,0 +1,86 @@
+package com.avaje.ebeaninternal.server.deploy.generatedproperty;
+
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebeaninternal.server.deploy.BeanProperty;
+
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZonedDateTime;
+
+/**
+ * Support java.time DateTime types as GeneratedProperty.
+ */
+public class GeneratedUpdateJavaTime {
+
+  public static abstract class Base implements GeneratedProperty {
+
+    @Override
+    public boolean includeInUpdate() {
+      return true;
+    }
+
+    @Override
+    public boolean includeInAllUpdates() {
+      return true;
+    }
+
+    @Override
+    public boolean includeInInsert() {
+      return true;
+    }
+
+    @Override
+    public boolean isDDLNotNullable() {
+      return true;
+    }
+  }
+
+  /**
+   * LocalDateTime support.
+   */
+  public static class LocalDT extends Base {
+
+    @Override
+    public Object getInsertValue(BeanProperty prop, EntityBean bean) {
+      return LocalDateTime.now();
+    }
+
+    @Override
+    public Object getUpdateValue(BeanProperty prop, EntityBean bean) {
+      return LocalDateTime.now();
+    }
+  }
+
+  /**
+   * OffsetDateTime support.
+   */
+  public static class OffsetDT extends Base {
+
+    @Override
+    public Object getInsertValue(BeanProperty prop, EntityBean bean) {
+      return OffsetDateTime.now();
+    }
+
+    @Override
+    public Object getUpdateValue(BeanProperty prop, EntityBean bean) {
+      return OffsetDateTime.now();
+    }
+  }
+
+  /**
+   * ZonedDateTime support.
+   */
+  public static class ZonedDT extends Base {
+
+    @Override
+    public Object getInsertValue(BeanProperty prop, EntityBean bean) {
+      return ZonedDateTime.now();
+    }
+
+    @Override
+    public Object getUpdateValue(BeanProperty prop, EntityBean bean) {
+      return ZonedDateTime.now();
+    }
+  }
+
+}

src/main/java/com/avaje/ebeaninternal/server/deploy/generatedproperty/InsertTimestampFactory.java

@@ -1,9 +1,15 @@
 package com.avaje.ebeaninternal.server.deploy.generatedproperty;
 
 import java.sql.Timestamp;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZonedDateTime;
+import java.util.HashMap;
+import java.util.Map;
 
 import javax.persistence.PersistenceException;
 
+import com.avaje.ebeaninternal.api.ClassUtil;
 import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanProperty;
 
 /**
@@ -11,12 +17,23 @@ import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanProperty;
  */
 public class InsertTimestampFactory {
 
-	final GeneratedInsertTimestamp timestamp = new GeneratedInsertTimestamp();
-
-	final GeneratedInsertDate utilDate = new GeneratedInsertDate();
-
 	final GeneratedInsertLong longTime = new GeneratedInsertLong();
 
+  Map<Class<?>, GeneratedProperty> map = new HashMap<Class<?>, GeneratedProperty>();
+
+  public InsertTimestampFactory() {
+    map.put(Timestamp.class, new GeneratedInsertTimestamp());
+    map.put(java.util.Date.class, new GeneratedInsertDate());
+    map.put(Long.class, longTime);
+    map.put(long.class, longTime);
+
+    if (ClassUtil.isPresent("java.time.LocalDate", this.getClass())) {
+      map.put(LocalDateTime.class, new GeneratedInsertJavaTime.LocalDT());
+      map.put(OffsetDateTime.class, new GeneratedInsertJavaTime.OffsetDT());
+      map.put(ZonedDateTime.class, new GeneratedInsertJavaTime.ZonedDT());
+    }
+  }
+
 	public void setInsertTimestamp(DeployBeanProperty property) {
 
 		property.setGeneratedProperty(createInsertTimestamp(property));
@@ -28,20 +45,12 @@ public class InsertTimestampFactory {
 	public GeneratedProperty createInsertTimestamp(DeployBeanProperty property) {
 		
 		Class<?> propType = property.getPropertyType();
-		if (propType.equals(Timestamp.class)) {
-			return timestamp;
-		}
-		if (propType.equals(java.util.Date.class)) {
-			return utilDate;
-		}
-		if (propType.equals(Long.class) || propType.equals(long.class)) {
-			return longTime;
-		}
-		
-		//TODO: Support JODA Time objects ... perhaps others?
-		
-		String msg = "Generated Insert Timestamp not supported on "+propType.getName();
-		throw new PersistenceException(msg);
+    GeneratedProperty generatedProperty = map.get(propType);
+    if (generatedProperty != null) {
+      return generatedProperty;
+    }
+
+		throw new PersistenceException("Generated Insert Timestamp not supported on "+propType.getName());
 	}
 	
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/generatedproperty/UpdateTimestampFactory.java

@@ -1,9 +1,15 @@
 package com.avaje.ebeaninternal.server.deploy.generatedproperty;
 
 import java.sql.Timestamp;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZonedDateTime;
+import java.util.HashMap;
+import java.util.Map;
 
 import javax.persistence.PersistenceException;
 
+import com.avaje.ebeaninternal.api.ClassUtil;
 import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanProperty;
 
 /**
@@ -11,12 +17,23 @@ import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanProperty;
  */
 public class UpdateTimestampFactory {
 
-	final GeneratedUpdateTimestamp timestamp = new GeneratedUpdateTimestamp();
-
-	final GeneratedUpdateDate utilDate = new GeneratedUpdateDate();
-
 	final GeneratedUpdateLong longTime = new GeneratedUpdateLong();
 
+  Map<Class<?>, GeneratedProperty> map = new HashMap<Class<?>, GeneratedProperty>();
+
+  public UpdateTimestampFactory() {
+    map.put(Timestamp.class, new GeneratedUpdateTimestamp());
+    map.put(java.util.Date.class, new GeneratedUpdateDate());
+    map.put(Long.class, longTime);
+    map.put(long.class, longTime);
+
+    if (ClassUtil.isPresent("java.time.LocalDate", this.getClass())) {
+      map.put(LocalDateTime.class, new GeneratedUpdateJavaTime.LocalDT());
+      map.put(OffsetDateTime.class, new GeneratedUpdateJavaTime.OffsetDT());
+      map.put(ZonedDateTime.class, new GeneratedUpdateJavaTime.ZonedDT());
+    }
+  }
+
 	public void setUpdateTimestamp(DeployBeanProperty property) {
 
 		property.setGeneratedProperty(createUpdateTimestamp(property));
@@ -25,23 +42,15 @@ public class UpdateTimestampFactory {
 	/**
 	 * Create the update GeneratedProperty depending on the property type.
 	 */
-	private GeneratedProperty createUpdateTimestamp(DeployBeanProperty property) {
-		
-		Class<?> propType = property.getPropertyType();
-		if (propType.equals(Timestamp.class)) {
-			return timestamp;
-		}
-		if (propType.equals(java.util.Date.class)) {
-			return utilDate;
-		}
-		if (propType.equals(Long.class) || propType.equals(long.class)) {
-			return longTime;
-		}
-		
-		//TODO: Support JODA Time objects ... perhaps others?
-		
-		String msg = "Generated update Timestamp not supported on "+propType.getName();
-		throw new PersistenceException(msg);
+	protected GeneratedProperty createUpdateTimestamp(DeployBeanProperty property) {
+
+    Class<?> propType = property.getPropertyType();
+    GeneratedProperty generatedProperty = map.get(propType);
+    if (generatedProperty != null) {
+      return generatedProperty;
+    }
+
+		throw new PersistenceException("Generated update Timestamp not supported on "+propType.getName());
 	}
 	
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/meta/DeployBeanDescriptor.java

@@ -36,7 +36,7 @@ import com.avaje.ebeaninternal.server.deploy.DRawSqlMeta;
 import com.avaje.ebeaninternal.server.deploy.DeployNamedQuery;
 import com.avaje.ebeaninternal.server.deploy.DeployNamedUpdate;
 import com.avaje.ebeaninternal.server.deploy.InheritInfo;
-import com.avaje.ebeaninternal.server.reflect.BeanReflect;
+import com.avaje.ebeaninternal.server.properties.BeanPropertyInfo;
 
 /**
  * Describes Beans including their deployment information.
@@ -112,11 +112,6 @@ public class DeployBeanDescriptor<T> {
 
   private List<CompoundUniqueContraint> compoundUniqueConstraints;
 
-  /**
-   * Extra deployment attributes.
-   */
-  private HashMap<String, String> extraAttrMap = new HashMap<String, String>();
-
   /**
    * The base database table.
    */
@@ -127,7 +122,7 @@ public class DeployBeanDescriptor<T> {
    * Used to provide mechanism to new EntityBean instances. Generated code
    * faster than reflection at this stage.
    */
-  private BeanReflect beanReflect;
+  private BeanPropertyInfo beanReflect;
   private String[] properties;
 
   /**
@@ -136,7 +131,7 @@ public class DeployBeanDescriptor<T> {
   private Class<T> beanType;
 
   private List<BeanPersistController> persistControllers = new ArrayList<BeanPersistController>(2);
-  private List<BeanPersistListener<T>> persistListeners = new ArrayList<BeanPersistListener<T>>(2);
+  private List<BeanPersistListener> persistListeners = new ArrayList<BeanPersistListener>(2);
   private List<BeanQueryAdapter> queryAdapters = new ArrayList<BeanQueryAdapter>(2);
 
   private CacheOptions cacheOptions = new CacheOptions();
@@ -302,7 +297,7 @@ public class DeployBeanDescriptor<T> {
     this.properties = props;
   }
 
-  public BeanReflect getBeanReflect() {
+  public BeanPropertyInfo getBeanReflect() {
     return beanReflect;
   }
 
@@ -317,7 +312,7 @@ public class DeployBeanDescriptor<T> {
    * Set the BeanReflect used to create new instances of an EntityBean. This
    * could use reflection or code generation to do this.
    */
-  public void setBeanReflect(BeanReflect beanReflect) {
+  public void setBeanReflect(BeanPropertyInfo beanReflect) {
     this.beanReflect = beanReflect;
   }
 
@@ -445,13 +440,13 @@ public class DeployBeanDescriptor<T> {
   /**
    * Return the BeanPersistListener (could be a chain of them, 1 or null).
    */
-  public BeanPersistListener<T> getPersistListener() {
+  public BeanPersistListener getPersistListener() {
     if (persistListeners.size() == 0) {
       return null;
     } else if (persistListeners.size() == 1) {
       return persistListeners.get(0);
     } else {
-      return new ChainedBeanPersistListener<T>(persistListeners);
+      return new ChainedBeanPersistListener(persistListeners);
     }
   }
 
@@ -472,7 +467,7 @@ public class DeployBeanDescriptor<T> {
     persistControllers.add(controller);
   }
 
-  public void addPersistListener(BeanPersistListener<T> listener) {
+  public void addPersistListener(BeanPersistListener listener) {
     persistListeners.add(listener);
   }
 
@@ -542,29 +537,6 @@ public class DeployBeanDescriptor<T> {
     return propMap.get(propName);
   }
 
-  public Map<String, String> getExtraAttributeMap() {
-    return extraAttrMap;
-  }
-
-  /**
-   * Get a named extra attribute.
-   */
-  public String getExtraAttribute(String key) {
-    return (String) extraAttrMap.get(key);
-  }
-
-  /**
-   * Set an extra attribute with a given name.
-   * 
-   * @param key
-   *          the name of the extra attribute
-   * @param value
-   *          the value of the extra attribute
-   */
-  public void setExtraAttribute(String key, String value) {
-    extraAttrMap.put(key, value);
-  }
-
   /**
    * Return the bean class name this descriptor is used for.
    * <p>

src/main/java/com/avaje/ebeaninternal/server/deploy/meta/DeployBeanProperty.java

@@ -20,8 +20,8 @@ import com.avaje.ebeaninternal.server.core.InternString;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor.EntityType;
 import com.avaje.ebeaninternal.server.deploy.generatedproperty.GeneratedProperty;
 import com.avaje.ebeaninternal.server.el.ElPropertyValue;
-import com.avaje.ebeaninternal.server.reflect.BeanReflectGetter;
-import com.avaje.ebeaninternal.server.reflect.BeanReflectSetter;
+import com.avaje.ebeaninternal.server.properties.BeanPropertyGetter;
+import com.avaje.ebeaninternal.server.properties.BeanPropertySetter;
 import com.avaje.ebeaninternal.server.type.ScalarType;
 import com.avaje.ebeaninternal.server.type.ScalarTypeEnum;
 import com.avaje.ebeaninternal.server.type.ScalarTypeWrapper;
@@ -202,9 +202,9 @@ public class DeployBeanProperty {
 
     private int propertyIndex;
     
-    private BeanReflectGetter getter;
+    private BeanPropertyGetter getter;
 
-    private BeanReflectSetter setter;
+    private BeanPropertySetter setter;
 
     /**
      * Generator for insert or update timestamp etc.
@@ -414,7 +414,7 @@ public class DeployBeanProperty {
             ScalarTypeEnum etype = (ScalarTypeEnum) scalarType;
 
             // check dbColName IN ('A', 'I', 'D')
-            return "check (" + dbColumn + " in " + etype.getContraintInValues() + ")";
+            return "check (" + dbColumn + " in " + etype.getConstraintInValues() + ")";
         }
         return null;
     }
@@ -439,11 +439,11 @@ public class DeployBeanProperty {
       this.propertyIndex = propertyIndex;
     }
 
-    public BeanReflectGetter getGetter() {
+    public BeanPropertyGetter getGetter() {
         return getter;
     }
 
-    public BeanReflectSetter getSetter() {
+    public BeanPropertySetter getSetter() {
         return setter;
     }
 
@@ -482,14 +482,14 @@ public class DeployBeanProperty {
     /**
      * Set the getter used to read the property value from a bean.
      */
-    public void setGetter(BeanReflectGetter getter) {
+    public void setGetter(BeanPropertyGetter getter) {
         this.getter = getter;
     }
 
     /**
      * Set the setter used to set the property value to a bean.
      */
-    public void setSetter(BeanReflectSetter setter) {
+    public void setSetter(BeanPropertySetter setter) {
         this.setter = setter;
     }
 

src/main/java/com/avaje/ebeaninternal/server/deploy/meta/DeployBeanPropertyCompound.java

@@ -21,99 +21,99 @@ import com.avaje.ebeaninternal.server.type.ScalarType;
  */
 public class DeployBeanPropertyCompound extends DeployBeanProperty {
 
-    final CtCompoundType<?> compoundType;
+  final CtCompoundType<?> compoundType;
 
-    final ScalarTypeConverter<?, ?> typeConverter;
+  final ScalarTypeConverter<?, ?> typeConverter;
 
-	DeployBeanEmbedded deployEmbedded;
-		
-	/**
-	 * Create the property.
-	 */
-	public DeployBeanPropertyCompound(DeployBeanDescriptor<?> desc, Class<?> targetType, 
-	        CtCompoundType<?> compoundType, ScalarTypeConverter<?, ?> typeConverter) {
-	    
-		super(desc, targetType, null, null);
-		this.compoundType = compoundType;
-		this.typeConverter = typeConverter;
-	}
+  DeployBeanEmbedded deployEmbedded;
 
-	public BeanPropertyCompoundRoot getFlatProperties(BeanDescriptorMap owner, BeanDescriptor<?> descriptor) {
-	    
-	    // get a 'flat' list of all the scalar types, their relative property names
-	    // and also set their matching dbColumn 
-	    
-	    // represents the root property
-	    BeanPropertyCompoundRoot rootProperty = new BeanPropertyCompoundRoot(this);
-	    
-	    // Walk the tree of a compound type collecting the 
-	    // scalar types and non-scalar properties
-	    CtCompoundTypeScalarList ctMeta = new CtCompoundTypeScalarList();
-	    
-	    compoundType.accumulateScalarTypes(null, ctMeta);
-	    
-	    List<BeanProperty> beanPropertyList = new ArrayList<BeanProperty>();
-	    
-	    
-	    // for each of the scalar types inside a compound value object
-	    // build a BeanPropertyCompoundScalar with appropriate deployment
-	    // information. 
-	    
-	    for (Entry<String, ScalarType<?>> entry : ctMeta.entries()) {
+  /**
+   * Create the property.
+   */
+  public DeployBeanPropertyCompound(DeployBeanDescriptor<?> desc, Class<?> targetType,
+                                    CtCompoundType<?> compoundType, ScalarTypeConverter<?, ?> typeConverter) {
 
-	        String relativePropertyName = entry.getKey();
-	        ScalarType<?> scalarType = entry.getValue();
-	        
-	        CtCompoundProperty ctProp = ctMeta.getCompoundType(relativePropertyName);
-	        
-	        
-	        String dbColumn = relativePropertyName.replace(".", "_");
-	        dbColumn = getDbColumn(relativePropertyName, dbColumn);
-	        
-	        DeployBeanProperty deploy = new DeployBeanProperty(null, scalarType.getType(), scalarType, null);
-	        deploy.setScalarType(scalarType);
-	        deploy.setDbColumn(dbColumn);
-	        deploy.setName(relativePropertyName);
-	        deploy.setDbInsertable(true);
-	        deploy.setDbUpdateable(true);
-	        deploy.setDbRead(true);
-	        
-	        BeanPropertyCompoundScalar bp = new BeanPropertyCompoundScalar(rootProperty, deploy, ctProp, typeConverter);
-	        beanPropertyList.add(bp);
-	        
-	        rootProperty.register(bp);
-	    }
-	    
-	    rootProperty.setNonScalarProperties(ctMeta.getNonScalarProperties());
-	    return rootProperty;
-	}
-	
-	private String getDbColumn(String propName, String defaultDbColumn){
-	    if (deployEmbedded == null){
-	        return defaultDbColumn;
-	    }
-	    String dbColumn = deployEmbedded.getPropertyColumnMap().get(propName);
-	    return dbColumn == null ? defaultDbColumn : dbColumn;
-	}
-	
-	/**
-	 * Return the deploy information specifically for the deployment
-	 * of Embedded beans.
-	 */
-	public DeployBeanEmbedded getDeployEmbedded() {
-		// deployment should be single threaded 
-		if (deployEmbedded == null){
-			deployEmbedded = new DeployBeanEmbedded();
-		}
-		return deployEmbedded;
-	}
+    super(desc, targetType, null, null);
+    this.compoundType = compoundType;
+    this.typeConverter = typeConverter;
+  }
 
-    public ScalarTypeConverter<?, ?> getTypeConverter() {
-        return typeConverter;
+  public BeanPropertyCompoundRoot getFlatProperties(BeanDescriptorMap owner, BeanDescriptor<?> descriptor) {
+
+    // get a 'flat' list of all the scalar types, their relative property names
+    // and also set their matching dbColumn
+
+    // represents the root property
+    BeanPropertyCompoundRoot rootProperty = new BeanPropertyCompoundRoot(this);
+
+    // Walk the tree of a compound type collecting the
+    // scalar types and non-scalar properties
+    CtCompoundTypeScalarList ctMeta = new CtCompoundTypeScalarList();
+
+    compoundType.accumulateScalarTypes(null, ctMeta);
+
+    List<BeanProperty> beanPropertyList = new ArrayList<BeanProperty>();
+
+
+    // for each of the scalar types inside a compound value object
+    // build a BeanPropertyCompoundScalar with appropriate deployment
+    // information.
+
+    for (Entry<String, ScalarType<?>> entry : ctMeta.entries()) {
+
+      String relativePropertyName = entry.getKey();
+      ScalarType<?> scalarType = entry.getValue();
+
+      CtCompoundProperty ctProp = ctMeta.getCompoundType(relativePropertyName);
+
+
+      String dbColumn = (getName() + "." + relativePropertyName).replace(".", "_");
+      dbColumn = getDbColumn(relativePropertyName, dbColumn);
+
+      DeployBeanProperty deploy = new DeployBeanProperty(null, scalarType.getType(), scalarType, null);
+      deploy.setScalarType(scalarType);
+      deploy.setDbColumn(dbColumn);
+      deploy.setName(relativePropertyName);
+      deploy.setDbInsertable(true);
+      deploy.setDbUpdateable(true);
+      deploy.setDbRead(true);
+
+      BeanPropertyCompoundScalar bp = new BeanPropertyCompoundScalar(rootProperty, deploy, ctProp, typeConverter);
+      beanPropertyList.add(bp);
+
+      rootProperty.register(bp);
     }
 
-    public CtCompoundType<?> getCompoundType() {
-        return compoundType;
+    rootProperty.setNonScalarProperties(ctMeta.getNonScalarProperties());
+    return rootProperty;
+  }
+
+  private String getDbColumn(String propName, String defaultDbColumn) {
+    if (deployEmbedded == null) {
+      return defaultDbColumn;
     }
+    String dbColumn = deployEmbedded.getPropertyColumnMap().get(propName);
+    return dbColumn == null ? defaultDbColumn : dbColumn;
+  }
+
+  /**
+   * Return the deploy information specifically for the deployment
+   * of Embedded beans.
+   */
+  public DeployBeanEmbedded getDeployEmbedded() {
+    // deployment should be single threaded
+    if (deployEmbedded == null) {
+      deployEmbedded = new DeployBeanEmbedded();
+    }
+    return deployEmbedded;
+  }
+
+  public ScalarTypeConverter<?, ?> getTypeConverter() {
+    return typeConverter;
+  }
+
+  public CtCompoundType<?> getCompoundType() {
+    return compoundType;
+  }
 
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/parse/DeployCreateProperties.java

@@ -93,7 +93,7 @@ public class DeployCreateProperties {
   }
 
   /**
-   * reflect the bean properties from Class. Some of these properties may not map to database
+   * properties the bean properties from Class. Some of these properties may not map to database
    * columns.
    */
   private void createProperties(DeployBeanDescriptor<?> desc, Class<?> beanType, int level) {
@@ -125,7 +125,7 @@ public class DeployCreateProperties {
           Method getter = findGetter(field, initFieldName, declaredMethods, scalaObject);
           Method setter = findSetter(field, initFieldName, declaredMethods, scalaObject);
 
-          DeployBeanProperty prop = createProp(level, desc, field, beanType, getter, setter);
+          DeployBeanProperty prop = createProp(desc, field, beanType, getter, setter);
           if (prop == null) {
             // transient annotation on unsupported type
 
@@ -152,7 +152,7 @@ public class DeployCreateProperties {
       Class<?> superClass = beanType.getSuperclass();
 
       if (!superClass.equals(Object.class)) {
-        // recursively add any properties in the inheritance heirarchy
+        // recursively add any properties in the inheritance hierarchy
         // up to the Object.class level...
         createProperties(desc, superClass, level + 1);
       }
@@ -361,7 +361,7 @@ public class DeployCreateProperties {
 
     if (field.getAnnotation(ColumnHstore.class) != null) {
       return ScalarTypePostgresHstore.KEY;
-    };
+    }
     
     return null;
   }
@@ -372,7 +372,7 @@ public class DeployCreateProperties {
     return (t != null);
   }
 
-  private DeployBeanProperty createProp(int level, DeployBeanDescriptor<?> desc, Field field, Class<?> beanType,
+  private DeployBeanProperty createProp(DeployBeanDescriptor<?> desc, Field field, Class<?> beanType,
       Method getter, Method setter) {
 
     DeployBeanProperty prop = createProp(desc, field);

src/main/java/com/avaje/ebeaninternal/server/el/ElPropertyChain.java

@@ -215,7 +215,7 @@ public class ElPropertyChain implements ElPropertyValue {
     }
 
 	public Object parseDateTime(long systemTimeMillis) {
-		return scalarType.parseDateTime(systemTimeMillis);
+		return scalarType.convertFromMillis(systemTimeMillis);
 	}
 
 	public StringParser getStringParser() {

src/main/java/com/avaje/ebeaninternal/server/expression/JunctionExpression.java

@@ -218,6 +218,16 @@ abstract class JunctionExpression<T> implements Junction<T>, SpiExpression, Expr
     return exprList.findIds();
   }
 
+  @Override
+  public void findEach(QueryEachConsumer<T> consumer) {
+    exprList.findEach(consumer);
+  }
+
+  @Override
+  public void findEachWhile(QueryEachWhileConsumer<T> consumer) {
+    exprList.findEachWhile(consumer);
+  }
+
   public void findVisit(QueryResultVisitor<T> visitor) {
     exprList.findVisit(visitor);
   }
@@ -323,14 +333,6 @@ abstract class JunctionExpression<T> implements Junction<T>, SpiExpression, Expr
     return exprList.istartsWith(propertyName, value);
   }
 
-  public com.avaje.ebean.Query<T> join(String assocProperty, String assocProperties) {
-    return exprList.join(assocProperty, assocProperties);
-  }
-
-  public com.avaje.ebean.Query<T> join(String assocProperties) {
-    return exprList.join(assocProperties);
-  }
-
   public ExpressionList<T> le(String propertyName, Object value) {
     return exprList.le(propertyName, value);
   }

src/main/java/com/avaje/ebeaninternal/server/jmx/MAdminAutofetchMBean.java

@@ -26,7 +26,7 @@ public interface MAdminAutofetchMBean {
 
 	/**
 	 * This controls whether autoFetch is used when it has not
-	 * been explicitly set on a query via {@link Query#setAutoFetch(boolean)}.
+	 * been explicitly set on a query via {@link Query#setAutofetch(boolean)}.
 	 */
 	public String getMode();
 
@@ -36,7 +36,7 @@ public interface MAdminAutofetchMBean {
 	public String getModeOptions();
 	
 	/**
-	 * Set the auto fetch mode used when a query has not had {@link Query#setAutoFetch(boolean)}.
+	 * Set the auto fetch mode used when a query has not had {@link Query#setAutofetch(boolean)}.
 	 */
 	public void setMode(String mode);
 

src/main/java/com/avaje/ebeaninternal/server/loadcontext/DLoadBeanContext.java

@@ -69,7 +69,7 @@ public class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContex
     return buffer;
 	}
 	
-  public void loadSecondaryQuery(OrmQueryRequest<?> parentRequest, int requestedBatchSize, boolean all) {
+  public void loadSecondaryQuery(OrmQueryRequest<?> parentRequest) {
 
     if (!queryFetch) {
       throw new IllegalStateException("Not expecting loadSecondaryQuery() to be called?");
@@ -111,7 +111,11 @@ public class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContex
       this.batchSize = batchSize;
       this.list = new ArrayList<EntityBeanIntercept>(batchSize);
     }
-    
+
+    public int getBatchSize() {
+      return batchSize;
+    }
+
     /**
      * Return true if the buffer is full.
      */

src/main/java/com/avaje/ebeaninternal/server/loadcontext/DLoadContext.java

@@ -56,7 +56,7 @@ public class DLoadContext implements LoadContext {
 
 	  this.persistenceContext = request.getPersistenceContext();
     this.ebeanServer = request.getServer();
-    this.defaultBatchSize = ebeanServer.getLazyLoadBatchSize();
+    this.defaultBatchSize = request.getLazyLoadBatchSize();
     this.rootDescriptor = request.getBeanDescriptor();
     
     SpiQuery<?> query = request.getQuery();
@@ -104,18 +104,13 @@ public class DLoadContext implements LoadContext {
 	/**
 	 * Execute all the secondary queries.
 	 */
-	public void executeSecondaryQueries(OrmQueryRequest<?> parentRequest, int defaultQueryBatch) {
+	public void executeSecondaryQueries(OrmQueryRequest<?> parentRequest) {
 		
 		if (secQuery != null){
 			for (int i = 0; i < secQuery.size(); i++) {
 				OrmQueryProperties properties = secQuery.get(i);
-				
-				int batchSize = properties.getQueryFetchBatch();
-				if (batchSize == 0){
-					batchSize = defaultQueryBatch;
-				}
 				LoadSecondaryQuery load = getLoadSecondaryQuery(properties.getPath());
-				load.loadSecondaryQuery(parentRequest, batchSize, properties.isQueryFetchAll());
+				load.loadSecondaryQuery(parentRequest);
 			}
 		}
 	}
@@ -201,10 +196,6 @@ public class DLoadContext implements LoadContext {
 		return useAutofetchManager;
 	}
 	
-	public String getRelativePath() {
-		return relativePath;
-	}
-	
 	protected String getFullPath(String path) {
     if (relativePath == null) {
       return path;

src/main/java/com/avaje/ebeaninternal/server/loadcontext/DLoadManyContext.java

@@ -83,8 +83,7 @@ public class DLoadManyContext extends DLoadBaseContext implements LoadManyContex
     bc.setLoader(0, currentBuffer);
 	}
 
-	
-	public void loadSecondaryQuery(OrmQueryRequest<?> parentRequest, int requestedBatchSize, boolean all){
+  public void loadSecondaryQuery(OrmQueryRequest<?> parentRequest) {
 
     if (!queryFetch) {
       throw new IllegalStateException("Not expecting loadSecondaryQuery() to be called?");
@@ -93,7 +92,7 @@ public class DLoadManyContext extends DLoadBaseContext implements LoadManyContex
       if (bufferList != null) {
         for (LoadBuffer loadBuffer : bufferList) {
           if (!loadBuffer.list.isEmpty()) {
-            LoadManyRequest req = new LoadManyRequest(loadBuffer, parentRequest, requestedBatchSize, false, false, false);
+            LoadManyRequest req = new LoadManyRequest(loadBuffer, parentRequest, false, false, false);
             parent.getEbeanServer().loadMany(req);  
             if (!queryProps.isQueryFetchAll()) {
               // Stop - only fetch the first batch ... the rest will be lazy loaded
@@ -127,6 +126,10 @@ public class DLoadManyContext extends DLoadBaseContext implements LoadManyContex
       this.batchSize = batchSize;
       this.list = new ArrayList<BeanCollection<?>>(batchSize);
     }
+
+    public int getBatchSize() {
+      return batchSize;
+    }
     
     /**
      * Return true if the buffer is full.
@@ -188,7 +191,7 @@ public class DLoadManyContext extends DLoadBaseContext implements LoadManyContex
         boolean useCache = context.hitCache && !onlyIds;
         if (useCache) {
           EntityBean ownerBean = bc.getOwnerBean();
-          BeanDescriptor<? extends Object> parentDesc = context.desc.getBeanDescriptor(ownerBean.getClass());
+          BeanDescriptor<?> parentDesc = context.desc.getBeanDescriptor(ownerBean.getClass());
           Object parentId = parentDesc.getId(ownerBean);
           if (parentDesc.cacheManyPropLoad(context.property, bc, parentId, context.parent.isReadOnly())) {
             // we loaded the bean from cache
@@ -199,7 +202,7 @@ public class DLoadManyContext extends DLoadBaseContext implements LoadManyContex
         
         // Should reduce the list by checking each beanCollection in the L2 first before executing the query
         
-        LoadManyRequest req = new LoadManyRequest(this, batchSize, true, onlyIds, useCache);
+        LoadManyRequest req = new LoadManyRequest(this, true, onlyIds, useCache);
         context.parent.getEbeanServer().loadMany(req);
       }
     }

src/main/java/com/avaje/ebeaninternal/server/persist/Binder.java

@@ -47,7 +47,7 @@ public class Binder {
 
 		ArrayList<BindValues.Value> list = bindValues.values();
 		for (int i = 0; i < list.size(); i++) {
-			BindValues.Value bindValue = (BindValues.Value) list.get(i);
+			BindValues.Value bindValue = list.get(i);
 			if (bindValue.isComment()) {
 				if (bindBuf != null) {
 					bindBuf.append(bindValue.getName());
@@ -226,14 +226,12 @@ public class Binder {
 		try {
 			switch (dataType) {
 			case java.sql.Types.BOOLEAN:
-				Boolean bo = (Boolean) data;
-				b.setBoolean(bo.booleanValue());
+				b.setBoolean((Boolean) data);
 				break;
-            case java.sql.Types.BIT:
-                // Types.BIT should map to Java Boolean
-                Boolean bitBool = (Boolean) data;
-                b.setBoolean(bitBool.booleanValue());
-                break;				
+      case java.sql.Types.BIT:
+        // Types.BIT should map to Java Boolean
+        b.setBoolean((Boolean) data);
+        break;
 
 			case java.sql.Types.VARCHAR:
 				b.setString((String) data);
@@ -244,32 +242,32 @@ public class Binder {
 				break;
 				
 			case java.sql.Types.TINYINT:
-				b.setByte(((Byte) data).byteValue());
+				b.setByte((Byte) data);
 				break;
 
 			case java.sql.Types.SMALLINT:
-				b.setShort(((Short) data).shortValue());
+				b.setShort((Short) data);
 				break;
 
 			case java.sql.Types.INTEGER:
-				b.setInt(((Integer) data).intValue());
+				b.setInt((Integer) data);
 				break;
 
 			case java.sql.Types.BIGINT:
-				b.setLong(((Long) data).longValue());
+				b.setLong((Long) data);
 				break;
 
 			case java.sql.Types.REAL:
-				b.setFloat(((Float) data).floatValue());
+				b.setFloat((Float) data);
 				break;
 
 			case java.sql.Types.FLOAT:
 				// DB Float in theory maps to Java Double type
-				b.setDouble(((Double) data).doubleValue());
+				b.setDouble((Double) data);
 				break;
 
 			case java.sql.Types.DOUBLE:
-				b.setDouble(((Double) data).doubleValue());
+				b.setDouble((Double) data);
 				break;
 
 			case java.sql.Types.NUMERIC:

src/main/java/com/avaje/ebeaninternal/server/persist/ExeUpdateSql.java

@@ -98,6 +98,7 @@ public class ExeUpdateSql {
         
     	// process named parameters if required
     	sql = BindParamsParser.parse(bindParams, sql);
+      updateSql.setGeneratedSql(sql);
         
     	boolean logSql = request.isLogSql();
     	

src/main/java/com/avaje/ebeaninternal/server/persist/dmlbind/BindableCompound.java

@@ -14,40 +14,41 @@ import com.avaje.ebeaninternal.server.persist.dml.GenerateDmlRequest;
  */
 public class BindableCompound implements Bindable {
 
-    private final Bindable[] items;
+  private final BindableProperty[] items;
 
-    private final BeanPropertyCompound compound;
+  private final BeanPropertyCompound compound;
 
-    public BindableCompound(BeanPropertyCompound embProp, List<Bindable> list) {
-        this.compound = embProp;
-        this.items = list.toArray(new Bindable[list.size()]);
+  public BindableCompound(BeanPropertyCompound embProp, List<BindableProperty> list) {
+    this.compound = embProp;
+    this.items = list.toArray(new BindableProperty[list.size()]);
+  }
+
+  public String toString() {
+    return "BindableCompound " + compound + " items:" + Arrays.toString(items);
+  }
+
+  public void dmlAppend(GenerateDmlRequest request) {
+
+    for (int i = 0; i < items.length; i++) {
+      items[i].dmlAppend(request);
     }
+  }
 
-    public String toString() {
-        return "BindableCompound " + compound + " items:" + Arrays.toString(items);
+  public void addToUpdate(PersistRequestBean<?> request, List<Bindable> list) {
+    if (request.isAddToUpdate(compound)) {
+      list.add(this);
     }
+  }
 
-    public void dmlAppend(GenerateDmlRequest request) {
+  public void dmlBind(BindableRequest bindRequest, EntityBean bean) throws SQLException {
 
-        for (int i = 0; i < items.length; i++) {
-            items[i].dmlAppend(request);
-        }
-    }
+    // get the compound type value
+    Object valueObject = compound.getValue(bean);
 
-    public void addToUpdate(PersistRequestBean<?> request, List<Bindable> list) {
-        if (request.isAddToUpdate(compound)) {
-            list.add(this);
-        }
-    }
-
-    public void dmlBind(BindableRequest bindRequest, EntityBean bean) throws SQLException {
-
-      throw new RuntimeException("This is broken, need to break out the scalar values!!");
-      
-        //Object valueObject = compound.getValue(bean);
-        //for (int i = 0; i < items.length; i++) {
-        //    items[i].dmlBind(bindRequest, valueObject);
-        //}
+    // bind each of the underlying scalar values for this compound type
+    for (int i = 0; i < items.length; i++) {
+      items[i].dmlBindObject(bindRequest, valueObject);
     }
+  }
 
 }

src/main/java/com/avaje/ebeaninternal/server/persist/dmlbind/BindableProperty.java

@@ -13,33 +13,47 @@ import com.avaje.ebeaninternal.server.persist.dml.GenerateDmlRequest;
  */
 public class BindableProperty implements Bindable {
 
-    protected final BeanProperty prop;
+  protected final BeanProperty prop;
 
-    public BindableProperty(BeanProperty prop) {
-        this.prop = prop;
+  public BindableProperty(BeanProperty prop) {
+    this.prop = prop;
+  }
+
+  public String toString() {
+    return prop.toString();
+  }
+
+  public void addToUpdate(PersistRequestBean<?> request, List<Bindable> list) {
+    if (request.isAddToUpdate(prop)) {
+      list.add(this);
     }
+  }
 
-    public String toString() {
-        return prop.toString();
+  public void dmlAppend(GenerateDmlRequest request) {
+    request.appendColumn(prop.getDbColumn());
+  }
+
+  /**
+   * Normal binding of a property value from the bean.
+   */
+  public void dmlBind(BindableRequest request, EntityBean bean) throws SQLException {
+
+    Object value = null;
+    if (bean != null) {
+      value = prop.getValue(bean);
     }
+    request.bind(value, prop, prop.getName());
+  }
 
-    public void addToUpdate(PersistRequestBean<?> request, List<Bindable> list) {
-        if (request.isAddToUpdate(prop)) {
-            list.add(this);
-        }
-    }
+  /**
+   * For compound types bind one of the underlying scalar values for a compound type.
+   */
+  public void dmlBindObject(BindableRequest request, Object bean) throws SQLException {
 
-    public void dmlAppend(GenerateDmlRequest request) {
-        request.appendColumn(prop.getDbColumn());
-    }
-
-    public void dmlBind(BindableRequest request, EntityBean bean) throws SQLException {
-
-        Object value = null;
-        if (bean != null) {
-            value = prop.getValue(bean);
-        }
-        // value = prop.getDefaultValue();
-        request.bind(value, prop, prop.getName());
+    Object value = null;
+    if (bean != null) {
+      value = prop.getValueObject(bean);
     }
+    request.bind(value, prop, prop.getName());
+  }
 }

src/main/java/com/avaje/ebeaninternal/server/persist/dmlbind/FactoryBaseProperties.java

@@ -16,49 +16,52 @@ import com.avaje.ebeaninternal.server.persist.dml.DmlMode;
  */
 public class FactoryBaseProperties {
 
-	private final FactoryProperty factoryProperty;
-	
-	
-	public FactoryBaseProperties(boolean bindEncryptDataFirst) {
-		factoryProperty = new FactoryProperty(bindEncryptDataFirst);
-	}
+  private final FactoryProperty factoryProperty;
 
-	/**
-	 * Add Bindable for the base properties to the list.
-	 */
-	public void create(List<Bindable> list, BeanDescriptor<?> desc, DmlMode mode, boolean withLobs) {
 
-	    add(desc.propertiesBaseScalar(), list, desc, mode, withLobs);	    
+  public FactoryBaseProperties(boolean bindEncryptDataFirst) {
+    factoryProperty = new FactoryProperty(bindEncryptDataFirst);
+  }
 
-		BeanPropertyCompound[] compoundProps = desc.propertiesBaseCompound();
-		for (int i = 0; i < compoundProps.length; i++) {
-		    BeanProperty[] props = compoundProps[i].getScalarProperties();
+  /**
+   * Add Bindable for the base properties to the list.
+   */
+  public void create(List<Bindable> list, BeanDescriptor<?> desc, DmlMode mode, boolean withLobs) {
 
-		    ArrayList<Bindable> newList = new ArrayList<Bindable>(props.length);
-		    add(props, newList, desc, mode, withLobs);
-		    
-		    BindableCompound compoundBindable = new BindableCompound(compoundProps[i], newList);
+    add(desc.propertiesBaseScalar(), list, desc, mode, withLobs);
 
-		    list.add(compoundBindable);
-		}
-	}
+    BeanPropertyCompound[] compoundProps = desc.propertiesBaseCompound();
+    for (int i = 0; i < compoundProps.length; i++) {
+      BeanProperty[] props = compoundProps[i].getScalarProperties();
 
-    private void add(BeanProperty[] props, List<Bindable> list, BeanDescriptor<?> desc, DmlMode mode, boolean withLobs) {
+      List<BindableProperty> newList = new ArrayList<BindableProperty>(props.length);
+      addCompound(props, newList, desc, mode, withLobs);
 
-        for (int i = 0; i < props.length; i++) {
+      BindableCompound compoundBindable = new BindableCompound(compoundProps[i], newList);
 
-//          if(DmlMode.WHERE.equals(mode) && !withLobs && !props[i].isDbUpdatable()) {
-//            // skip non-updatable column from where clause
-//          } else {
-            Bindable item = factoryProperty.create(props[i], mode, withLobs);
-            if (item != null) {
-                list.add(item);
-            } else {
-                // null where readOnly (Secondary tables) or Lob exclusion
-            }
-//          }
-        }
+      list.add(compoundBindable);
+    }
+  }
 
+  private void add(BeanProperty[] props, List<Bindable> list, BeanDescriptor<?> desc, DmlMode mode, boolean withLobs) {
+
+    for (int i = 0; i < props.length; i++) {
+      Bindable item = factoryProperty.create(props[i], mode, withLobs);
+      if (item != null) {
+        list.add(item);
+      }
+    }
+  }
+
+  private void addCompound(BeanProperty[] props, List<BindableProperty> list, BeanDescriptor<?> desc, DmlMode mode, boolean withLobs) {
+
+    for (int i = 0; i < props.length; i++) {
+      BindableProperty item = (BindableProperty) factoryProperty.create(props[i], mode, withLobs);
+      if (item != null) {
+        list.add(item);
+      }
     }
 
+  }
+
 }

src/main/java/com/avaje/ebeaninternal/server/properties/BeanPropertiesReader.java

@@ -1,17 +1,20 @@
-package com.avaje.ebeaninternal.server.reflect;
+package com.avaje.ebeaninternal.server.properties;
 
 import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 
-public class BeanReflectProperties {
+/**
+ * Determines the properties on a given bean.
+ */
+public class BeanPropertiesReader {
 
   private final Map<String,Integer> propertyIndexMap = new HashMap<String,Integer>();
   
   private final String[] props;
   
-  public BeanReflectProperties(Class<?> clazz) {
+  public BeanPropertiesReader(Class<?> clazz) {
     this.props = getProperties(clazz);
     for (int i=0; i<props.length; i++) {
       propertyIndexMap.put(props[i], Integer.valueOf(i));

src/main/java/com/avaje/ebeaninternal/server/properties/BeanPropertyGetter.java

@@ -1,11 +1,11 @@
-package com.avaje.ebeaninternal.server.reflect;
+package com.avaje.ebeaninternal.server.properties;
 
 import com.avaje.ebean.bean.EntityBean;
 
 /**
  * The getter implementation for a given bean property.
  */
-public interface BeanReflectGetter {
+public interface BeanPropertyGetter {
 
 	/**
 	 * Return the value of a given bean property.

src/main/java/com/avaje/ebeaninternal/server/properties/BeanPropertyInfo.java

@@ -1,4 +1,4 @@
-package com.avaje.ebeaninternal.server.reflect;
+package com.avaje.ebeaninternal.server.properties;
 
 /**
  * Provides getter setter and construction methods for beans.
@@ -7,7 +7,7 @@ package com.avaje.ebeaninternal.server.reflect;
  * code generation.
  * </p>
  */
-public interface BeanReflect {
+public interface BeanPropertyInfo {
 
 	/**
 	 * Create an EntityBean for this type.
@@ -17,10 +17,10 @@ public interface BeanReflect {
 	/**
 	 * Return the getter for a given bean property.
 	 */
-	public BeanReflectGetter getGetter(String name, int position);
+	public BeanPropertyGetter getGetter(String name, int position);
 	
 	/**
 	 * Return the setter for a given bean property.
 	 */
-	public BeanReflectSetter getSetter(String name, int position);
+	public BeanPropertySetter getSetter(String name, int position);
 }

src/main/java/com/avaje/ebeaninternal/server/properties/BeanPropertyInfoFactory.java

@@ -1,14 +1,14 @@
-package com.avaje.ebeaninternal.server.reflect;
+package com.avaje.ebeaninternal.server.properties;
 
 
 /**
  * Creates BeanReflect object used to provide getter setter and construction
  * for the beans.
  */
-public interface BeanReflectFactory {
+public interface BeanPropertyInfoFactory {
 
 	/**
 	 * Create the BeanReflect for the given plain bean and its EntityBean equivalent.
 	 */
-	public BeanReflect create(Class<?> entityBeanType);
+	public BeanPropertyInfo create(Class<?> entityBeanType);
 }

src/main/java/com/avaje/ebeaninternal/server/properties/BeanPropertySetter.java

@@ -1,11 +1,11 @@
-package com.avaje.ebeaninternal.server.reflect;
+package com.avaje.ebeaninternal.server.properties;
 
 import com.avaje.ebean.bean.EntityBean;
 
 /**
  * The setter for a given bean property.
  */
-public interface BeanReflectSetter {
+public interface BeanPropertySetter {
 
 	/**
 	 * Set the property value of a bean.

src/main/java/com/avaje/ebeaninternal/server/properties/EnhanceBeanPropertyInfo.java

@@ -1,4 +1,4 @@
-package com.avaje.ebeaninternal.server.reflect;
+package com.avaje.ebeaninternal.server.properties;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
@@ -11,13 +11,13 @@ import com.avaje.ebean.bean.EntityBean;
  * A BeanReflect implementation based on the enhancement that creates EntityBean
  * implementations.
  */
-public final class EnhanceBeanReflect implements BeanReflect {
+public final class EnhanceBeanPropertyInfo implements BeanPropertyInfo {
 
   private static final Object[] constuctorArgs = new Object[0];
 
   private final Constructor<?> constructor;
 
-  public EnhanceBeanReflect(Class<?> clazz) {
+  public EnhanceBeanPropertyInfo(Class<?> clazz) {
     try {
       if (Modifier.isAbstract(clazz.getModifiers())) {
         this.constructor = null;  
@@ -47,15 +47,15 @@ public final class EnhanceBeanReflect implements BeanReflect {
     }
   }
 
-  public BeanReflectGetter getGetter(String name, int position) {
+  public BeanPropertyGetter getGetter(String name, int position) {
     return new Getter(position);
   }
 
-  public BeanReflectSetter getSetter(String name, int position) {
+  public BeanPropertySetter getSetter(String name, int position) {
     return new Setter(position);
   }
 
-  static final class Getter implements BeanReflectGetter {
+  static final class Getter implements BeanPropertyGetter {
 
     private final int fieldIndex;
 
@@ -72,7 +72,7 @@ public final class EnhanceBeanReflect implements BeanReflect {
     }
   }
 
-  static final class Setter implements BeanReflectSetter {
+  static final class Setter implements BeanPropertySetter {
 
     private final int fieldIndex;
 

src/main/java/com/avaje/ebeaninternal/server/properties/EnhanceBeanPropertyInfoFactory.java

@@ -0,0 +1,13 @@
+package com.avaje.ebeaninternal.server.properties;
+
+/**
+ * Creates a BeanReflectFactory based on the enhancement that 
+ * creates EntityBean implementations.
+ */
+public final class EnhanceBeanPropertyInfoFactory implements BeanPropertyInfoFactory {
+
+	public BeanPropertyInfo create(Class<?> entityBeanType) {
+		return new EnhanceBeanPropertyInfo(entityBeanType);
+	}
+
+}

src/main/java/com/avaje/ebeaninternal/server/query/CQuery.java

@@ -1,29 +1,8 @@
 package com.avaje.ebeaninternal.server.query;
 
-import java.lang.ref.WeakReference;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-
-import javax.persistence.PersistenceException;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.avaje.ebean.QueryIterator;
-import com.avaje.ebean.bean.BeanCollection;
-import com.avaje.ebean.bean.BeanCollectionAdd;
-import com.avaje.ebean.bean.EntityBean;
-import com.avaje.ebean.bean.EntityBeanIntercept;
-import com.avaje.ebean.bean.NodeUsageCollector;
-import com.avaje.ebean.bean.NodeUsageListener;
-import com.avaje.ebean.bean.ObjectGraphNode;
-import com.avaje.ebean.bean.PersistenceContext;
+import com.avaje.ebean.bean.*;
 import com.avaje.ebean.config.GlobalProperties;
-import com.avaje.ebeaninternal.api.LoadContext;
 import com.avaje.ebeaninternal.api.SpiExpressionList;
 import com.avaje.ebeaninternal.api.SpiQuery;
 import com.avaje.ebeaninternal.api.SpiQuery.Mode;
@@ -32,16 +11,23 @@ import com.avaje.ebeaninternal.server.autofetch.AutoFetchManager;
 import com.avaje.ebeaninternal.server.core.Message;
 import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
 import com.avaje.ebeaninternal.server.core.SpiOrmQueryRequest;
-import com.avaje.ebeaninternal.server.deploy.BeanCollectionHelp;
-import com.avaje.ebeaninternal.server.deploy.BeanCollectionHelpFactory;
-import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import com.avaje.ebeaninternal.server.deploy.DbReadContext;
+import com.avaje.ebeaninternal.server.deploy.*;
 import com.avaje.ebeaninternal.server.el.ElPropertyValue;
 import com.avaje.ebeaninternal.server.lib.util.StringHelper;
 import com.avaje.ebeaninternal.server.querydefn.OrmQueryProperties;
 import com.avaje.ebeaninternal.server.type.DataBind;
 import com.avaje.ebeaninternal.server.type.DataReader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.persistence.PersistenceException;
+import java.lang.ref.WeakReference;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 /**
  * An object that represents a SqlSelect statement.
@@ -82,7 +68,7 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
   /**
    * Flag set when 'master' bean changed.
    */
-  private boolean loadedBeanChanged;
+  private boolean loadedBeanChanged;
 
   /**
    * The 'master' bean just loaded.
@@ -220,6 +206,9 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
   private long startNano;
 
   private long executionTimeMicros;
+
+  private BeanCollectionAdd currentDetailAdd;
+
   /**
    * Create the Sql select based on the request.
    */
@@ -253,7 +242,7 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
       // get filter to put on the collection for reuse with refresh
       String manyPropertyName = sqlTree.getManyPropertyName();
       OrmQueryProperties chunk = query.getDetail().getChunk(manyPropertyName, false);
-      this.filterMany = chunk.getFilterMany();
+      this.filterMany = (chunk == null) ? null : chunk.getFilterMany();
     } else {
       this.filterMany = null;
     }
@@ -266,7 +255,7 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
     this.predicates = predicates;
     this.maxRowsLimit = query.getMaxRows() > 0 ? query.getMaxRows() : GLOBAL_ROW_LIMIT;
     this.help = createHelp(request);
-    this.collection = (BeanCollection<T>) (help != null ? help.createEmpty(false) : null);
+    this.collection = (help != null ? help.createEmptyNoParent() : null);
   }
 
   private BeanCollectionHelp<T> createHelp(OrmQueryRequest<T> request) {
@@ -306,10 +295,6 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
     return predicates;
   }
 
-  public LoadContext getGraphContext() {
-    return request.getGraphContext();
-  }
-
   public SpiOrmQueryRequest<?> getQueryRequest() {
     return request;
   }
@@ -470,12 +455,10 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
   public EntityBean getLoadedBean() {
     if (manyIncluded) {
       if (prevDetailCollection instanceof BeanCollection<?>) {
-        ((BeanCollection<?>) prevDetailCollection).setModifyListening(manyProperty
-            .getModifyListenMode());
+        ((BeanCollection<?>) prevDetailCollection).setModifyListening(manyProperty.getModifyListenMode());
 
       } else if (currentDetailCollection instanceof BeanCollection<?>) {
-        ((BeanCollection<?>) currentDetailCollection).setModifyListening(manyProperty
-            .getModifyListenMode());
+        ((BeanCollection<?>) currentDetailCollection).setModifyListening(manyProperty.getModifyListenMode());
       }
     }
 
@@ -581,8 +564,6 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
     return false;
   }
 
-  private BeanCollectionAdd currentDetailAdd;
-
   private void createNewDetailCollection() {
     prevDetailCollection = currentDetailCollection;
     if (queryMode.equals(Mode.LAZYLOAD_MANY)) {
@@ -590,7 +571,7 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
       currentDetailCollection = manyPropertyEl.elGetValue(loadedBean);
     } else {
       // create a new collection to populate and assign to the bean
-      currentDetailCollection = manyProperty.createEmpty(false);
+      currentDetailCollection = manyProperty.createEmpty(loadedBean);
       manyPropertyEl.elSetValue(loadedBean, currentDetailCollection, false);
     }
 
@@ -719,14 +700,6 @@ public class CQuery<T> implements DbReadContext, CancelableQuery {
     return sqlTree.getSummary();
   }
 
-  /**
-   * Return the SqlSelectChain. This is the flattened structure that represents
-   * this query.
-   */
-  public SqlTree getSqlTree() {
-    return sqlTree;
-  }
-
   public String getBindLog() {
     return bindLog;
   }

src/main/java/com/avaje/ebeaninternal/server/query/CQueryEngine.java

@@ -25,14 +25,14 @@ public class CQueryEngine {
 
   private static final Logger logger = LoggerFactory.getLogger(CQueryEngine.class);
 
-  private final DatabasePlatform dbPlatform;
-  
+  private static final int defaultSecondaryQueryBatchSize = 100;
+
+  private final boolean forwardOnlyHintOnFindIterate;
+
   private final CQueryBuilder queryBuilder;
 
-  private final int defaultSecondaryQueryBatchSize = 100;
-
   public CQueryEngine(DatabasePlatform dbPlatform, Binder binder) {
-    this.dbPlatform = dbPlatform;
+    this.forwardOnlyHintOnFindIterate = dbPlatform.isForwardOnlyHintOnFindIterate();
     this.queryBuilder = new CQueryBuilder(dbPlatform, binder);
   }
 
@@ -121,7 +121,7 @@ public class CQueryEngine {
 
     try {
 
-      if (!cquery.prepareBindExecuteQueryForwardOnly(dbPlatform.isForwardOnlyHintOnFindIterate())) {
+      if (!cquery.prepareBindExecuteQueryForwardOnly(forwardOnlyHintOnFindIterate)) {
         // query has been cancelled already
         logger.trace("Future fetch already cancelled");
         return null;
@@ -131,7 +131,15 @@ public class CQueryEngine {
         logSql(cquery);
       }
 
+      // first check batch sizes set on query joins
       int iterateBufferSize = request.getSecondaryQueriesMinBatchSize(defaultSecondaryQueryBatchSize);
+      if (iterateBufferSize < 1) {
+        // not set on query joins so check if batch size set on query itself
+        int queryBatch = request.getQuery().getLazyLoadBatchSize();
+        if (queryBatch > 0) {
+          iterateBufferSize = queryBatch;
+        }
+      }
 
       QueryIterator<T> readIterate = cquery.readIterate(iterateBufferSize, request);
 
@@ -178,7 +186,7 @@ public class CQueryEngine {
         logFindManySummary(cquery);
       }
 
-      request.executeSecondaryQueries(defaultSecondaryQueryBatchSize);
+      request.executeSecondaryQueries();
 
       return beanCollection;
 
@@ -223,7 +231,7 @@ public class CQueryEngine {
         logFindBeanSummary(cquery);
       }
 
-      request.executeSecondaryQueries(defaultSecondaryQueryBatchSize);
+      request.executeSecondaryQueries();
 
       return (T)bean;
 

src/main/java/com/avaje/ebeaninternal/server/query/CQueryIteratorWithBuffer.java

@@ -43,7 +43,7 @@ class CQueryIteratorWithBuffer<T> implements QueryIterator<T> {
           }
         }
         // execute secondary queries
-        request.executeSecondaryQueries(bufferSize);
+        request.executeSecondaryQueries();
       }
       return !buffer.isEmpty();
 

src/main/java/com/avaje/ebeaninternal/server/query/SqlTree.java

@@ -13,40 +13,71 @@ import com.avaje.ebeaninternal.server.el.ElPropertyValue;
  */
 public class SqlTree {
 
-  private SqlTreeNode rootNode;
+  private final SqlTreeNode rootNode;
 
   /**
    * Property if resultSet contains master and detail rows.
    */
-  private BeanPropertyAssocMany<?> manyProperty;
-  private String manyPropertyName;
-  private ElPropertyValue manyPropEl;
+  private final BeanPropertyAssocMany<?> manyProperty;
 
-  private Set<String> includes;
+  private final String manyPropertyName;
+
+  private final ElPropertyValue manyPropEl;
+
+  private final Set<String> includes;
 
   /**
    * Summary of the select being generated.
    */
-  private String summary;
+  private final String summary;
 
-  private String selectSql;
+  private final String selectSql;
 
-  private String fromSql;
+  private final String fromSql;
 
   /**
    * Encrypted Properties require additional binding.
    */
-  private BeanProperty[] encryptedProps;
+  private final BeanProperty[] encryptedProps;
 
   /**
    * Where clause for inheritance.
    */
-  private String inheritanceWhereSql;
+  private final String inheritanceWhereSql;
 
   /**
    * Create the SqlSelectClause.
    */
-  public SqlTree() {
+  public SqlTree(String summary, SqlTreeNode rootNode, String selectSql, String fromSql, String inheritanceWhereSql,
+                 BeanProperty[] encryptedProps, BeanPropertyAssocMany<?> manyProperty, String manyPropertyName,
+                 ElPropertyValue manyPropEl, Set<String> includes) {
+
+    this.summary = summary;
+    this.rootNode = rootNode;
+    this.selectSql = selectSql;
+    this.fromSql = fromSql;
+    this.inheritanceWhereSql = inheritanceWhereSql;
+    this.encryptedProps = encryptedProps;
+    this.manyProperty = manyProperty;
+    this.manyPropertyName = manyPropertyName;
+    this.manyPropEl = manyPropEl;
+    this.includes = includes;
+  }
+
+  /**
+   * Construct for RawSql.
+   */
+  public SqlTree(String summary, SqlTreeNode rootNode) {
+    this.summary = summary;
+    this.rootNode = rootNode;
+    this.selectSql = null;
+    this.fromSql = null;
+    this.inheritanceWhereSql = null;
+    this.encryptedProps = null;
+    this.manyProperty = null;
+    this.manyPropertyName = null;
+    this.manyPropEl = null;
+    this.includes = null;
   }
 
   public List<String> buildSelectExpressionChain() {
@@ -62,23 +93,6 @@ public class SqlTree {
     return includes;
   }
 
-  /**
-   * Set the association includes (Ones and Many's).
-   */
-  public void setIncludes(Set<String> includes) {
-    this.includes = includes;
-  }
-
-  /**
-   * Set the manyProperty used for this query.
-   */
-  public void setManyProperty(BeanPropertyAssocMany<?> manyProperty, String manyPropertyName,
-      ElPropertyValue manyPropEl) {
-    this.manyProperty = manyProperty;
-    this.manyPropertyName = manyPropertyName;
-    this.manyPropEl = manyPropEl;
-  }
-
   /**
    * Return the String for the actual SQL.
    */
@@ -86,21 +100,10 @@ public class SqlTree {
     return selectSql;
   }
 
-  /**
-   * Set the select sql clause.
-   */
-  public void setSelectSql(String selectSql) {
-    this.selectSql = selectSql;
-  }
-
   public String getFromSql() {
     return fromSql;
   }
 
-  public void setFromSql(String fromSql) {
-    this.fromSql = fromSql;
-  }
-
   /**
    * Return the where clause for inheritance.
    */
@@ -108,20 +111,6 @@ public class SqlTree {
     return inheritanceWhereSql;
   }
 
-  /**
-   * Set where clause(s) for inheritance.
-   */
-  public void setInheritanceWhereSql(String whereSql) {
-    this.inheritanceWhereSql = whereSql;
-  }
-
-  /**
-   * Set the summary description of the query.
-   */
-  public void setSummary(String summary) {
-    this.summary = summary;
-  }
-
   /**
    * Return a summary of the select clause.
    */
@@ -133,10 +122,6 @@ public class SqlTree {
     return rootNode;
   }
 
-  public void setRootNode(SqlTreeNode rootNode) {
-    this.rootNode = rootNode;
-  }
-
   /**
    * Return the property that is associated with the many. There can only be one
    * per SqlSelect. This can be null.
@@ -164,7 +149,4 @@ public class SqlTree {
     return encryptedProps;
   }
 
-  public void setEncryptedProps(BeanProperty[] encryptedProps) {
-    this.encryptedProps = encryptedProps;
-  }
 }

src/main/java/com/avaje/ebeaninternal/server/query/SqlTreeBuilder.java

@@ -66,6 +66,8 @@ public class SqlTreeBuilder {
 
   private final boolean rawSql;
 
+  private SqlTreeNode rootNode;
+
   /**
    * Construct for RawSql query.
    */
@@ -111,34 +113,33 @@ public class SqlTreeBuilder {
    */
   public SqlTree build() {
 
-    SqlTree sqlTree = new SqlTree();
-
     summary.append(desc.getName());
 
     // build the appropriate chain of SelectAdapter's
-    buildRoot(desc, sqlTree);
+    buildRoot(desc);
 
     // build the actual String
-    SqlTreeNode rootNode = sqlTree.getRootNode();
-
+    String selectSql = null;
+    String fromSql = null;
+    String inheritanceWhereSql = null;
+    BeanProperty[] encryptedProps = null;
     if (!rawSql) {
-      sqlTree.setSelectSql(buildSelectClause(rootNode));
-      sqlTree.setFromSql(buildFromClause(rootNode));
-      sqlTree.setInheritanceWhereSql(buildWhereClause(rootNode));
-      sqlTree.setEncryptedProps(ctx.getEncryptedProps());
+      selectSql = buildSelectClause();
+      fromSql = buildFromClause();
+      inheritanceWhereSql = buildWhereClause();
+      encryptedProps = ctx.getEncryptedProps();
     }
-    sqlTree.setIncludes(queryDetail.getIncludes());
-    sqlTree.setSummary(summary.toString());
 
+    ElPropertyValue manyPropEl = null;
     if (manyPropertyName != null) {
-      ElPropertyValue manyPropEl = desc.getElGetValue(manyPropertyName);
-      sqlTree.setManyProperty(manyProperty, manyPropertyName, manyPropEl);
+      manyPropEl = desc.getElGetValue(manyPropertyName);
     }
 
-    return sqlTree;
+    return new SqlTree(summary.toString(), rootNode, selectSql, fromSql, inheritanceWhereSql, encryptedProps,
+                        manyProperty, manyPropertyName, manyPropEl, queryDetail.getIncludes());
   }
 
-  private String buildSelectClause(SqlTreeNode rootNode) {
+  private String buildSelectClause() {
 
     if (rawSql) {
       return "Not Used";
@@ -155,7 +156,7 @@ public class SqlTreeBuilder {
     return selectSql;
   }
 
-  private String buildWhereClause(SqlTreeNode rootNode) {
+  private String buildWhereClause() {
 
     if (rawSql) {
       return "Not Used";
@@ -164,7 +165,7 @@ public class SqlTreeBuilder {
     return ctx.getContent();
   }
 
-  private String buildFromClause(SqlTreeNode rootNode) {
+  private String buildFromClause() {
 
     if (rawSql) {
       return "Not Used";
@@ -173,10 +174,9 @@ public class SqlTreeBuilder {
     return ctx.getContent();
   }
 
-  private void buildRoot(BeanDescriptor<?> desc, SqlTree sqlTree) {
+  private void buildRoot(BeanDescriptor<?> desc) {
 
-    SqlTreeNode selectRoot = buildSelectChain(null, null, desc, null);
-    sqlTree.setRootNode(selectRoot);
+    rootNode = buildSelectChain(null, null, desc, null);
 
     if (!rawSql) {
       alias.addJoin(queryDetail.getIncludes(), desc);

src/main/java/com/avaje/ebeaninternal/server/querydefn/DefaultOrmQuery.java

@@ -8,22 +8,8 @@ import java.util.Set;
 
 import javax.persistence.PersistenceException;
 
-import com.avaje.ebean.EbeanServer;
-import com.avaje.ebean.Expression;
-import com.avaje.ebean.ExpressionFactory;
-import com.avaje.ebean.ExpressionList;
-import com.avaje.ebean.FetchConfig;
-import com.avaje.ebean.FutureIds;
-import com.avaje.ebean.FutureList;
-import com.avaje.ebean.FutureRowCount;
-import com.avaje.ebean.OrderBy;
+import com.avaje.ebean.*;
 import com.avaje.ebean.OrderBy.Property;
-import com.avaje.ebean.PagedList;
-import com.avaje.ebean.PagingList;
-import com.avaje.ebean.Query;
-import com.avaje.ebean.QueryIterator;
-import com.avaje.ebean.QueryResultVisitor;
-import com.avaje.ebean.RawSql;
 import com.avaje.ebean.bean.BeanCollectionTouched;
 import com.avaje.ebean.bean.CallStack;
 import com.avaje.ebean.bean.EntityBean;
@@ -102,7 +88,10 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
 
   private int firstRow;
 
-  private int totalHits;
+  /**
+   * Lazy loading batch size (can override server wide default).
+   */
+  private int lazyLoadBatchSize;
 
   /**
    * The where clause from a parsed query string.
@@ -181,6 +170,8 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
 
   private Boolean readOnly;
 
+  private PersistenceContextScope persistenceContextScope;
+
   private boolean sqlSelect;
 
   /**
@@ -263,14 +254,6 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
     }
   }
 
-  public int getTotalHits() {
-    return totalHits;
-  }
-
-  public void setTotalHits(int totalHits) {
-    this.totalHits = totalHits;
-  }
-
   @Override
   public Query<T> apply(PathProperties pathProperties) {
     pathProperties.apply(this);
@@ -307,6 +290,16 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
     return this;
   }
 
+  @Override
+  public int getLazyLoadBatchSize() {
+    return lazyLoadBatchSize;
+  }
+
+  public Query<T> setLazyLoadBatchSize(int lazyLoadBatchSize) {
+    this.lazyLoadBatchSize = lazyLoadBatchSize;
+    return this;
+  }
+
   public String getLazyLoadProperty() {
     return lazyLoadProperty;
   }
@@ -473,6 +466,7 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
     if (havingExpressions != null) {
       copy.havingExpressions = havingExpressions.copy(copy);
     }
+    copy.persistenceContextScope = persistenceContextScope;
     copy.usageProfiling = usageProfiling;
     copy.autoFetch = autoFetch;
     copy.parentNode = parentNode;
@@ -482,6 +476,16 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
     return copy;
   }
 
+  @Override
+  public Query<T> setPersistenceContextScope(PersistenceContextScope scope) {
+    this.persistenceContextScope = scope;
+    return this;
+  }
+
+  public PersistenceContextScope getPersistenceContextScope() {
+    return persistenceContextScope;
+  }
+
   public Type getType() {
     return type;
   }
@@ -911,6 +915,16 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
     server.findVisit(this, visitor, null);
   }
 
+  @Override
+  public void findEachWhile(QueryEachWhileConsumer<T> consumer) {
+    server.findEachWhile(this, consumer, null);
+  }
+
+  @Override
+  public void findEach(QueryEachConsumer<T> consumer) {
+    server.findEach(this, consumer, null);
+  }
+
   public QueryIterator<T> findIterate() {
     return server.findIterate(this, null);
   }
@@ -1159,18 +1173,6 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
     return query;
   }
 
-  public DefaultOrmQuery<T> addWhere(String addToWhereClause) {
-    return where(addToWhereClause);
-  }
-
-  public DefaultOrmQuery<T> addWhere(Expression expression) {
-    return where(expression);
-  }
-
-  public ExpressionList<T> addWhere() {
-    return where();
-  }
-
   public DefaultOrmQuery<T> where(String addToWhereClause) {
     if (additionalWhere == null) {
       additionalWhere = addToWhereClause;
@@ -1208,18 +1210,6 @@ public class DefaultOrmQuery<T> implements SpiQuery<T> {
     }
   }
 
-  public DefaultOrmQuery<T> addHaving(String addToHavingClause) {
-    return having(addToHavingClause);
-  }
-
-  public DefaultOrmQuery<T> addHaving(Expression expression) {
-    return having(expression);
-  }
-
-  public ExpressionList<T> addHaving() {
-    return having();
-  }
-
   public DefaultOrmQuery<T> having(String addToHavingClause) {
     if (additionalHaving == null) {
       additionalHaving = addToHavingClause;

src/main/java/com/avaje/ebeaninternal/server/reflect/EnhanceBeanReflectFactory.java

@@ -1,13 +0,0 @@
-package com.avaje.ebeaninternal.server.reflect;
-
-/**
- * Creates a BeanReflectFactory based on the enhancement that 
- * creates EntityBean implementations.
- */
-public final class EnhanceBeanReflectFactory implements BeanReflectFactory {
-
-	public BeanReflect create(Class<?> entityBeanType) {
-		return new EnhanceBeanReflect(entityBeanType);
-	}
-
-}

src/main/java/com/avaje/ebeaninternal/server/text/json/DJsonContext.java

@@ -4,6 +4,7 @@ import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.text.json.EJson;
 import com.avaje.ebean.text.PathProperties;
 import com.avaje.ebean.text.json.JsonContext;
+import com.avaje.ebean.text.json.JsonIOException;
 import com.avaje.ebean.text.json.JsonWriteOptions;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
@@ -23,7 +24,7 @@ import java.util.Map.Entry;
 public class DJsonContext implements JsonContext {
 
   private final SpiEbeanServer server;
-  
+
   private final JsonFactory jsonFactory;
 
   public DJsonContext(SpiEbeanServer server, JsonFactory jsonFactory) {
@@ -35,117 +36,141 @@ public class DJsonContext implements JsonContext {
     return server.isSupportedType(genericType);
   }
 
-  public JsonGenerator createGenerator(Writer writer) throws IOException {
-    return jsonFactory.createGenerator(writer);
-  }
-  
-  public JsonParser createParser(Reader reader) throws IOException {
-    return jsonFactory.createParser(reader);
+  public JsonGenerator createGenerator(Writer writer) throws JsonIOException {
+    try {
+      return jsonFactory.createGenerator(writer);
+    } catch (IOException e) {
+      throw new JsonIOException(e);
+    }
   }
 
-  public <T> T toBean(Class<T> cls, String json) throws IOException {
+  public JsonParser createParser(Reader reader) throws JsonIOException {
+    try {
+      return jsonFactory.createParser(reader);
+    } catch (IOException e) {
+      throw new JsonIOException(e);
+    }
+  }
+
+  public <T> T toBean(Class<T> cls, String json) throws JsonIOException {
     return toBean(cls, new StringReader(json));
   }
 
-  public <T> T toBean(Class<T> cls, Reader jsonReader) throws IOException {
+  public <T> T toBean(Class<T> cls, Reader jsonReader) throws JsonIOException {
     return toBean(cls, createParser(jsonReader));
   }
 
-  private <T> T toBean(Class<T> cls, JsonParser parser) throws IOException {
+  private <T> T toBean(Class<T> cls, JsonParser parser) throws JsonIOException {
 
-    BeanDescriptor<T> d = getDescriptor(cls);
-    return d.jsonRead(parser, null);
+    try {
+      BeanDescriptor<T> d = getDescriptor(cls);
+      return d.jsonRead(parser, null);
+    } catch (IOException e) {
+      throw new JsonIOException(e);
+    }
   }
 
-  public <T> List<T> toList(Class<T> cls, String json) throws IOException {
+  public <T> List<T> toList(Class<T> cls, String json) throws JsonIOException {
     return toList(cls, new StringReader(json));
   }
 
 
-  public <T> List<T> toList(Class<T> cls, Reader jsonReader) throws IOException {
+  public <T> List<T> toList(Class<T> cls, Reader jsonReader) throws JsonIOException {
     return toList(cls, createParser(jsonReader));
   }
 
-  private <T> List<T> toList(Class<T> cls, JsonParser src) throws IOException {
+  private <T> List<T> toList(Class<T> cls, JsonParser src) throws JsonIOException {
 
-    BeanDescriptor<T> d = getDescriptor(cls);
+    try {
+      BeanDescriptor<T> d = getDescriptor(cls);
 
-    List<T> list = new ArrayList<T>();
+      List<T> list = new ArrayList<T>();
 
-    JsonToken event = src.nextToken();
-    if (event != JsonToken.START_ARRAY) {
-      throw new JsonParseException("Expecting start_array event but got " + event ,src.getCurrentLocation());
-    }
-
-    do {
-      T bean = d.jsonRead(src, null);
-      if (bean == null) {
-        break;
-      } else {
-        list.add(bean);
+      JsonToken event = src.nextToken();
+      if (event != JsonToken.START_ARRAY) {
+        throw new JsonParseException("Expecting start_array event but got " + event, src.getCurrentLocation());
       }
-    } while (true);
 
-    return list;
+      do {
+        T bean = d.jsonRead(src, null);
+        if (bean == null) {
+          break;
+        } else {
+          list.add(bean);
+        }
+      } while (true);
+
+      return list;
+    } catch (IOException e) {
+      throw new JsonIOException(e);
+    }
   }
 
-  public Object toObject(Type genericType, String json) throws IOException {
+  public Object toObject(Type genericType, String json) throws JsonIOException {
 
     TypeInfo info = ParamTypeHelper.getTypeInfo(genericType);
     ManyType manyType = info.getManyType();
     switch (manyType) {
-    case NONE:
-      return toBean(info.getBeanType(), json);
+      case NONE:
+        return toBean(info.getBeanType(), json);
 
-    case LIST:
-      return toList(info.getBeanType(), json);
+      case LIST:
+        return toList(info.getBeanType(), json);
 
-    default:
-      throw new IOException("Type " + manyType + " not supported");
+      default:
+        throw new JsonIOException("Type " + manyType + " not supported");
     }
   }
 
-  public Object toObject(Type genericType, Reader json) throws IOException {
+  public Object toObject(Type genericType, Reader json) throws JsonIOException {
 
     TypeInfo info = ParamTypeHelper.getTypeInfo(genericType);
     ManyType manyType = info.getManyType();
     switch (manyType) {
-    case NONE:
-      return toBean(info.getBeanType(), json);
+      case NONE:
+        return toBean(info.getBeanType(), json);
 
-    case LIST:
-      return toList(info.getBeanType(), json);
+      case LIST:
+        return toList(info.getBeanType(), json);
 
-    default:
-      throw new IOException("Type " + manyType + " not supported");
+      default:
+        throw new JsonIOException("Type " + manyType + " not supported");
     }
   }
 
-  public void toJson(Object o, Writer writer) throws IOException {
+  public void toJson(Object o, Writer writer) throws JsonIOException {
     toJson(o, writer, null);
   }
 
 
-  public void toJson(Object o, Writer writer, JsonWriteOptions options) throws IOException {
-    JsonGenerator generator = createGenerator(writer);
-    toJsonInternal(o, generator, options);
-    generator.close();
+  public void toJson(Object o, Writer writer, JsonWriteOptions options) throws JsonIOException {
+    try {
+      JsonGenerator generator = createGenerator(writer);
+      toJsonInternal(o, generator, options);
+      generator.close();
+    } catch (IOException e) {
+      throw new JsonIOException(e);
+    }
   }
 
-  public String toJson(Object o) throws IOException {
+  public String toJson(Object o) throws JsonIOException {
     return toJsonString(o, null);
   }
 
-  public String toJson(Object o, JsonWriteOptions options) throws IOException {
+  public String toJson(Object o, JsonWriteOptions options) throws JsonIOException {
     return toJsonString(o, options);
   }
 
-  private String toJsonString(Object o, JsonWriteOptions options) throws IOException {
-    StringWriter writer = new StringWriter(500);
-    JsonGenerator gen = createGenerator(writer);
-    toJsonInternal(o, gen, options);
-    gen.close();
-    return writer.toString();
+  private String toJsonString(Object o, JsonWriteOptions options) throws JsonIOException {
+    try {
+      StringWriter writer = new StringWriter(500);
+      JsonGenerator gen = createGenerator(writer);
+      toJsonInternal(o, gen, options);
+      gen.close();
+      return writer.toString();
+    } catch (IOException e) {
+      throw new JsonIOException(e);
+    }
   }
 
   @SuppressWarnings("unchecked")
@@ -171,7 +196,7 @@ public class DJsonContext implements JsonContext {
     } else if (o instanceof EntityBean) {
       BeanDescriptor<?> d = getDescriptor(o.getClass());
       WriteJson writeJson = createWriteJson(gen, options);
-      d.jsonWrite(writeJson, (EntityBean)o, null);
+      d.jsonWrite(writeJson, (EntityBean) o, null);
     }
   }
 
@@ -183,7 +208,7 @@ public class DJsonContext implements JsonContext {
   private <T> void toJsonFromCollection(Collection<T> collection, String key, JsonGenerator gen, JsonWriteOptions options) throws IOException {
 
     if (key != null) {
-      gen.writeFieldName(key);      
+      gen.writeFieldName(key);
     }
     gen.writeStartArray();
 
@@ -203,7 +228,7 @@ public class DJsonContext implements JsonContext {
 
     WriteJson writeJson = createWriteJson(gen, options);
     gen.writeStartObject();
-    
+
     while (it.hasNext()) {
       Entry<Object, Object> entry = it.next();
       String key = entry.getKey().toString();
@@ -216,7 +241,7 @@ public class DJsonContext implements JsonContext {
 
         } else if (value instanceof EntityBean) {
           BeanDescriptor<?> d = getDescriptor(value.getClass());
-          d.jsonWrite(writeJson,(EntityBean) value, key);
+          d.jsonWrite(writeJson, (EntityBean) value, key);
 
         } else {
           EJson.write(entry, gen);

src/main/java/com/avaje/ebeaninternal/server/text/json/DefaultJsonValueAdapter.java

@@ -1,57 +0,0 @@
-package com.avaje.ebeaninternal.server.text.json;
-
-import java.sql.Date;
-import java.sql.Timestamp;
-import java.text.SimpleDateFormat;
-import java.util.TimeZone;
-
-public class DefaultJsonValueAdapter {//implements JsonValueAdapter {
-
-  private final SimpleDateFormat dateTimeProto;
-
-  public DefaultJsonValueAdapter(String dateTimeFormat) {
-    this.dateTimeProto = new SimpleDateFormat(dateTimeFormat);
-    this.dateTimeProto.setTimeZone(TimeZone.getTimeZone("UTC"));
-  }
-
-  public DefaultJsonValueAdapter() {
-    this("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
-  }
-
-  private SimpleDateFormat dtFormat() {
-    return (SimpleDateFormat) dateTimeProto.clone();
-  }
-
-  public String jsonFromDate(Date date) {
-    return "\"" + date.toString() + "\"";
-  }
-
-  public String jsonFromTimestamp(Timestamp date) {
-    return "\"" + dtFormat().format(date) + "\"";
-  }
-
-  public Date jsonToDate(String jsonDate) {
-    try {
-      long utc = Long.parseLong(jsonDate);
-      return new java.sql.Date(utc);
-    } catch (NumberFormatException ex) {
-      return Date.valueOf(jsonDate);
-    }
-  }
-
-  public Timestamp jsonToTimestamp(String jsonDateTime) {
-    try {
-      long utc = Long.parseLong(jsonDateTime);
-      return new Timestamp(utc);
-    } catch (NumberFormatException ex) {
-      try {
-        java.util.Date d = dtFormat().parse(jsonDateTime);
-        return new Timestamp(d.getTime());
-      } catch (Exception e) {
-        String m = "Error parsing Datetime[" + jsonDateTime + "]";
-        throw new RuntimeException(m, e);
-      }
-    }
-  }
-
-}

src/main/java/com/avaje/ebeaninternal/server/transaction/BeanPersistIds.java

@@ -246,7 +246,7 @@ public class BeanPersistIds implements Serializable {
      */
     public void notifyCacheAndListener() {
 
-        BeanPersistListener<?> listener = beanDescriptor.getPersistListener();
+        BeanPersistListener listener = beanDescriptor.getPersistListener();
 
         // any change invalidates the query cache
         beanDescriptor.queryCacheClear();