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

Add check for distinct query when adding id attribute to order clause in paging query

pom.xml

@@ -7,12 +7,12 @@
     <version>1.1</version>
   </parent>
 
-  <groupId>org.avaje.ebeanorm</groupId>
-  <artifactId>avaje-ebeanorm</artifactId>
-  <version>7.16.3</version>
+  <groupId>org.avaje.ebean</groupId>
+  <artifactId>ebean</artifactId>
+  <version>8.1.1</version>
   <packaging>jar</packaging>
 
-  <name>avaje-ebeanorm</name>
+  <name>ebean</name>
   <url>http://ebean-orm.github.io/</url>
 
   <properties>
@@ -37,7 +37,7 @@
 
   <scm>
     <developerConnection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm.git</developerConnection>
-    <tag>avaje-ebeanorm-7.16.3</tag>
+    <tag>ebean-8.1.1</tag>
   </scm>
 
   <dependencies>
@@ -69,19 +69,19 @@
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-classpath-scanner-api</artifactId>
-      <version>2.1</version>
+      <version>2.2</version>
     </dependency>
 
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-classpath-scanner</artifactId>
-      <version>2.1.1</version>
+      <version>2.2.1</version>
     </dependency>
 
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-dbmigration</artifactId>
-      <version>1.1.1</version>
+      <version>1.2.1</version>
     </dependency>
 
     <dependency>
@@ -90,6 +90,12 @@
       <version>[1.7.1,1.7.99)</version>
     </dependency>
 
+    <dependency>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime</artifactId>
+      <version>4.5.3</version>
+    </dependency>
+
     <!-- Jackson core used internally by Ebean -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
@@ -166,9 +172,9 @@
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.ebeanorm</groupId>
-      <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.11.1</version>
+      <groupId>org.avaje.ebean</groupId>
+      <artifactId>ebean-agent</artifactId>
+      <version>8.1.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -177,7 +183,7 @@
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.4.189</version>
+      <version>1.4.192</version>
       <scope>provided</scope>
     </dependency>
     
@@ -241,9 +247,9 @@
       </plugin>
 
       <plugin>
-        <groupId>org.avaje.ebeanorm</groupId>
-        <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.11.1</version>
+        <groupId>org.avaje.ebean</groupId>
+        <artifactId>ebean-maven-plugin</artifactId>
+        <version>8.1.1</version>
         <executions>
           <execution>
             <id>test</id>
@@ -298,7 +304,7 @@
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>2.9.1</version>
         <configuration>
-          <doctitle>Ebean 7</doctitle>
+          <doctitle>Ebean 8</doctitle>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>

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

@@ -38,6 +38,11 @@ public interface BeanState {
    */
   void setDisableLazyLoad(boolean disableLazyLoading);
 
+  /**
+   * Return true if the bean has lazy loading disabled.
+   */
+  boolean isDisableLazyLoad();
+
   /**
    * Set the loaded state of the property given it's name.
    *

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

@@ -499,6 +499,13 @@ public final class Ebean {
     serverMgr.getDefaultServer().endTransaction();
   }
 
+  /**
+   * Mark the current transaction as rollback only.
+   */
+  public static void setRollbackOnly() {
+    serverMgr.getDefaultServer().currentTransaction().setRollbackOnly();
+  }
+
   /**
    * Return a map of the differences between two objects of the same type.
    * <p>
@@ -945,6 +952,21 @@ public final class Ebean {
     return serverMgr.getDefaultServer().createCsvReader(beanType);
   }
 
+  /**
+   * Create a named query.
+   * <p>
+   * For RawSql the named query is expected to be in ebean.xml.
+   * </p>
+   *
+   * @param beanType   The type of entity bean
+   * @param namedQuery The name of the query
+   * @param <T>        The type of entity bean
+   * @return The query
+   */
+  public static <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
+    return serverMgr.getDefaultServer().createNamedQuery(beanType, namedQuery);
+  }
+
   /**
    * Create a query for a type of entity bean.
    * <p>
@@ -960,39 +982,7 @@ public final class Ebean {
    * {@link Query#findSet()} etc will execute against the same EbeanServer from
    * which is was created.
    * </p>
-   * 
-   * <pre>{@code
-   *   // Find order 2 additionally fetching the customer, details and details.product
-   *   // name.
-   * 
-   *   Order order = Ebean.find(Order.class)
-   *     .fetch("customer")
-   *     .fetch("details")
-   *     .fetch("detail.product", "name")
-   *     .setId(2)
-   *     .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
-   * 
-   *   String oql = "find order fetch customer fetch details fetch details.product (name) where id = :orderId ";
-   * 
-   *   Query<Order> query = Ebean.find(Order.class);
-   *   query.setQuery(oql);
-   *   query.setParameter("orderId", 2);
-   * 
-   *   Order order = query.findUnique();
-   * 
-   *   // Using a named query
-   *   Query<Order> query = Ebean.find(Order.class, "with.details");
-   *   query.setParameter("orderId", 2);
-   * 
-   *   Order order = query.findUnique();
-   * 
-   * }</pre>
-   * 
+   *
    * @param beanType
    *          the class of entity to be fetched
    * @return A ORM Query object for this beanType
@@ -1002,6 +992,47 @@ public final class Ebean {
     return serverMgr.getDefaultServer().createQuery(beanType);
   }
 
+  /**
+   * Parse the Ebean query language statement returning the query which can then
+   * be modified (add expressions, change order by clause, change maxRows, change
+   * fetch and select paths etc).
+   *
+   * <h3>Example</h3>
+   *
+   * <pre>{@code
+   *
+   *
+   *   // Find order additionally fetching the customer, details and details.product name.
+   *
+   *   String eql = "fetch customer fetch details fetch details.product (name) where id = :orderId ";
+   *
+   *   Query<Order> query = Ebean.createQuery(Order.class, eql);
+   *   query.setParameter("orderId", 2);
+   *
+   *   Order order = query.findUnique();
+   *
+   *   // This is the same as:
+   *
+   *   Order order = Ebean.find(Order.class)
+   *     .fetch("customer")
+   *     .fetch("details")
+   *     .fetch("detail.product", "name")
+   *     .setId(2)
+   *     .findUnique();
+   *
+   * }</pre>
+   *
+   * @param beanType The type of bean to fetch
+   * @param eql The Ebean query
+   * @param <T> The type of the entity bean
+   *
+   * @return The query with expressions defined as per the parsed query statement
+   */
+  public static <T> Query<T> createQuery(Class<T> beanType, String eql) {
+
+    return serverMgr.getDefaultServer().createQuery(beanType, eql);
+  }
+
   /**
    * Create a query for a type of entity bean.
    * <p>

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

@@ -199,6 +199,19 @@ public interface EbeanServer {
    */
   <T> UpdateQuery<T> update(Class<T> beanType);
 
+  /**
+   * Create a named query.
+   * <p>
+   * For RawSql the named query is expected to be in ebean.xml.
+   * </p>
+   *
+   * @param beanType   The type of entity bean
+   * @param namedQuery The name of the query
+   * @param <T>        The type of entity bean
+   * @return The query
+   */
+  <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery);
+
   /**
    * Create a query for an entity bean and synonym for {@link #find(Class)}.
    *
@@ -206,6 +219,43 @@ public interface EbeanServer {
    */
   <T> Query<T> createQuery(Class<T> beanType);
 
+  /**
+   * Parse the Ebean query language statement returning the query which can then
+   * be modified (add expressions, change order by clause, change maxRows, change
+   * fetch and select paths etc).
+   *
+   * <h3>Example</h3>
+   *
+   * <pre>{@code
+   *
+   *   // Find order additionally fetching the customer, details and details.product name.
+   *
+   *   String eql = "fetch customer fetch details fetch details.product (name) where id = :orderId ";
+   *
+   *   Query<Order> query = Ebean.createQuery(Order.class, eql);
+   *   query.setParameter("orderId", 2);
+   *
+   *   Order order = query.findUnique();
+   *
+   *   // This is the same as:
+   *
+   *   Order order = Ebean.find(Order.class)
+   *     .fetch("customer")
+   *     .fetch("details")
+   *     .fetch("detail.product", "name")
+   *     .setId(2)
+   *     .findUnique();
+   *
+   * }</pre>
+   *
+   * @param beanType The type of bean to fetch
+   * @param eql The Ebean query
+   * @param <T> The type of the entity bean
+   *
+   * @return The query with expressions defined as per the parsed query statement
+   */
+  <T> Query<T> createQuery(Class<T> beanType, String eql);
+
   /**
    * Create a query for a type of entity bean.
    * <p>
@@ -689,11 +739,18 @@ public interface EbeanServer {
   <T> T getReference(Class<T> beanType, Object id);
 
   /**
-   * Return the number of 'top level' or 'root' entities this query should
-   * return.
+   * Return the number of 'top level' or 'root' entities this query should return.
    *
-   * @see Query#findRowCount()
-   * @see com.avaje.ebean.Query#findFutureRowCount()
+   * @see Query#findCount()
+   * @see Query#findFutureCount()
+   */
+  <T> int findCount(Query<T> query, Transaction transaction);
+
+  /**
+   * Deprecated in favor of findCount()
+   *
+   * Return the number of 'top level' or 'root' entities this query should return.
+   * @deprecated
    */
   <T> int findRowCount(Query<T> query, Transaction transaction);
 
@@ -818,7 +875,15 @@ public interface EbeanServer {
    * @return a Future object for the row count query
    * @see com.avaje.ebean.Query#findFutureRowCount()
    */
-  <T> FutureRowCount<T> findFutureRowCount(Query<T> query, Transaction transaction);
+  <T> FutureRowCount<T> findFutureCount(Query<T> query, Transaction transaction);
+
+  /**
+   * Deprecated in favor of findFutureCount().
+   *
+   * Execute find row count query in a background thread.
+   * @deprecated
+   */
+   <T> FutureRowCount<T> findFutureRowCount(Query<T> query, Transaction transaction);
 
   /**
    * Execute find Id's query in a background thread.

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

@@ -135,6 +135,11 @@ public interface ExpressionFactory {
    */
   Expression ieq(String propertyName, String value);
 
+  /**
+   * Case Insensitive Equal To that allows for named parameter use.
+   */
+  Expression ieqObject(String propertyName, Object value);
+
   /**
    * Between - property between the two given values.
    */
@@ -192,6 +197,11 @@ public interface ExpressionFactory {
    */
   ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType);
 
+  /**
+   * Like with support for named parameters.
+   */
+  Expression like(String propertyName, Object value, boolean caseInsensitive, LikeType likeType);
+
   /**
    * Like - property like value where the value contains the SQL wild card
    * characters % (percentage) and _ (underscore).

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

@@ -182,6 +182,13 @@ public interface ExpressionList<T> {
    * This is the number of 'top level' or 'root level' entities.
    * </p>
    */
+  int findCount();
+
+  /**
+   * Deprecated in favor of findCount().
+   *
+   * @deprecated
+   */
   int findRowCount();
 
   /**
@@ -228,6 +235,13 @@ public interface ExpressionList<T> {
    * 
    * @return a Future object for the row count query
    */
+  FutureRowCount<T> findFutureCount();
+
+  /**
+   * Deprecated in favor of findFutureCount().
+   *
+   * @deprecated
+   */
   FutureRowCount<T> findFutureRowCount();
 
   /**

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

@@ -29,8 +29,7 @@ import java.io.Serializable;
  * // Find Orders join details using a single SQL query
  * }</pre>
  * <p>
- * Example: Using a "query join" instead of a "fetch join" we instead use 2 SQL
- * queries
+ * Example: Using a "query join" instead of a "fetch join" we instead use 2 SQL queries
  * </p>
  * 
  * <pre>{@code
@@ -117,7 +116,7 @@ import java.io.Serializable;
  * <pre>{@code
  * List<Order> list = Ebean.find(Order.class)
  *   .fetch("customer","name", new FetchConfig().lazy(5))
- *   .fetch("customer.contacts",&quotcontactName, phone, email&quot)
+ *   .fetch("customer.contacts","contactName, phone, email")
  *   .fetch("customer.shippingAddress")
  *   .where().eq("status",Order.Status.NEW)
  *   .findList();
@@ -125,12 +124,7 @@ import java.io.Serializable;
  * // query 1) find order where status = Order.Status.NEW
  * //  
  * // .. if lazy loading of customers is invoked 
- * // .. use a batch size of 5 to load the customers 
- *  
- *       find  customer (name) 
- *       fetch customer.contacts (contactName, phone, email) 
- *       fetch customer.shippingAddress (*) 
- *       where id in (?,?,?,?,?)
+ * // .. use a batch size of 5 to load the customers
  * 
  * }</pre>
  * 

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

@@ -59,11 +59,11 @@ package com.avaje.ebean;
  *          .and()
  *            .startsWith("name", "r")
  *            .eq("anniversary", onAfter)
- *            .endJunction()
+ *            .endAnd()
  *          .and()
  *            .eq("status", Customer.Status.ACTIVE)
  *            .gt("id", 0)
- *            .endJunction()
+ *            .endAnd()
  *      .order().asc("name");
  *
  * q.findList();
@@ -84,39 +84,41 @@ public interface Junction<T> extends Expression, ExpressionList<T> {
     /**
      * AND group.
      */
-    AND(" and ", ""),
+    AND(" and ", "", false),
 
     /**
      * OR group.
      */
-    OR(" or ", ""),
+    OR(" or ", "", false),
 
     /**
      * NOT group.
      */
-    NOT(" and ", "not "),
+    NOT(" and ", "not ", false),
 
     /**
      * Text search AND group.
      */
-    MUST("must", ""),
+    MUST("must", "", true),
 
     /**
      * Text search NOT group.
      */
-    MUST_NOT("must_not", ""),
+    MUST_NOT("must_not", "", true),
 
     /**
      * Text search OR group.
      */
-    SHOULD("should", "");
+    SHOULD("should", "", true);
 
-    String prefix;
-    String literal;
+    private String prefix;
+    private String literal;
+    private boolean text;
 
-    Type(String literal, String prefix) {
+    Type(String literal, String prefix, boolean text) {
       this.literal = literal;
       this.prefix = prefix;
+      this.text = text;
     }
 
     /**
@@ -132,6 +134,14 @@ public interface Junction<T> extends Expression, ExpressionList<T> {
     public String prefix() {
       return prefix;
     }
+
+    /**
+     * Return true if this is a text type.
+     */
+    public boolean isText() {
+      return text;
+    }
+
   }
 
 }

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

@@ -677,19 +677,36 @@ public abstract class Model {
     /**
      * Executes a find row count query in a background thread.
      * <p>
-     * Equivalent to {@link Query#findFutureRowCount()}
+     * Equivalent to {@link Query#findFutureCount()}
+     */
+    public FutureRowCount<T> findFutureCount() {
+      return query().findFutureCount();
+    }
+
+    /**
+     * Deprecated in favor of findFutureCount().
+     * <p>
+     * Equivalent to {@link Query#findFutureCount()}
      */
     public FutureRowCount<T> findFutureRowCount() {
-      return query().findFutureRowCount();
+      return query().findFutureCount();
     }
 
     /**
      * Returns the total number of entities for this type. *
      * <p>
-     * Equivalent to {@link Query#findRowCount()}
+     * Equivalent to {@link Query#findCount()}
+     */
+    public int findCount() {
+      return query().findCount();
+    }
+
+    /**
+     * Deprecated in favor of findCount().
+     * @deprecated
      */
     public int findRowCount() {
-      return query().findRowCount();
+      return query().findCount();
     }
 
     /**

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

@@ -148,6 +148,13 @@ public final class OrderBy<T> implements Serializable {
     return copy;
   }
 
+  /**
+   * Add to the order by by parsing a raw expression.
+   */
+  public void add(String rawExpression) {
+    parse(rawExpression);
+  }
+
   /**
    * Add a property to the order by.
    */
@@ -206,8 +213,9 @@ public final class OrderBy<T> implements Serializable {
    * order by clause and replace.
    * </p>
    */
-  public void clear() {
+  public OrderBy<T> clear() {
     list.clear();
+    return this;
   }
 
   /**

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

@@ -110,6 +110,13 @@ public interface PagedList<T> {
    * wrapped in the unchecked PersistenceException (which might be preferrable).
    * </p>
    */
+  void loadCount();
+
+  /**
+   * Deprecated in favor of loadCount().
+   *
+   * @deprecated
+   */
   void loadRowCount();
 
   /**
@@ -138,6 +145,13 @@ public interface PagedList<T> {
    *
    * }</pre>
    */
+  Future<Integer> getFutureCount();
+
+  /**
+   * Deprecated in favor of getFutureCount().
+   *
+   * @deprecated
+   */
   Future<Integer> getFutureRowCount();
 
   /**
@@ -170,6 +184,13 @@ public interface PagedList<T> {
    *
    * }</pre>
    */
+  int getTotalCount();
+
+  /**
+   * Deprecated in favor of getTotalCount().
+   *
+   * @deprecated
+   */
   int getTotalRowCount();
 
   /**

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

@@ -13,10 +13,10 @@ import java.util.Set;
  * <p>
  * Example: Create the query using the API.
  * </p>
- * 
+ * <p>
  * <pre>{@code
  *
- * List<Order> orderList = 
+ * List<Order> orderList =
  *   ebeanServer.find(Order.class)
  *     .fetch("customer")
  *     .fetch("details")
@@ -26,46 +26,40 @@ import java.util.Set;
  *     .orderBy("customer.id, id desc")
  *     .setMaxRows(50)
  *     .findList();
- *   
+ *
  * ...
  * }</pre>
- * 
  * <p>
  * Example: The same query using the query language
  * </p>
- * 
  * <pre>{@code
  *
- * String oql = 
- *   	"  find  order "
+ * String oql =
  *   	+" fetch customer "
  *   	+" fetch details "
  *   	+" where customer.name like :custName and orderDate > :minOrderDate "
  *   	+" order by customer.id, id desc "
  *   	+" limit 50 ";
- *   
+ *
  * Query<Order> query = ebeanServer.createQuery(Order.class, oql);
  * query.setParameter("custName", "Rob%");
  * query.setParameter("minOrderDate", lastWeek);
- *   
+ *
  * List<Order> orderList = query.findList();
  * ...
  * }</pre>
- * 
  * <p>
  * Example: Using a named query called "with.cust.and.details"
  * </p>
- * 
  * <pre>{@code
  *
  * Query<Order> query = ebeanServer.createNamedQuery(Order.class,"with.cust.and.details");
  * query.setParameter("custName", "Rob%");
  * query.setParameter("minOrderDate", lastWeek);
- *   
+ *
  * List<Order> orderList = query.findList();
  * ...
  * }</pre>
- * 
  * <h3>AutoTune</h3>
  * <p>
  * Ebean has built in support for "AutoTune". This is a mechanism where a query
@@ -82,7 +76,6 @@ import java.util.Set;
  * to a remote client or where there is some requirement for "Read Consistency"
  * guarantees.
  * </p>
- * 
  * <h3>Query Language</h3>
  * <p>
  * <b>Partial Objects</b>
@@ -101,36 +94,25 @@ import java.util.Set;
  * concurrency checking will occur but only include the fetched properties.
  * Refer to "ALL Properties/Columns" mode of Optimistic Concurrency checking.
  * </p>
- * 
  * <pre>{@code
- * [ find  {bean type} [ ( * | {fetch properties} ) ] ]
- * [ fetch {associated bean} [ ( * | {fetch properties} ) ] ]
+ * [ select [ ( * | {fetch properties} ) ] ]
+ * [ fetch {path} [ ( * | {fetch properties} ) ] ]
  * [ where {predicates} ]
  * [ order by {order by properties} ]
  * [ limit {max rows} [ offset {first row} ] ]
  * }</pre>
- * 
  * <p>
- * <b>FIND</b> <b>{bean type}</b> [ ( <i>*</i> | <i>{fetch properties}</i> ) ]
+ * <b>SELECT</b> [ ( <i>*</i> | <i>{fetch properties}</i> ) ]
  * </p>
  * <p>
- * With the find you specify the type of beans to fetch. You can optionally
- * specify a list of properties to fetch. If you do not specify a list of
- * properties ALL the properties for those beans are fetched.
+ * With the select you can specify a list of properties to fetch.
  * </p>
  * <p>
- * In object graph terms the <em>find</em> clause specifies the type of bean at
- * the root level and the <em>fetch</em> clauses specify the paths of the object
- * graph to populate.
- * </p>
- * <p>
- * <b>FETCH</b> <b>{associated property}</b> [ ( <i>*</i> | <i>{fetch
- * properties}</i> ) ]
+ * <b>FETCH</b> <b>{path}</b> [ ( <i>*</i> | <i>{fetch properties}</i> ) ]
  * </p>
  * <p>
  * With the fetch you specify the associated property to fetch and populate. The
- * associated property is a OneToOnem, ManyToOne, OneToMany or ManyToMany
- * property. When the query is executed Ebean will fetch the associated data.
+ * path is a OneToOne, ManyToOne, OneToMany or ManyToMany property.
  * </p>
  * <p>
  * For fetch of a path we can optionally specify a list of properties to fetch.
@@ -161,52 +143,34 @@ import java.util.Set;
  * </p>
  * <h4>Examples of Ebean's Query Language</h4>
  * <p>
- * Find orders fetching all its properties
- * </p>
- * 
- * <pre>{@code
- * find order
- * }</pre>
- * 
- * <p>
- * Find orders fetching all its properties
- * </p>
- * 
- * <pre>{@code
- * find order (*)
- * }</pre>
- * 
- * <p>
  * Find orders fetching its id, shipDate and status properties. Note that the id
  * property is always fetched even if it is not included in the list of fetch
  * properties.
  * </p>
- * 
  * <pre>{@code
- * find order (shipDate, status)
+ *
+ * select (shipDate, status)
+ *
  * }</pre>
- * 
  * <p>
  * Find orders with a named bind variable (that will need to be bound via
  * {@link Query#setParameter(String, Object)}).
  * </p>
- * 
  * <pre>{@code
- * find order
+ *
  * where customer.name like :custLike
+ *
  * }</pre>
- * 
  * <p>
  * Find orders and also fetch the customer with a named bind parameter. This
  * will fetch and populate both the order and customer objects.
  * </p>
- * 
  * <pre>{@code
- * find  order
+ *
  * fetch customer
  * where customer.id = :custId
+ *
  * }</pre>
- * 
  * <p>
  * Find orders and also fetch the customer, customer shippingAddress, order
  * details and related product. Note that customer and product objects will be
@@ -215,63 +179,16 @@ import java.util.Set;
  * objects (associated with each order detail) will have their id, sku and name
  * populated.
  * </p>
- * 
  * <pre>{@code
- * find  order
+ *
  * fetch customer (name)
  * fetch customer.shippingAddress
  * fetch details
  * fetch details.product (sku, name)
+ *
  * }</pre>
- * 
- * <h3>Early parsing of the Query</h3>
- * <p>
- * When you get a Query object from a named query, the query statement has
- * already been parsed. You can then add to that query (add fetch paths, add to
- * the where clause) or override some of its settings (override the order by
- * clause, first rows, max rows).
- * </p>
- * <p>
- * The thought is that you can use named queries as a 'starting point' and then
- * modify the query to suit specific needs.
- * </p>
- * <h3>Building the Where clause</h3>
- * <p>
- * You can add to the where clause using Expression objects or a simple String.
- * Note that the ExpressionList has methods to add most of the common
- * expressions that you will need.
- * <ul>
- * <li>where(String addToWhereClause)</li>
- * <li>where().add(Expression expression)</li>
- * <li>where().eq(propertyName, value).like(propertyName , value)...</li>
- * </ul>
- * </p>
- * <p>
- * The full WHERE clause is constructed by appending together
- * <li>original query where clause (Named query or query.setQuery(String oql))</li>
- * <li>clauses added via query.where(String addToWhereClause)</li>
- * <li>clauses added by Expression objects</li>
- * </p>
- * <p>
- * The above is the order that these are clauses are appended to give the full
- * WHERE clause.
- * </p>
- * <h3>Design Goal</h3>
- * <p>
- * This query language is NOT designed to be a replacement for SQL. It is
- * designed to be a simple way to describe the "Object Graph" you want Ebean to
- * build for you. Each find/fetch represents a node in that "Object Graph" which
- * makes it easy to define for each node which properties you want to fetch.
- * </p>
- * <p>
- * Once you hit the limits of this language such as wanting aggregate functions
- * (sum, average, min etc) or recursive queries etc you use SQL. Ebean's goal is
- * to make it as easy as possible to use your own SQL to populate entity beans.
- * Refer to {@link RawSql} .
- * </p>
- * 
- * @param <T>
- *          the type of Entity bean this query will fetch.
+ *
+ * @param <T> the type of Entity bean this query will fetch.
  */
 public interface Query<T> {
 
@@ -289,7 +206,7 @@ public interface Query<T> {
    * Perform an 'As of' query using history tables to return the object graph
    * as of a time in the past.
    * <p>
-   *   To perform this query the DB must have underlying history tables.
+   * To perform this query the DB must have underlying history tables.
    * </p>
    *
    * @param asOf the date time in the past at which you want to view the data
@@ -325,7 +242,7 @@ public interface Query<T> {
    * 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}.
+   * is used - this value defaults to {@link PersistenceContextScope#TRANSACTION}.
    * <p/>
    * Note that the same persistence Context is used for subsequent lazy loading and query join queries.
    * <p/>
@@ -392,14 +309,15 @@ public interface Query<T> {
   Query<T> setDisableReadAuditing();
 
   /**
-   * Explicitly set a comma delimited list of the properties to fetch on the
-   * 'main' root level entity bean (aka partial object). Note that '*' means all
-   * properties.
+   * Specify the properties to fetch on the root level entity bean in comma delimited format.
    * <p>
-   * You use {@link #fetch(String, String)} to specify specific properties to fetch
+   * The Id property is automatically included in the properties to fetch unless setDistinct(true)
+   * is set on the query.
+   * </p>
+   * <p>
+   * Use {@link #fetch(String, String)} to specify specific properties to fetch
    * on other non-root level paths of the object graph.
    * </p>
-   *
    * <pre>{@code
    *
    * List<Customer> customers =
@@ -412,42 +330,33 @@ public interface Query<T> {
    *
    * }</pre>
    *
-   * @param fetchProperties
-   *          the properties to fetch for this bean (* = all properties).
+   * @param fetchProperties the properties to fetch for this bean (* = all properties).
    */
   Query<T> select(String fetchProperties);
 
   /**
-   * Specify a path to <em>fetch</em> with its specific properties to include
-   * (aka partial object).
+   * Specify a path to fetch eagerly including specific properties.
    * <p>
-   * When you specify a join this means that property (associated bean(s)) will
-   * be fetched and populated. If you specify "*" then all the properties of the
-   * associated bean will be fetched and populated. You can specify a comma
-   * delimited list of the properties of that associated bean which means that
-   * only those properties are fetched and populated resulting in a
-   * "Partial Object" - a bean that only has some of its properties populated.
+   * Ebean will endeavour to fetch this path using a SQL join. If Ebean determines that it can
+   * not use a SQL join (due to maxRows or because it would result in a cartesian product) Ebean
+   * will automatically convert this fetch query into a "query join" - i.e. use fetchQuery().
    * </p>
-   * 
    * <pre>{@code
    *
    * // query orders...
    * List<Order> orders =
-   *     ebeanserver.find(Order.class)
+   *     ebeanServer.find(Order.class)
    *       // fetch the customer...
    *       // ... getting the customers name and phone number
    *       .fetch("customer", "name, phoneNumber")
-   * 
+   *
    *       // ... also fetch the customers billing address (* = all properties)
    *       .fetch("customer.billingAddress", "*")
    *       .findList();
    * }</pre>
-   * 
    * <p>
-   * If columns is null or "*" then all columns/properties for that path are
-   * fetched.
+   * If columns is null or "*" then all columns/properties for that path are fetched.
    * </p>
-   * 
    * <pre>{@code
    *
    * // fetch customers (their id, name and status)
@@ -458,19 +367,66 @@ public interface Query<T> {
    *     .findList();
    *
    * }</pre>
-   * 
-   * @param path
-   *          the path of an associated (1-1,1-M,M-1,M-M) bean.
-   * @param fetchProperties
-   *          properties of the associated bean that you want to include in the
-   *          fetch (* means all properties, null also means all properties).
+   *
+   * @param path            the property path we wish to fetch eagerly.
+   * @param fetchProperties properties of the associated bean that you want to include in the
+   *                        fetch (* means all properties, null also means all properties).
    */
   Query<T> fetch(String path, String fetchProperties);
 
+  /**
+   * Fetch the path and properties using a "query join" (separate SQL query).
+   * <p>
+   * This is the same as:
+   * </p>
+   * <pre>{@code
+   *
+   *  fetch(path, fetchProperties, new FetchConfig().query())
+   *
+   * }</pre>
+   * <p>
+   * This would be used instead of a fetch() when we use a separate SQL query to fetch this
+   * part of the object graph rather than a SQL join.
+   * </p>
+   * <p>
+   * We might typically get a performance benefit when the path to fetch is a OneToMany
+   * or ManyToMany, the 'width' of the 'root bean' is wide and the cardinality of the many
+   * is high.
+   * </p>
+   *
+   * @param path            the property path we wish to fetch eagerly.
+   * @param fetchProperties properties of the associated bean that you want to include in the
+   *                        fetch (* means all properties, null also means all properties).
+   */
+  Query<T> fetchQuery(String path, String fetchProperties);
+
+  /**
+   * Fetch the path and properties lazily (via batch lazy loading).
+   * <p>
+   * This is the same as:
+   * </p>
+   * <pre>{@code
+   *
+   *  fetch(path, fetchProperties, new FetchConfig().lazy())
+   *
+   * }</pre>
+   * <p>
+   * The reason for using fetchLazy() is to either:
+   * </p>
+   * <ul>
+   * <li>Control/tune what is fetched as part of lazy loading</li>
+   * <li>Make use of the L2 cache, build this part of the graph from L2 cache</li>
+   * </ul>
+   *
+   * @param path            the property path we wish to fetch lazily.
+   * @param fetchProperties properties of the associated bean that you want to include in the
+   *                        fetch (* means all properties, null also means all properties).
+   */
+  Query<T> fetchLazy(String path, String fetchProperties);
+
   /**
    * Additionally specify a FetchConfig to use a separate query or lazy loading
    * to load this path.
-   *
    * <pre>{@code
    *
    * // fetch customers (their id, name and status)
@@ -481,13 +437,17 @@ public interface Query<T> {
    *     .findList();
    *
    * }</pre>
+   *
+   * @param path the property path we wish to fetch eagerly.
    */
-  Query<T> fetch(String assocProperty, String fetchProperties, FetchConfig fetchConfig);
+  Query<T> fetch(String path, String fetchProperties, FetchConfig fetchConfig);
 
   /**
-   * Specify a path to load including all its properties.
+   * Specify a path to fetch eagerly including all its properties.
    * <p>
-   * The same as {@link #fetch(String, String)} with the fetchProperties as "*".
+   * Ebean will endeavour to fetch this path using a SQL join. If Ebean determines that it can
+   * not use a SQL join (due to maxRows or because it would result in a cartesian product) Ebean
+   * will automatically convert this fetch query into a "query join" - i.e. use fetchQuery().
    * </p>
    * <pre>{@code
    *
@@ -500,16 +460,59 @@ public interface Query<T> {
    *
    * }</pre>
    *
-   * @param path
-   *          the property of an associated (1-1,1-M,M-1,M-M) bean.
+   * @param path the property path we wish to fetch eagerly.
    */
   Query<T> fetch(String path);
 
+  /**
+   * Fetch the path eagerly using a "query join" (separate SQL query).
+   * <p>
+   * This is the same as:
+   * </p>
+   * <pre>{@code
+   *
+   *  fetch(path, new FetchConfig().query())
+   *
+   * }</pre>
+   * <p>
+   * This would be used instead of a fetch() when we use a separate SQL query to fetch this
+   * part of the object graph rather than a SQL join.
+   * </p>
+   * <p>
+   * We might typically get a performance benefit when the path to fetch is a OneToMany
+   * or ManyToMany, the 'width' of the 'root bean' is wide and the cardinality of the many
+   * is high.
+   * </p>
+   *
+   * @param path the property path we wish to fetch eagerly
+   */
+  Query<T> fetchQuery(String path);
+
+  /**
+   * Fetch the path lazily (via batch lazy loading).
+   * <p>
+   * This is the same as:
+   * </p>
+   * <pre>{@code
+   *
+   *  fetch(path, new FetchConfig().lazy())
+   *
+   * }</pre>
+   * <p>
+   * The reason for using fetchLazy() is to either:
+   * </p>
+   * <ul>
+   * <li>Control/tune what is fetched as part of lazy loading</li>
+   * <li>Make use of the L2 cache, build this part of the graph from L2 cache</li>
+   * </ul>
+   *
+   * @param path the property path we wish to fetch lazily.
+   */
+  Query<T> fetchLazy(String path);
+
   /**
    * Additionally specify a JoinConfig to specify a "query join" and or define
    * the lazy loading query.
-   *
-   *
    * <pre>{@code
    *
    * // fetch customers (their id, name and status)
@@ -536,7 +539,7 @@ public interface Query<T> {
    * <p>
    * This query will execute against the EbeanServer that was used to create it.
    * </p>
-   * 
+   *
    * @see EbeanServer#findIds(Query, Transaction)
    */
   List<Object> findIds();
@@ -564,7 +567,6 @@ public interface Query<T> {
    * iterator uses the QueryEachConsumer (SAM) interface which is better suited to use
    * with Java8 closures.
    * </p>
-   *
    * <pre>{@code
    *
    *  ebeanServer.find(Customer.class)
@@ -578,8 +580,7 @@ public interface Query<T> {
    *
    * }</pre>
    *
-   * @param consumer
-   *          the consumer used to process the queried beans.
+   * @param consumer the consumer used to process the queried beans.
    */
   void findEach(QueryEachConsumer<T> consumer);
 
@@ -591,8 +592,6 @@ public interface Query<T> {
    * iterator uses the QueryEachWhileConsumer (SAM) interface which is better suited to use
    * with Java8 closures.
    * </p>
-
-   *
    * <pre>{@code
    *
    *  ebeanServer.find(Customer.class)
@@ -611,8 +610,7 @@ public interface Query<T> {
    *
    * }</pre>
    *
-   * @param consumer
-   *          the consumer used to process the queried beans.
+   * @param consumer the consumer used to process the queried beans.
    */
   void findEachWhile(QueryEachWhileConsumer<T> consumer);
 
@@ -621,7 +619,6 @@ public interface Query<T> {
    * <p>
    * This query will execute against the EbeanServer that was used to create it.
    * </p>
-   *
    * <pre>{@code
    *
    * List<Customer> customers =
@@ -640,7 +637,6 @@ public interface Query<T> {
    * <p>
    * This query will execute against the EbeanServer that was used to create it.
    * </p>
-   *
    * <pre>{@code
    *
    * Set<Customer> customers =
@@ -663,7 +659,6 @@ public interface Query<T> {
    * You can use setMapKey() so specify the property values to be used as keys
    * on the map. If one is not specified then the id property is used.
    * </p>
-   * 
    * <pre>{@code
    *
    * Map<?, Product> map =
@@ -672,7 +667,7 @@ public interface Query<T> {
    *     .findMap();
    *
    * }</pre>
-   * 
+   *
    * @see EbeanServer#findMap(Query, Transaction)
    */
   Map<?, T> findMap();
@@ -693,7 +688,6 @@ public interface Query<T> {
    * This is useful when your predicates dictate that your query should only
    * return 0 or 1 results.
    * </p>
-   * 
    * <pre>{@code
    *
    * // assuming the sku of products is unique...
@@ -703,16 +697,14 @@ public interface Query<T> {
    *         .findUnique();
    * ...
    * }</pre>
-   * 
    * <p>
    * It is also useful with finding objects by their id when you want to specify
    * further join information.
    * </p>
-   * 
    * <pre>{@code
    *
    * // Fetch order 1 and additionally fetch join its order details...
-   * Order order = 
+   * Order order =
    *     ebeanServer.find(Order.class)
    *       .setId(1)
    *       .fetch("details")
@@ -731,13 +723,13 @@ public interface Query<T> {
   /**
    * Return versions of a @History entity bean.
    * <p>
-   *   Note that this query will work against view based history implementations
-   *   but not sql2011 standards based implementations that require a start and
-   *   end timestamp to be specified.
+   * Note that this query will work against view based history implementations
+   * but not sql2011 standards based implementations that require a start and
+   * end timestamp to be specified.
    * </p>
    * <p>
-   *   Generally this query is expected to be a find by id or unique predicates query.
-   *   It will execute the query against the history returning the versions of the bean.
+   * Generally this query is expected to be a find by id or unique predicates query.
+   * It will execute the query against the history returning the versions of the bean.
    * </p>
    */
   List<Version<T>> findVersions();
@@ -745,8 +737,8 @@ public interface Query<T> {
   /**
    * Return versions of a @History entity bean between the 2 timestamps.
    * <p>
-   *   Generally this query is expected to be a find by id or unique predicates query.
-   *   It will execute the query against the history returning the versions of the bean.
+   * Generally this query is expected to be a find by id or unique predicates query.
+   * It will execute the query against the history returning the versions of the bean.
    * </p>
    */
   List<Version<T>> findVersionsBetween(Timestamp start, Timestamp end);
@@ -774,6 +766,15 @@ public interface Query<T> {
    * This is the number of 'top level' or 'root level' entities.
    * </p>
    */
+  int findCount();
+
+  /**
+   * Deprecated in favor of findCount().
+   * <p>
+   * Return the count of entities this query should return.
+   *
+   * @deprecated
+   */
   int findRowCount();
 
   /**
@@ -783,9 +784,24 @@ public interface Query<T> {
    * execution status (isDone etc) and get the value (with or without a
    * timeout).
    * </p>
-   * 
+   *
    * @return a Future object for the row count query
    */
+  FutureRowCount<T> findFutureCount();
+
+  /**
+   * Deprecated in favor of findFutureCount().
+   * <p>
+   * Execute find row count query in a background thread.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a
+   * timeout).
+   * </p>
+   *
+   * @return a Future object for the row count query
+   * @deprecated
+   */
   FutureRowCount<T> findFutureRowCount();
 
   /**
@@ -795,7 +811,7 @@ public interface Query<T> {
    * execution status (isDone etc) and get the value (with or without a
    * timeout).
    * </p>
-   * 
+   *
    * @return a Future object for the list of Id's
    */
   FutureIds<T> findFutureIds();
@@ -821,7 +837,6 @@ public interface Query<T> {
    * If maxRows is not set on the query prior to calling findPagedList() then a
    * PersistenceException is thrown.
    * </p>
-   *
    * <pre>{@code
    *
    *  PagedList<Order> pagedList = Ebean.find(Order.class)
@@ -843,24 +858,21 @@ public interface Query<T> {
 
   /**
    * Set a named bind parameter. Named parameters have a colon to prefix the name.
-   * 
    * <pre>{@code
    *
    * // a query with a named parameter
    * String oql = "find order where status = :orderStatus";
-   * 
+   *
    * Query<Order> query = ebeanServer.find(Order.class, oql);
-   * 
+   *
    * // bind the named parameter
    * query.bind("orderStatus", OrderStatus.NEW);
    * List<Order> list = query.findList();
    *
    * }</pre>
-   * 
-   * @param name
-   *          the parameter name
-   * @param value
-   *          the parameter value
+   *
+   * @param name  the parameter name
+   * @param value the parameter value
    */
   Query<T> setParameter(String name, Object value);
 
@@ -868,25 +880,22 @@ public interface Query<T> {
    * Set an ordered bind parameter according to its position. Note that the
    * position starts at 1 to be consistent with JDBC PreparedStatement. You need
    * to set a parameter value for each ? you have in the query.
-   * 
    * <pre>{@code
    *
    * // a query with a positioned parameter
    * String oql = "where status = ? order by id desc";
-   * 
+   *
    * Query<Order> query = ebeanServer.createQuery(Order.class, oql);
-   * 
+   *
    * // bind the parameter
    * query.setParameter(1, OrderStatus.NEW);
-   * 
+   *
    * List<Order> list = query.findList();
    *
    * }</pre>
-   * 
-   * @param position
-   *          the parameter bind position starting from 1 (not 0)
-   * @param value
-   *          the parameter bind value.
+   *
+   * @param position the parameter bind position starting from 1 (not 0)
+   * @param value    the parameter bind value.
    */
   Query<T> setParameter(int position, Object value);
 
@@ -896,7 +905,6 @@ public interface Query<T> {
    * You can use this to have further control over the query. For example adding
    * fetch joins.
    * </p>
-   * 
    * <pre>{@code
    *
    * Order order =
@@ -919,10 +927,9 @@ public interface Query<T> {
 
   /**
    * Add a single Expression to the where clause returning the query.
-   * 
    * <pre>{@code
    *
-   * List<Order> newOrders = 
+   * List<Order> newOrders =
    *     ebeanServer.find(Order.class)
    * 		.where().eq("status", Order.NEW)
    * 		.findList();
@@ -936,7 +943,6 @@ public interface Query<T> {
    * Add Expressions to the where clause with the ability to chain on the
    * ExpressionList. You can use this for adding multiple expressions to the
    * where clause.
-   * 
    * <pre>{@code
    *
    * List<Order> orders =
@@ -947,9 +953,9 @@ public interface Query<T> {
    *     .findList();
    *
    * }</pre>
-   * 
-   * @see Expr
+   *
    * @return The ExpressionList for adding expressions to.
+   * @see Expr
    */
   ExpressionList<T> where();
 
@@ -984,9 +990,8 @@ public interface Query<T> {
    * each customer you only want to get the new orders they placed since last
    * week. In this case you can use filterMany() to filter the orders.
    * </p>
-   * 
    * <pre>{@code
-   * 
+   *
    * List<Customer> list =
    *     ebeanServer.find(Customer.class)
    *     // .fetch("orders", new FetchConfig().lazy())
@@ -995,20 +1000,17 @@ public interface Query<T> {
    *     .where().ilike("name", "rob%")
    *     .filterMany("orders").eq("status", Order.Status.NEW).gt("orderDate", lastWeek)
    *     .findList();
-   * 
+   *
    * }</pre>
-   * 
    * <p>
    * Please note you have to be careful that you add expressions to the correct
    * expression list - as there is one for the 'root level' and one for each
    * filterMany that you have.
    * </p>
-   * 
-   * @param propertyName
-   *          the name of the many property that you want to have a filter on.
-   * 
+   *
+   * @param propertyName the name of the many property that you want to have a filter on.
    * @return the expression list that you add filter expressions for the many
-   *         to.
+   * to.
    */
   ExpressionList<T> filterMany(String propertyName);
 
@@ -1021,9 +1023,9 @@ public interface Query<T> {
    * Note that this returns the ExpressionList (so you can add multiple
    * expressions to the query in a fluent API way).
    * </p>
-   * 
-   * @see Expr
+   *
    * @return The ExpressionList for adding more expressions to.
+   * @see Expr
    */
   ExpressionList<T> having();
 
@@ -1037,9 +1039,8 @@ public interface Query<T> {
    * than the ExpressionList. This is useful when you want to further specify
    * something on the query.
    * </p>
-   * 
-   * @param addExpressionToHaving
-   *          the expression to add to the having clause.
+   *
+   * @param addExpressionToHaving the expression to add to the having clause.
    * @return the Query object
    */
   Query<T> having(Expression addExpressionToHaving);
@@ -1151,9 +1152,8 @@ public interface Query<T> {
 
   /**
    * Set the maximum number of rows to return in the query.
-   * 
-   * @param maxRows
-   *          the maximum number of rows to return in the query.
+   *
+   * @param maxRows the maximum number of rows to return in the query.
    */
   Query<T> setMaxRows(int maxRows);
 
@@ -1162,11 +1162,10 @@ public interface Query<T> {
    * <p>
    * If no property is set then the id property is used.
    * </p>
-   * 
    * <pre>{@code
    *
    * // Assuming sku is unique for products...
-   *    
+   *
    * Map<?,Product> productMap =
    *     ebeanServer.find(Product.class)
    *     // use sku for keys...
@@ -1174,9 +1173,8 @@ public interface Query<T> {
    *     .findMap();
    *
    * }</pre>
-   * 
-   * @param mapKey
-   *          the property to use as keys for a map.
+   *
+   * @param mapKey the property to use as keys for a map.
    */
   Query<T> setMapKey(String mapKey);
 
@@ -1203,7 +1201,7 @@ public interface Query<T> {
   /**
    * Set to true if this query should execute against the doc store.
    * <p>
-   *   When setting this you may also consider disabling lazy loading.
+   * When setting this you may also consider disabling lazy loading.
    * </p>
    */
   Query<T> setUseDocStore(boolean useDocStore);
@@ -1226,9 +1224,8 @@ public interface Query<T> {
    * preparedStatement. If the timeout occurs an exception will be thrown - this
    * will be a SQLException wrapped up in a PersistenceException.
    * </p>
-   * 
-   * @param secs
-   *          the query timeout limit in seconds. Zero means there is no limit.
+   *
+   * @param secs the query timeout limit in seconds. Zero means there is no limit.
    */
   Query<T> setTimeout(int secs);
 
@@ -1238,6 +1235,16 @@ public interface Query<T> {
    * Gives the JDBC driver a hint as to the number of rows that should be
    * fetched from the database when more rows are needed for ResultSet.
    * </p>
+   * <p>
+   * Note that internally findEach and findEachWhile will set the fetch size
+   * if it has not already as these queries expect to process a lot of rows.
+   * If we didn't then Postgres and MySql for example would eagerly pull back
+   * all the row data and potentially consume a lot of memory in the process.
+   * </p>
+   * <p>
+   * As findEach and findEachWhile automatically set the fetch size we don't have
+   * to do so generally but we might still wish to for tuning a specific use case.
+   * </p>
    */
   Query<T> setBufferFetchSizeHint(int fetchSize);
 
@@ -1260,7 +1267,7 @@ public interface Query<T> {
    * Return true if this query has forUpdate set.
    */
   boolean isForUpdate();
-  
+
   /**
    * Set root table alias.
    */
@@ -1274,7 +1281,7 @@ public interface Query<T> {
   /**
    * Set true if you want to disable lazy loading.
    * <p>
-   *   That is, once the object graph is returned further lazy loading is disabled.
+   * That is, once the object graph is returned further lazy loading is disabled.
    * </p>
    */
   Query<T> setDisableLazyLoading(boolean disableLazyLoading);

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

@@ -606,9 +606,9 @@ public final class RawSql implements Serializable {
         }
       }
 
-      private static String derivePropertyName(String dbAlias, String dbColumn) {
+      protected static String derivePropertyName(String dbAlias, String dbColumn) {
         if (dbAlias != null) {
-          return dbAlias;
+          return CamelCaseHelper.toCamelFromUnderscore(dbAlias);
         }
         int dotPos = dbColumn.indexOf('.');
         if (dotPos > -1) {

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

@@ -2,8 +2,6 @@ package com.avaje.ebean;
 
 import java.io.Serializable;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 /**
  * Query object for performing native SQL queries that return SqlRow's.

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

@@ -117,8 +117,7 @@ public interface SqlUpdate {
   SqlUpdate setParameter(int position, Object value);
 
   /**
-   * Set a null parameter via its index position. Exactly the same as
-   * {@link #setNull(int, int)}.
+   * Set a null parameter via its index position.
    */
   SqlUpdate setNull(int position, int jdbcType);
 

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

@@ -74,6 +74,11 @@ public interface Transaction extends Closeable {
    */
   void rollback(Throwable e) throws PersistenceException;
 
+  /**
+   * Mark the transaction for rollback only.
+   */
+  void setRollbackOnly();
+
   /**
    * If the transaction is active then perform rollback. Otherwise do nothing.
    */

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

@@ -31,6 +31,11 @@ public interface BeanCollection<E> extends Serializable {
     ALL
   }
 
+  /**
+   * Set the disableLazyLoad state.
+   */
+  void setDisableLazyLoad(boolean disableLazyLoad);
+
   /**
    * Load bean from another collection.
    */

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

@@ -39,6 +39,8 @@ public final class EntityBeanIntercept implements Serializable {
 
   private transient BeanLoader beanLoader;
 
+  private transient PreGetterCallback preGetterCallback;
+
   private String ebeanServerName;
 
   /**
@@ -186,6 +188,21 @@ public final class EntityBeanIntercept implements Serializable {
     return embeddedOwnerIndex;
   }
 
+  /**
+   * Clear the getter callback.
+   */
+  public void clearGetterCallback() {
+    this.preGetterCallback = null;
+  }
+
+  /**
+   * Register the callback to be triggered when getter is called.
+   * This is used primarily to automatically flush the JDBC batch.
+   */
+  public void registerGetterCallback(PreGetterCallback getterCallback) {
+    this.preGetterCallback = getterCallback;
+  }
+
   /**
    * Set the embedded beans owning bean.
    */
@@ -832,19 +849,31 @@ public final class EntityBeanIntercept implements Serializable {
   public void initialisedMany(int propertyIndex) {
     loadedProps[propertyIndex] = true;
   }
-  
+
+  private final void preGetterCallback() {
+    if (preGetterCallback != null) {
+      preGetterCallback.preGetterTrigger();
+    }
+  }
+
+  /**
+   * Called prior to Id property getter.
+   */
+  public void preGetId() {
+    preGetterCallback();
+  }
+
   /**
    * Method that is called prior to a getter method on the actual entity.
    */
   public void preGetter(int propertyIndex) {
+    preGetterCallback();
     if (state == STATE_NEW || disableLazyLoad) {
       return;
     }
-    
     if (!isLoadedProperty(propertyIndex)) {
       loadBean(propertyIndex);
     }
-
     if (nodeUsageCollector != null) {
       nodeUsageCollector.addUsed(getProperty(propertyIndex));
     }

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

@@ -0,0 +1,13 @@
+package com.avaje.ebean.bean;
+
+/**
+ * A callback that can be registered to fire on getter method calls.
+ * It's primary purpose is to automatically flush JDBC batch buffer.
+ */
+public interface PreGetterCallback {
+
+  /**
+   * Trigger the callback.
+   */
+  void preGetterTrigger();
+}

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

@@ -20,6 +20,8 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
 
   protected boolean readOnly;
 
+  protected boolean disableLazyLoad;
+
   /**
    * The EbeanServer this is associated with. (used for lazy fetch).
    */
@@ -84,6 +86,11 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     this.filterMany = filterMany;
   }
 
+  @Override
+  public void setDisableLazyLoad(boolean disableLazyLoad) {
+    this.disableLazyLoad = disableLazyLoad;
+  }
+
   protected void lazyLoadCollection(boolean onlyIds) {
     if (loader == null) {
       loader = (BeanCollectionLoader) Ebean.getServer(ebeanServerName);

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

@@ -102,7 +102,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   private void initClear() {
     synchronized (this) {
       if (list == null) {
-        if (modifyListening) {
+        if (!disableLazyLoad && modifyListening) {
           lazyLoadCollection(true);
         } else {
           list = new ArrayList<E>();
@@ -114,7 +114,11 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   private void init() {
     synchronized (this) {
       if (list == null) {
-        lazyLoadCollection(false);
+        if (disableLazyLoad) {
+          list = new ArrayList<E>();
+        } else {
+          lazyLoadCollection(false);
+        }
       }
     }
   }

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

@@ -198,9 +198,11 @@ public class ServerConfig {
   private PersistBatch persistBatch = PersistBatch.NONE;
 
   /**
-   * Use for per request batch mode.
+   * Use for cascade persist JDBC batch mode. INHERIT means use the platform default
+   * which is ALL except for SQL Server where it is NONE (as getGeneratedKeys isn't
+   * supported on SQL Server with JDBC batch).
    */
-  private PersistBatch persistBatchOnCascade = PersistBatch.NONE;
+  private PersistBatch persistBatchOnCascade = PersistBatch.INHERIT;
 
   private int persistBatchSize = 20;
 
@@ -318,7 +320,7 @@ public class ServerConfig {
   /**
    * Setting to indicate if UUID should be stored as binary(16) or varchar(40) or native DB type (for H2 and Postgres).
    */
-  private DbUuid dbUuid = DbUuid.AUTO;
+  private DbUuid dbUuid = DbUuid.AUTO_VARCHAR;
 
 
   private List<IdGenerator> idGenerators = new ArrayList<IdGenerator>();
@@ -377,19 +379,13 @@ public class ServerConfig {
 
   private boolean transactionRollbackOnChecked = true;
 
-  private boolean registerJmxMBeans = true;
-
   // configuration for the background executor service (thread pool)
 
   private int backgroundExecutorSchedulePoolSize = 1;
-  private int backgroundExecutorCorePoolSize = 1;
-  private int backgroundExecutorMaxPoolSize = 8;
-  private int backgroundExecutorIdleSecs = 60;
   private int backgroundExecutorShutdownSecs = 30;
 
   // defaults for the L2 bean caching
 
-  private int cacheWarmingDelay = 30;
   private int cacheMaxSize = 10000;
   private int cacheMaxIdleTime = 600;
   private int cacheMaxTimeToLive = 60 * 60 * 6;
@@ -407,7 +403,7 @@ public class ServerConfig {
   private boolean expressionEqualsWithNullAsNoop;
 
   /**
-   * Set to true to use native ILIKE expression (if support by datasbase platform / like Postgres).
+   * Set to true to use native ILIKE expression (if support by database platform / like Postgres).
    */
   private boolean expressionNativeIlike;
 
@@ -1040,20 +1036,6 @@ public class ServerConfig {
     this.transactionRollbackOnChecked = transactionRollbackOnChecked;
   }
 
-  /**
-   * Return true if the server should register JMX MBeans.
-   */
-  public boolean isRegisterJmxMBeans() {
-    return registerJmxMBeans;
-  }
-
-  /**
-   * Set if the server should register JMX MBeans.
-   */
-  public void setRegisterJmxMBeans(boolean registerJmxMBeans) {
-    this.registerJmxMBeans = registerJmxMBeans;
-  }
-
   /**
    * Return the Background executor schedule pool size. Defaults to 1.
    */
@@ -1068,48 +1050,6 @@ public class ServerConfig {
     this.backgroundExecutorSchedulePoolSize = backgroundExecutorSchedulePoolSize;
   }
 
-  /**
-   * Return the Background executor core pool size.
-   */
-  public int getBackgroundExecutorCorePoolSize() {
-    return backgroundExecutorCorePoolSize;
-  }
-
-  /**
-   * Set the Background executor core pool size.
-   */
-  public void setBackgroundExecutorCorePoolSize(int backgroundExecutorCorePoolSize) {
-    this.backgroundExecutorCorePoolSize = backgroundExecutorCorePoolSize;
-  }
-
-  /**
-   * Return the Background executor max pool size.
-   */
-  public int getBackgroundExecutorMaxPoolSize() {
-    return backgroundExecutorMaxPoolSize;
-  }
-
-  /**
-   * Set the Background executor max pool size.
-   */
-  public void setBackgroundExecutorMaxPoolSize(int backgroundExecutorMaxPoolSize) {
-    this.backgroundExecutorMaxPoolSize = backgroundExecutorMaxPoolSize;
-  }
-
-  /**
-   * Return the Background executor idle seconds.
-   */
-  public int getBackgroundExecutorIdleSecs() {
-    return backgroundExecutorIdleSecs;
-  }
-
-  /**
-   * Set the Background executor idle seconds.
-   */
-  public void setBackgroundExecutorIdleSecs(int backgroundExecutorIdleSecs) {
-    this.backgroundExecutorIdleSecs = backgroundExecutorIdleSecs;
-  }
-
   /**
    * Return the Background executor shutdown seconds. This is the time allowed for the pool to shutdown nicely
    * before it is forced shutdown.
@@ -1126,20 +1066,6 @@ public class ServerConfig {
     this.backgroundExecutorShutdownSecs = backgroundExecutorShutdownSecs;
   }
 
-  /**
-   * Return the cache warming delay in seconds.
-   */
-  public int getCacheWarmingDelay() {
-    return cacheWarmingDelay;
-  }
-
-  /**
-   * Set the cache warming delay in seconds.
-   */
-  public void setCacheWarmingDelay(int cacheWarmingDelay) {
-    this.cacheWarmingDelay = cacheWarmingDelay;
-  }
-
   /**
    * Return the L2 cache default max size.
    */
@@ -2397,6 +2323,8 @@ public class ServerConfig {
     autoCommitMode = p.getBoolean("autoCommitMode", autoCommitMode);
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
 
+    backgroundExecutorSchedulePoolSize = p.getInt("backgroundExecutorSchedulePoolSize", backgroundExecutorSchedulePoolSize);
+    backgroundExecutorShutdownSecs = p.getInt("backgroundExecutorShutdownSecs", backgroundExecutorShutdownSecs);
     disableClasspathSearch = p.getBoolean("disableClasspathSearch", disableClasspathSearch);
     currentUserProvider = createInstance(p, CurrentUserProvider.class, "currentUserProvider", currentUserProvider);
     databasePlatform = createInstance(p, DatabasePlatform.class, "databasePlatform", databasePlatform);
@@ -2406,7 +2334,6 @@ public class ServerConfig {
     dbEncrypt = createInstance(p, DbEncrypt.class, "dbEncrypt", dbEncrypt);
     serverCachePlugin = createInstance(p, ServerCachePlugin.class, "serverCachePlugin", serverCachePlugin);
     serverCacheManager = createInstance(p, ServerCacheManager.class, "serverCacheManager", serverCacheManager);
-    cacheWarmingDelay = p.getInt("cacheWarmingDelay", cacheWarmingDelay);
 
     if (packages != null) {
       String packagesProp = p.get("search.packages", p.get("packages", null));
@@ -2530,13 +2457,14 @@ public class ServerConfig {
   /**
    * Return the PersistBatch mode to use for 'batchOnCascade' taking into account if the database
    * platform supports getGeneratedKeys in batch mode.
-   * <p>
-   * Used to effectively turn off batchOnCascade for SQL Server - still allows explicit batch mode.
-   * </p>
    */
   public PersistBatch appliedPersistBatchOnCascade() {
 
-    return databasePlatform.isDisallowBatchOnCascade() ? PersistBatch.NONE : persistBatchOnCascade;
+    if (persistBatchOnCascade == PersistBatch.INHERIT) {
+      // use the platform default (ALL except SQL Server which has NONE)
+      return databasePlatform.getPersistBatchOnCascade();
+    }
+    return persistBatchOnCascade;
   }
 
   /**
@@ -2612,18 +2540,45 @@ public class ServerConfig {
   public enum DbUuid {
 
     /**
-     * Store using native UUID in H2 and Postgres.
+     * Store using native UUID in H2 and Postgres and otherwise fallback to VARCHAR(40).
      */
-    AUTO,
+    AUTO_VARCHAR(true, false),
 
     /**
-     * Store using DB VARCHAR.
+     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16).
      */
-    VARCHAR,
+    AUTO_BINARY(true, true),
 
     /**
-     * Store using DB BINARY.
+     * Store using DB VARCHAR(40).
      */
-    BINARY
+    VARCHAR(false, false),
+
+    /**
+     * Store using DB BINARY(16).
+     */
+    BINARY(false, true);
+
+    boolean nativeType;
+    boolean binary;
+
+    DbUuid(boolean nativeType, boolean binary) {
+      this.nativeType = nativeType;
+      this.binary = binary;
+    }
+
+    /**
+     * Return true if native UUID type is preferred.
+     */
+    public boolean useNativeType() {
+      return nativeType;
+    }
+
+    /**
+     * Return true if BINARY(16) storage is preferred over VARCHAR(40).
+     */
+    public boolean useBinary() {
+      return binary;
+    }
   }
 }

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

@@ -2,6 +2,7 @@ package com.avaje.ebean.config.dbplatform;
 
 import com.avaje.ebean.BackgroundExecutor;
 import com.avaje.ebean.Query;
+import com.avaje.ebean.config.PersistBatch;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
 import com.avaje.ebean.dbmigration.ddlgeneration.platform.PlatformDdl;
@@ -14,7 +15,6 @@ import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Types;
-import java.util.Properties;
 
 /**
  * Database platform specific settings.
@@ -155,11 +155,9 @@ public class DatabasePlatform {
   protected boolean forwardOnlyHintOnFindIterate;
 
   /**
-   * Flag set for SQL Server due to lack of support of getGeneratedKeys in
-   * batch mode (meaning for batch inserts you should explicitly turn off
-   * getGeneratedKeys - joy).
+   * By default we use JDBC batch when cascading (except for SQL Server).
    */
-  protected boolean disallowBatchOnCascade;
+  protected PersistBatch persistBatchOnCascade = PersistBatch.ALL;
 
   protected PlatformDdl platformDdl;
 
@@ -183,8 +181,11 @@ public class DatabasePlatform {
   public DatabasePlatform() {
   }
 
-  public void configure(Properties properties) {
-    // by default do nothing
+  /**
+   * Configure UUID Storage etc based on ServerConfig settings.
+   */
+  public void configure(ServerConfig serverConfig) {
+    dbTypeMap.config(nativeUuidType, serverConfig.getDbUuid());
   }
 
   /**
@@ -542,14 +543,10 @@ public class DatabasePlatform {
   }
 
   /**
-   * Return true if the persistBatchOnCascade setting should be ignored.
-   * <p>
-   * This is primarily for SQL Server which does not support getGeneratedKeys with jdbc batch mode
-   * so can't really be transparently used.
-   * </p>
+   * Return the platform default JDBC batch mode for persist cascade.
    */
-  public boolean isDisallowBatchOnCascade() {
-    return disallowBatchOnCascade;
+  public PersistBatch getPersistBatchOnCascade() {
+    return persistBatchOnCascade;
   }
 
   /**

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

@@ -152,4 +152,10 @@ public class DbType {
     return sb.toString();
   }
 
+  /**
+   * Create a copy of the type with a new default length.
+   */
+  public DbType withLength(int defaultLength) {
+    return new DbType(name, defaultLength);
+  }
 }

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

@@ -1,5 +1,7 @@
 package com.avaje.ebean.config.dbplatform;
 
+import com.avaje.ebean.config.ServerConfig;
+
 import java.sql.Types;
 import java.util.HashMap;
 import java.util.Map;
@@ -9,6 +11,8 @@ import java.util.Map;
  */
 public class DbTypeMap {
 
+  private static final DbType UUID_NATIVE = new DbType("uuid", false);
+  private static final DbType UUID_PLACEHOLDER = new DbType("uuidPlaceholder");
   private static final DbType JSON_CLOB_PLACEHOLDER = new DbType("jsonClobPlaceholder");
   private static final DbType JSON_BLOB_PLACEHOLDER = new DbType("jsonBlobPlaceholder");
   private static final DbType JSON_VARCHAR_PLACEHOLDER = new DbType("jsonVarcharPlaceholder");
@@ -66,7 +70,7 @@ public class DbTypeMap {
 
   /**
    * Return the DbTypeMap with standard (not platform specific) types.
-   *
+   * <p>
    * This has some extended JSON types (JSON, JSONB, JSONVarchar, JSONClob, JSONBlob).
    * These types get translated to specific database platform types during DDL generation.
    */
@@ -104,8 +108,6 @@ public class DbTypeMap {
     put(Types.BLOB, new DbType("blob"));
     put(Types.CLOB, new DbType("clob"));
 
-    // DB native UUID support (H2 and Postgres)
-    put(DbType.UUID, new DbType("uuid"));
     put(Types.ARRAY, new DbType("array"));
 
     if (logicalTypes) {
@@ -116,6 +118,7 @@ public class DbTypeMap {
       put(DbType.JSONClob, new DbType("jsonclob"));
       put(DbType.JSONBlob, new DbType("jsonblob"));
       put(DbType.JSONVarchar, new DbType("jsonvarchar", 1000));
+      put(DbType.UUID, UUID_NATIVE);
 
     } else {
       put(DbType.JSON, JSON_CLOB_PLACEHOLDER); // Postgres maps this to JSON
@@ -123,6 +126,7 @@ public class DbTypeMap {
       put(DbType.JSONClob, JSON_CLOB_PLACEHOLDER);
       put(DbType.JSONBlob, JSON_BLOB_PLACEHOLDER);
       put(DbType.JSONVarchar, JSON_VARCHAR_PLACEHOLDER);
+      put(DbType.UUID, UUID_PLACEHOLDER);
     }
 
     put(Types.LONGVARBINARY, new DbType("longvarbinary"));
@@ -133,7 +137,6 @@ public class DbTypeMap {
     put(Types.DATE, new DbType("date"));
     put(Types.TIME, new DbType("time"));
     put(Types.TIMESTAMP, new DbType("timestamp"));
-
   }
 
   /**
@@ -191,4 +194,17 @@ public class DbTypeMap {
   public DbType get(int jdbcType) {
     return typeMap.get(jdbcType);
   }
+
+  /**
+   * Map the UUID appropriately based on native DB support and ServerConfig.DbUuid.
+   */
+  public void config(boolean nativeUuidType, ServerConfig.DbUuid dbUuid) {
+    if (nativeUuidType && dbUuid.useNativeType()) {
+      put(DbType.UUID, UUID_NATIVE);
+    } else if (dbUuid.useBinary()) {
+      put(DbType.UUID, get(Types.BINARY).withLength(16));
+    } else {
+      put(DbType.UUID, get(Types.VARCHAR).withLength(40));
+    }
+  }
 }

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

@@ -9,9 +9,7 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Timestamp;
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
 
 /**
  * H2 database trigger used to populate history tables to support the @History feature.
@@ -54,7 +52,6 @@ public class H2HistoryTrigger implements Trigger {
     insertSql.append("insert into ").append(tableName).append(HISTORY_SUFFIX).append(" (");
 
     int count = 0;
-    List<String> columns = new ArrayList<String>();
     while (rs.next()) {
       if (++count > 1) {
         insertSql.append(",");
@@ -66,7 +63,6 @@ public class H2HistoryTrigger implements Trigger {
         this.effectEndPosition = count - 1;
       }
       insertSql.append(columnName);
-      columns.add(columnName);
     }
     insertSql.append(") values (");
     for (int i = 0; i < count; i++) {

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

@@ -1,9 +1,11 @@
 package com.avaje.ebean.config.dbplatform;
 
 import com.avaje.ebean.BackgroundExecutor;
+import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.dbmigration.ddlgeneration.platform.H2Ddl;
 
 import javax.sql.DataSource;
+import java.util.Properties;
 
 /**
  * H2 specific platform.
@@ -19,9 +21,7 @@ public class H2Platform extends DatabasePlatform {
     this.nativeUuidType = true;
     this.dbDefaultValue.setNow("now()");
 
-    // only support getGeneratedKeys with non-batch JDBC
-    // so generally use SEQUENCE instead of IDENTITY for H2
-    this.dbIdentity.setIdType(IdType.SEQUENCE);
+    this.dbIdentity.setIdType(IdType.IDENTITY);
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsSequence(true);
     this.dbIdentity.setSupportsIdentity(true);
@@ -34,6 +34,18 @@ public class H2Platform extends DatabasePlatform {
     // so no changes to dbTypeMap required
   }
 
+  @Override
+  public void configure(ServerConfig serverConfig) {
+    super.configure(serverConfig);
+    Properties properties = serverConfig.getProperties();
+    if (properties != null) {
+      String idType = properties.getProperty("ebean.h2.idtype");
+      if (idType != null) {
+        this.dbIdentity.setIdType(IdType.valueOf(idType));
+      }
+    }
+  }
+
   /**
    * Return a H2 specific sequence IdGenerator that supports batch fetching
    * sequence values.

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

@@ -1,5 +1,7 @@
 package com.avaje.ebean.config.dbplatform;
 
+import com.avaje.ebean.config.PersistBatch;
+
 import java.sql.Types;
 
 /**
@@ -18,6 +20,7 @@ public class MsSqlServer2000Platform extends DatabasePlatform {
   public MsSqlServer2000Platform() {
     super();
     this.name = "mssqlserver2000";
+    this.persistBatchOnCascade = PersistBatch.NONE;
     this.dbIdentity.setIdType(IdType.IDENTITY);
     this.dbIdentity.setSupportsGetGeneratedKeys(false);
     this.dbIdentity.setSelectLastInsertedIdTemplate("select @@IDENTITY as X");

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

@@ -1,5 +1,6 @@
 package com.avaje.ebean.config.dbplatform;
 
+import com.avaje.ebean.config.PersistBatch;
 import com.avaje.ebean.dbmigration.ddlgeneration.platform.MsSqlServerDdl;
 
 import java.sql.Types;
@@ -21,7 +22,7 @@ public class MsSqlServer2005Platform extends DatabasePlatform {
     this.name = "mssqlserver2005";
     // effectively disable persistBatchOnCascade mode for SQL Server
     // due to lack of support for getGeneratedKeys in batch mode
-    this.disallowBatchOnCascade = true;
+    this.persistBatchOnCascade = PersistBatch.NONE;
     this.idInExpandedForm = true;
     this.selectCountWithAlias = true;
     this.sqlLimiter = new MsSqlServer2005SqlLimiter();

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

@@ -64,12 +64,15 @@ public class PostgresPlatform extends DatabasePlatform {
   }
 
   @Override
-  public void configure(Properties properties) {
-    super.configure(properties);
-    String tsType = properties.getProperty("ebean.postgres.timestamp");
-    if (tsType != null) {
-      // set timestamp type to "timestamp" without time zone
-      dbTypeMap.put(Types.TIMESTAMP, new DbType(tsType));
+  public void configure(ServerConfig serverConfig) {
+    super.configure(serverConfig);
+    Properties properties = serverConfig.getProperties();
+    if (properties != null) {
+      String tsType = properties.getProperty("ebean.postgres.timestamp");
+      if (tsType != null) {
+        // set timestamp type to "timestamp" without time zone
+        dbTypeMap.put(Types.TIMESTAMP, new DbType(tsType));
+      }
     }
   }
 

src/main/java/com/avaje/ebean/dbmigration/DbMigration.java

@@ -164,9 +164,6 @@ public class DbMigration {
    * </p>
    */
   public void addPlatform(DbPlatformName platform, String prefix) {
-    if (!prefix.endsWith("-")) {
-      prefix += "-";
-    }
     platforms.add(new Pair(getPlatform(platform), prefix));
   }
 
@@ -204,13 +201,20 @@ public class DbMigration {
 
     // use this flag to stop other plugins like full DDL generation
     if (!online) {
-      DbOffline.setRunningMigration();
+      DbOffline.setGenerateMigration();
+      if (databasePlatform == null && !platforms.isEmpty()) {
+        // for multiple platform generation set the general platform
+        // to H2 so that it runs offline without DB connection
+        setPlatform(platforms.get(0).platform);
+      }
     }
     setDefaults();
     try {
       Request request = createRequest();
 
-      generateExtraDdl(request);
+      if (platforms.isEmpty()) {
+        generateExtraDdl(request.migrationDir, databasePlatform);
+      }
 
       String pendingVersion = generatePendingDrop();
       if (pendingVersion != null) {
@@ -234,15 +238,15 @@ public class DbMigration {
    * migration runner.
    * </p>
    */
-  private void generateExtraDdl(Request request) throws IOException {
+  private void generateExtraDdl(File migrationDir, DatabasePlatform dbPlatform) throws IOException {
 
-    if (databasePlatform != null) {
+    if (dbPlatform != null) {
       ExtraDdl extraDdl = ExtraDdlXmlReader.read("/extra-ddl.xml");
       if (extraDdl != null) {
         List<DdlScript> ddlScript = extraDdl.getDdlScript();
         for (DdlScript script : ddlScript) {
-          if (ExtraDdlXmlReader.matchPlatform(databasePlatform.getName(), script.getPlatforms())) {
-            writeExtraDdl(request, script);
+          if (ExtraDdlXmlReader.matchPlatform(dbPlatform.getName(), script.getPlatforms())) {
+            writeExtraDdl(migrationDir, script);
           }
         }
       }
@@ -252,13 +256,13 @@ public class DbMigration {
   /**
    * Write (or override) the "repeatable" migration script.
    */
-  private void writeExtraDdl(Request request, DdlScript script) throws IOException {
+  private void writeExtraDdl(File migrationDir, DdlScript script) throws IOException {
 
     String fullName = repeatableMigrationName(script.getName());
 
     logger.info("writing repeatable script {}", fullName);
 
-    File file = new File(request.migrationDir, fullName);
+    File file = new File(migrationDir, fullName);
     FileWriter writer = new FileWriter(file);
     writer.write(script.getValue());
     writer.flush();
@@ -363,14 +367,16 @@ public class DbMigration {
       logger.warn("migration already exists, not generating DDL");
 
     } else {
-      if (databasePlatform != null) {
+      if (!platforms.isEmpty()) {
+        writeExtraPlatformDdl(fullVersion, request.currentModel, dbMigration, request.migrationDir);
+
+      } else if (databasePlatform != null) {
         // writer needs the current model to provide table/column details for
         // history ddl generation (triggers, history tables etc)
         DdlWrite write = new DdlWrite(new MConfiguration(), request.current);
         PlatformDdlWriter writer = createDdlWriter(databasePlatform, "");
         writer.processMigration(dbMigration, write, request.migrationDir, fullVersion);
       }
-      writeExtraPlatformDdl(fullVersion, request.currentModel, dbMigration, request.migrationDir);
     }
   }
 
@@ -426,7 +432,10 @@ public class DbMigration {
     for (Pair pair : platforms) {
       DdlWrite platformBuffer = new DdlWrite(new MConfiguration(), currentModel.read());
       PlatformDdlWriter platformWriter = createDdlWriter(pair);
-      platformWriter.processMigration(dbMigration, platformBuffer, writePath, fullVersion);
+      File subPath = platformWriter.subPath(writePath, pair.prefix);
+      platformWriter.processMigration(dbMigration, platformBuffer, subPath, fullVersion);
+
+      generateExtraDdl(subPath, pair.platform);
     }
   }
 

src/main/java/com/avaje/ebean/dbmigration/DbOffline.java

@@ -14,7 +14,7 @@ public class DbOffline {
 
   private static final String KEY = "ebean.dboffline";
 
-  private static boolean runningMigration;
+  private static boolean generateMigration;
 
   /**
    * Set the platform to use when creating the next EbeanServer instance.
@@ -55,23 +55,23 @@ public class DbOffline {
    * Return true if the migration is running. This typically means don't run the
    * plugins like full DDL generation.
    */
-  public static boolean isRunningMigration() {
-    return runningMigration;
+  public static boolean isGenerateMigration() {
+    return generateMigration;
   }
 
   /**
    * Called when the migration is running is order to stop other plugins
    * like the full DDL generation from executing.
    */
-  public static void setRunningMigration() {
-    runningMigration = true;
+  public static void setGenerateMigration() {
+    generateMigration = true;
   }
 
   /**
    * Reset the offline platform and runningMigration flag.
    */
   public static void reset() {
-    runningMigration = false;
+    generateMigration = false;
     System.clearProperty(KEY);
     logger.debug("reset");
   }

src/main/java/com/avaje/ebean/dbmigration/DdlGenerator.java

@@ -96,7 +96,13 @@ public class DdlGenerator {
     Transaction transaction = server.createTransaction();
     Connection connection = transaction.getConnection();
     try {
+      if (expectErrors) {
+        connection.setAutoCommit(true);
+      }
       int count = runner.runAll(content, connection);
+      if (expectErrors) {
+        connection.setAutoCommit(false);
+      }
       transaction.commit();
       return count;
 

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/BaseTableDdl.java

@@ -583,6 +583,12 @@ public class BaseTableDdl implements TableDdl {
       }
     }
 
+    for (Column column : columns) {
+      if (hasValue(column.getReferences())) {
+        writeForeignKey(writer, tableName, column);
+      }
+    }
+
     // add a bit of whitespace
     writer.apply().end();
   }
@@ -831,9 +837,10 @@ public class BaseTableDdl implements TableDdl {
 
   protected void alterTableAddColumn(DdlBuffer buffer, String tableName, Column column, boolean onHistoryTable) throws IOException {
 
+    String convertedType = platformDdl.convert(column.getType(), false);
     buffer.append("alter table ").append(tableName)
         .append(" add column ").append(column.getName())
-        .append(" ").append(column.getType());
+        .append(" ").append(convertedType);
 
     if (!onHistoryTable) {
       if (isTrue(column.isNotnull())) {

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/PlatformDdl.java

@@ -26,6 +26,8 @@ import java.util.List;
  */
 public class PlatformDdl {
 
+  protected final DatabasePlatform platform;
+
   protected PlatformHistoryDdl historyDdl = new NoHistorySupportDdl();
 
   /**
@@ -98,6 +100,7 @@ public class PlatformDdl {
   protected final DbDefaultValue dbDefaultValue;
 
   public PlatformDdl(DatabasePlatform platform) {
+    this.platform = platform;
     this.dbIdentity = platform.getDbIdentity();
     this.dbDefaultValue = platform.getDbDefaultValue();
     this.typeConverter = new PlatformTypeConverter(platform.getDbTypeMap());
@@ -107,6 +110,7 @@ public class PlatformDdl {
    * Set configuration options.
    */
   public void configure(ServerConfig serverConfig) {
+    platform.configure(serverConfig);
     historyDdl.configure(serverConfig, this);
     naming = serverConfig.getConstraintNaming();
   }

src/main/java/com/avaje/ebean/dbmigration/model/CurrentModel.java

@@ -11,7 +11,6 @@ import com.avaje.ebean.dbmigration.model.visitor.VisitAllUsing;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
 
 import java.io.IOException;
-import java.util.List;
 
 /**
  * Reads EbeanServer bean descriptors to build the current model.
@@ -24,6 +23,8 @@ public class CurrentModel {
 
   private final DbConstraintNaming.MaxLength maxLength;
 
+  private final boolean platformTypes;
+
   private ModelContainer model;
 
   private ChangeSet changeSet;
@@ -31,32 +32,31 @@ public class CurrentModel {
   private DdlWrite write;
 
   /**
-   * Construct with a given EbeanServer instance.
+   * Construct with a given EbeanServer instance for DDL create all generation, not migration.
    */
   public CurrentModel(SpiEbeanServer server) {
-    this(server, server.getServerConfig().getConstraintNaming());
+    this(server, server.getServerConfig().getConstraintNaming(), true);
   }
 
   /**
    * Construct with a given EbeanServer, platformDdl and constraintNaming convention.
    * <p>
-   *   Note the EbeanServer is just used to read the BeanDescriptors and platformDdl supplies
-   *   the platform specific handling on
+   * Note the EbeanServer is just used to read the BeanDescriptors and platformDdl supplies
+   * the platform specific handling on
    * </p>
    */
   public CurrentModel(SpiEbeanServer server, DbConstraintNaming constraintNaming) {
+    this(server, constraintNaming, false);
+  }
+
+  private CurrentModel(SpiEbeanServer server, DbConstraintNaming constraintNaming, boolean platformTypes) {
     this.server = server;
     this.constraintNaming = constraintNaming;
     this.maxLength = maxLength(server, constraintNaming);
+    this.platformTypes = platformTypes;
   }
 
-  public CurrentModel(SpiEbeanServer server, DbConstraintNaming constraintNaming, int maxConstraintLength) {
-    this.server = server;
-    this.constraintNaming = constraintNaming;
-    this.maxLength = new DefaultConstraintMaxLength(maxConstraintLength);
-  }
-
-  private DbConstraintNaming.MaxLength maxLength(SpiEbeanServer server, DbConstraintNaming naming) {
+  private static DbConstraintNaming.MaxLength maxLength(SpiEbeanServer server, DbConstraintNaming naming) {
 
     if (naming.getMaxLength() != null) {
       return naming.getMaxLength();
@@ -73,7 +73,7 @@ public class CurrentModel {
     if (model == null) {
       model = new ModelContainer();
 
-      ModelBuildContext context = new ModelBuildContext(model, constraintNaming, maxLength);
+      ModelBuildContext context = new ModelBuildContext(model, constraintNaming, maxLength, platformTypes);
       ModelBuildBeanVisitor visitor = new ModelBuildBeanVisitor(context);
       VisitAllUsing visit = new VisitAllUsing(visitor, server);
       visit.visitAllBeans();

src/main/java/com/avaje/ebean/dbmigration/model/MTable.java

@@ -270,17 +270,15 @@ public class MTable {
     }
 
     // compare existing columns (look for dropped columns)
-    int columnPosition = 0;
     for (MColumn existingColumn : allColumns()) {
       MColumn newColumn = newColumnMap.get(existingColumn.getName());
       if (newColumn == null) {
-        diffDropColumn(modelDiff, existingColumn, columnPosition, newTable);
+        diffDropColumn(modelDiff, existingColumn);
       } else if (newColumn.isDraftOnly() && !draft) {
         // effectively a drop column (draft only column on a non-draft table)
         logger.trace("... drop column {} from table {} as now draftOnly", newColumn.getName(), name);
-        diffDropColumn(modelDiff, existingColumn, columnPosition, newTable);
+        diffDropColumn(modelDiff, existingColumn);
       }
-      columnPosition++;
     }
 
     if (addColumn != null) {
@@ -540,7 +538,7 @@ public class MTable {
   /**
    * Add a 'drop column' to the diff.
    */
-  private void diffDropColumn(ModelDiff modelDiff, MColumn existingColumn, int columnPosition, MTable newTable) {
+  private void diffDropColumn(ModelDiff modelDiff, MColumn existingColumn) {
 
     DropColumn dropColumn = new DropColumn();
     dropColumn.setTableName(name);

src/main/java/com/avaje/ebean/dbmigration/model/PlatformDdlWriter.java

@@ -9,6 +9,8 @@ import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
 import com.avaje.ebean.dbmigration.migration.ChangeSet;
 import com.avaje.ebean.dbmigration.migration.ChangeSetType;
 import com.avaje.ebean.dbmigration.migration.Migration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.File;
 import java.io.FileWriter;
@@ -21,6 +23,8 @@ import java.util.List;
  */
 public class PlatformDdlWriter {
 
+  private static final Logger logger = LoggerFactory.getLogger(PlatformDdlWriter.class);
+
   private final ServerConfig serverConfig;
 
   private final DatabasePlatform platform;
@@ -67,7 +71,7 @@ public class PlatformDdlWriter {
   protected void writePlatformDdl(DdlWrite write, File resourcePath, String fullVersion) throws IOException {
 
     if (!write.isApplyEmpty()) {
-      FileWriter applyWriter = createWriter(resourcePath, fullVersion, "", config.getApplySuffix());
+      FileWriter applyWriter = createWriter(resourcePath, fullVersion, config.getApplySuffix());
       try {
         writeApplyDdl(applyWriter, write);
         applyWriter.flush();
@@ -77,28 +81,12 @@ public class PlatformDdlWriter {
     }
   }
 
-  protected FileWriter createWriter(File path, String fullVersion, String subPath, String suffix) throws IOException {
+  protected FileWriter createWriter(File path, String fullVersion, String suffix) throws IOException {
 
-    String fileName = fullVersion;
-    if (!platformPrefix.isEmpty()) {
-      fileName += "-"+platformPrefix;
-    }
-    if (subPath != null && !subPath.isEmpty()) {
-      path = subPath(path, subPath);
-    }
-    fileName += suffix;
-    File applyFile = new File(path,  fileName);
+    File applyFile = new File(path,  fullVersion + suffix);
     return new FileWriter(applyFile);
   }
 
-  protected File subPath(File path, String suffix) {
-    File subPath = new File(path, suffix);
-    if (!subPath.exists()) {
-      subPath.mkdirs();
-    }
-    return subPath;
-  }
-
   /**
    * Write the 'Apply' DDL buffers to the writer.
    */
@@ -127,4 +115,17 @@ public class PlatformDdlWriter {
     return platform.createDdlHandler(serverConfig);
   }
 
+  /**
+   * Return a sub directory (for multi-platform ddl generation).
+   */
+  public File subPath(File path, String suffix) {
+    File subPath = new File(path, suffix);
+    if (!subPath.exists()) {
+      if (!subPath.mkdirs()) {
+        logger.error("failed to create directories for " + subPath.getAbsolutePath());
+      }
+    }
+    return subPath;
+  }
+
 }

src/main/java/com/avaje/ebean/dbmigration/model/build/ModelBuildContext.java

@@ -29,10 +29,13 @@ public class ModelBuildContext {
 
   private final DbConstraintNaming.MaxLength maxLength;
 
-  public ModelBuildContext(ModelContainer model, DbConstraintNaming naming, DbConstraintNaming.MaxLength maxLength) {
+  private final boolean platformTypes;
+
+  public ModelBuildContext(ModelContainer model, DbConstraintNaming naming, DbConstraintNaming.MaxLength maxLength, boolean platformTypes) {
     this.model = model;
     this.constraintNaming = naming;
     this.maxLength = maxLength;
+    this.platformTypes = platformTypes;
   }
 
   /**
@@ -132,7 +135,7 @@ public class ModelBuildContext {
     }
 
     // can be the logical JSON types (JSON, JSONB, JSONClob, JSONBlob, JSONVarchar)
-    int dbType = p.getDbType();
+    int dbType = p.getDbType(platformTypes);
     if (dbType == 0) {
       throw new RuntimeException("No scalarType defined for " + p.getFullBeanName());
     }

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

@@ -1,7 +1,5 @@
 package com.avaje.ebean.event;
 
-import java.util.Set;
-
 import com.avaje.ebean.config.ServerConfig;
 
 /**

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

@@ -1,7 +1,5 @@
 package com.avaje.ebean.event;
 
-import java.util.Set;
-
 /**
  * Used to enhance or override the default bean persistence mechanism.
  * <p>

src/main/java/com/avaje/ebean/event/changelog/BeanChange.java

@@ -80,7 +80,7 @@ public class BeanChange {
    * Set the bean id (for JSON tools).
    */
   public void setId(Object id) {
-    this.id = this.id;
+    this.id = id;
   }
 
   /**

src/main/java/com/avaje/ebean/util/CamelCaseHelper.java

@@ -12,9 +12,12 @@ public class CamelCaseHelper {
    */
   public static String toCamelFromUnderscore(String underscore) {
 
-    StringBuilder result = new StringBuilder();
     String[] vals = underscore.split("_");
+    if (vals.length == 1) {
+      return underscore;
+    }
 
+    StringBuilder result = new StringBuilder();
     for (int i = 0; i < vals.length; i++) {
       String lower = vals[i].toLowerCase();
       if (i > 0) {

src/main/java/com/avaje/ebean/util/StringHelper.java

@@ -398,7 +398,7 @@ public class StringHelper {
       int additionalSize, int startPos, int endPos) {
 
     if (source == null) {
-      return source;
+      return null;
     }
 
     char match0 = match.charAt(0);

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

@@ -132,15 +132,11 @@ public class ManyWhereJoins implements Serializable {
     formulaProperties.append(propertyName);
   }
 
-  public boolean isHasMany() {
-    return formulaWithJoin || !joins.isEmpty();
-  }
-
   /**
-   * Return true if the findRowCount query just needs the id property in the select clause.
+   * Return true if the query select includes a formula with join.
    */
-  public boolean isSelectId() {
-    return !formulaWithJoin;
+  public boolean isFormulaWithJoin() {
+    return formulaWithJoin;
   }
 
   /**

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

@@ -181,6 +181,15 @@ public class ScopeTrans implements Thread.UncaughtExceptionHandler {
     return e;
   }
 
+  /**
+   * Mark the underlying transaction as rollback only.
+   */
+  public void setRollbackOnly() {
+    if (transaction != null) {
+      transaction.setRollbackOnly();
+    }
+  }
+
   /**
    * An Exception was caught and may or may not cause a rollback to occur.
    * Returns the exception and this should be thrown by the calling code.

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

@@ -49,6 +49,11 @@ public class ScopedTransaction implements SpiTransaction {
     scopeTrans.rollback(e);
   }
 
+  @Override
+  public void setRollbackOnly() {
+    scopeTrans.setRollbackOnly();
+  }
+
   @Override
   public void end() throws PersistenceException {
     try {

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

@@ -13,7 +13,12 @@ import java.io.IOException;
  */
 public interface SpiExpression extends Expression {
 
-  /**
+	/**
+	 * Simplify nested expressions if possible.
+	 */
+	void simplify();
+
+	/**
    * Write the expression as an elastic search expression.
    */
   void writeDocQuery(DocQueryContext context) throws IOException;

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

@@ -0,0 +1,6 @@
+package com.avaje.ebeaninternal.api;
+
+public interface SpiNamedParam {
+
+  Object getValue();
+}

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

@@ -222,6 +222,16 @@ public interface SpiQuery<T> extends Query<T> {
    */
   Timestamp getAsOf();
 
+  /**
+   * Return true if the base table is using history.
+   */
+  boolean isAsOfBaseTable();
+
+  /**
+   * Set when the base table is using history.
+   */
+  void setAsOfBaseTable();
+
   /**
    * Increment the counter of tables used in 'As Of' query.
    */
@@ -296,6 +306,16 @@ public interface SpiQuery<T> extends Query<T> {
    */
   void setLoadDescription(String loadMode, String loadDescription);
 
+  /**
+   * Check that the named parameters have had their values set.
+   */
+  void checkNamedParameters();
+
+  /**
+   * Create a named parameter placeholder.
+   */
+  SpiNamedParam createNamedParameter(String parameterName);
+
   /**
    * Return the joins required to support predicates on the many properties.
    */
@@ -542,12 +562,6 @@ public interface SpiQuery<T> extends Query<T> {
    */
   BindParams getBindParams();
 
-  /**
-   * Get the orm query as a String. Only available if the query was built from
-   * a string.
-   */
-  String getQuery();
-
   /**
    * Replace the query detail. This is used by the AutoTune feature to as a
    * fast way to set the query properties and joins.
@@ -564,6 +578,11 @@ public interface SpiQuery<T> extends Query<T> {
    */
   boolean tuneFetchProperties(OrmQueryDetail detail);
 
+  /**
+   * If this is a RawSql based entity set the default RawSql if not set.
+   */
+  void setDefaultRawSqlIfRequired();
+
   /**
    * Set to true if this query has been tuned by autoTune.
    */
@@ -574,9 +593,15 @@ public interface SpiQuery<T> extends Query<T> {
    */
   OrmQueryDetail getDetail();
 
-  TableJoin getIncludeTableJoin();
+  /**
+   * Return the extra join for a M2M lazy load.
+   */
+  TableJoin getM2mIncludeJoin();
 
-  void setIncludeTableJoin(TableJoin includeTableJoin);
+  /**
+   * Set the extra join for a M2M lazy load.
+   */
+  void setM2MIncludeJoin(TableJoin includeTableJoin);
 
   /**
    * Return the property used to specify keys for a map.
@@ -686,4 +711,8 @@ public interface SpiQuery<T> extends Query<T> {
    */
   OrmUpdateProperties getUpdateProperties();
 
+  /**
+   * Simplify nested expression lists where possible.
+   */
+  void simplifyExpressions();
 }

src/main/java/com/avaje/ebeaninternal/server/autotune/service/ProfileOriginNodeUsage.java

@@ -45,9 +45,8 @@ public class ProfileOriginNodeUsage {
       if (path != null) {
         ElPropertyValue elGetValue = rootDesc.getElGetValue(path);
         if (elGetValue == null) {
-          desc = null;
           logger.warn("AutoTune: Can't find join for path[" + path + "] for " + rootDesc.getName());
-
+          return;
         } else {
           BeanProperty beanProperty = elGetValue.getBeanProperty();
           if (beanProperty instanceof BeanPropertyAssoc<?>) {

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

@@ -4,7 +4,6 @@ import java.io.Externalizable;
 import java.io.IOException;
 import java.io.ObjectInput;
 import java.io.ObjectOutput;
-import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 

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

@@ -1,7 +1,6 @@
 package com.avaje.ebeaninternal.server.cache;
 
 import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.EbeanServer;
 import com.avaje.ebean.cache.ServerCache;
 import com.avaje.ebean.cache.ServerCacheOptions;
 import com.avaje.ebean.cache.ServerCacheStatistics;

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

@@ -1,35 +1,25 @@
 package com.avaje.ebeaninternal.server.core;
 
-import java.util.concurrent.TimeUnit;
-
 import com.avaje.ebeaninternal.api.SpiBackgroundExecutor;
+import com.avaje.ebeaninternal.server.lib.DaemonExecutorService;
 import com.avaje.ebeaninternal.server.lib.DaemonScheduleThreadPool;
-import com.avaje.ebeaninternal.server.lib.DaemonThreadPool;
+
+import java.util.concurrent.TimeUnit;
 
 /**
  * The default implementation of the BackgroundExecutor.
  */
 public class DefaultBackgroundExecutor implements SpiBackgroundExecutor {
 
-	private final DaemonThreadPool pool;
-	
 	private final DaemonScheduleThreadPool schedulePool;
 
+  private final DaemonExecutorService pool;
+
   /**
    * Construct the default implementation of BackgroundExecutor.
-   *
-   * @param corePoolSize
-   *            the core size of the thread pool.
-   * @param maximumPoolSize
-   *            the maximum pool size before jobs are queued
-   * @param keepAliveSecs
-   *            the time in seconds idle threads are keep alive
-   * @param shutdownWaitSeconds
-   *            the time in seconds allowed for the pool to shutdown nicely.
-   *            After this the pool is forced to shutdown.
    */
-	public DefaultBackgroundExecutor(int schedulePoolSize, int corePoolSize, int maximumPoolSize, long keepAliveSecs,int shutdownWaitSeconds, String namePrefix) {
-		this.pool = new DaemonThreadPool(corePoolSize, maximumPoolSize, keepAliveSecs, shutdownWaitSeconds, namePrefix);
+	public DefaultBackgroundExecutor(int schedulePoolSize, int shutdownWaitSeconds, String namePrefix) {
+		this.pool = new DaemonExecutorService(shutdownWaitSeconds, namePrefix);
 		this.schedulePool = new DaemonScheduleThreadPool(schedulePoolSize, shutdownWaitSeconds, namePrefix+"-periodic-");
 	}
 

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

@@ -14,14 +14,14 @@ import java.util.Set;
  */
 public class DefaultBeanState implements BeanState {
 
-	private final EntityBean entityBean;
-	
-	private final EntityBeanIntercept intercept;
-	
-	public DefaultBeanState(EntityBean  entityBean){
-		this.entityBean = entityBean;
-		this.intercept = entityBean._ebean_getIntercept();
-	}
+  private final EntityBean entityBean;
+
+  private final EntityBeanIntercept intercept;
+
+  public DefaultBeanState(EntityBean entityBean) {
+    this.entityBean = entityBean;
+    this.intercept = entityBean._ebean_getIntercept();
+  }
 
   public void setPropertyLoaded(String propertyName, boolean loaded) {
     intercept.setPropertyLoaded(propertyName, loaded);
@@ -31,52 +31,57 @@ public class DefaultBeanState implements BeanState {
     return intercept.isReference();
   }
 
-	public boolean isNew() {
-		return intercept.isNew();
-	}
-
-	public boolean isNewOrDirty() {
-		return intercept.isNewOrDirty();
-	}
-
-	public boolean isDirty() {
-		return intercept.isDirty();
-	}
-	
-	public Set<String> getLoadedProps() {
-	  return intercept.getLoadedPropertyNames();
-	}
-	
-	public Set<String> getChangedProps() {
-	  return intercept.getDirtyPropertyNames();
+  public boolean isNew() {
+    return intercept.isNew();
   }
-	
-  public Map<String,ValuePair> getDirtyValues() {
+
+  public boolean isNewOrDirty() {
+    return intercept.isNewOrDirty();
+  }
+
+  public boolean isDirty() {
+    return intercept.isDirty();
+  }
+
+  public Set<String> getLoadedProps() {
+    return intercept.getLoadedPropertyNames();
+  }
+
+  public Set<String> getChangedProps() {
+    return intercept.getDirtyPropertyNames();
+  }
+
+  public Map<String, ValuePair> getDirtyValues() {
     return intercept.getDirtyValues();
   }
-	
-	public boolean isReadOnly() {
-		return intercept.isReadOnly();
-	}
-	
-	public void setReadOnly(boolean readOnly){
-		intercept.setReadOnly(readOnly);
-	}
-	
-	public void addPropertyChangeListener(PropertyChangeListener listener) {
-		entityBean.addPropertyChangeListener(listener);
-	}
-	
-	public void removePropertyChangeListener(PropertyChangeListener listener) {
-		entityBean.removePropertyChangeListener(listener);
-	}
 
-	public void setLoaded() {
-	  intercept.setLoaded();
-	}
+  public boolean isReadOnly() {
+    return intercept.isReadOnly();
+  }
+
+  public void setReadOnly(boolean readOnly) {
+    intercept.setReadOnly(readOnly);
+  }
+
+  public void addPropertyChangeListener(PropertyChangeListener listener) {
+    entityBean.addPropertyChangeListener(listener);
+  }
+
+  public void removePropertyChangeListener(PropertyChangeListener listener) {
+    entityBean.removePropertyChangeListener(listener);
+  }
+
+  public void setLoaded() {
+    intercept.setLoaded();
+  }
 
   @Override
   public void setDisableLazyLoad(boolean disableLazyLoading) {
     intercept.setDisableLazyLoad(disableLazyLoading);
   }
+
+  @Override
+  public boolean isDisableLazyLoad() {
+    return intercept.isDisableLazyLoad();
+  }
 }

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

@@ -78,14 +78,10 @@ public class DefaultContainer implements SpiContainer {
   private SpiBackgroundExecutor createBackgroundExecutor(ServerConfig serverConfig) {
 
     String namePrefix = "ebean-" + serverConfig.getName();
-
     int schedulePoolSize = serverConfig.getBackgroundExecutorSchedulePoolSize();
-    int corePoolSize = serverConfig.getBackgroundExecutorCorePoolSize();
-    int maxPoolSize = serverConfig.getBackgroundExecutorMaxPoolSize();
-    int idleSecs = serverConfig.getBackgroundExecutorIdleSecs();
     int shutdownSecs = serverConfig.getBackgroundExecutorShutdownSecs();
 
-    return new DefaultBackgroundExecutor(schedulePoolSize, corePoolSize, maxPoolSize, idleSecs, shutdownSecs, namePrefix);
+    return new DefaultBackgroundExecutor(schedulePoolSize, shutdownSecs, namePrefix);
   }
 
   /**
@@ -122,22 +118,20 @@ public class DefaultContainer implements SpiContainer {
 
       // generate and run DDL if required
       // if there are any other tasks requiring action in their plugins, do them as well
-      if (!DbOffline.isRunningMigration()) {
+      if (!DbOffline.isGenerateMigration()) {
         server.executePlugins(online);
-      }
 
-      // initialise prior to registering with clusterManager
-      server.initialise();
-
-      if (online) {
-        if (clusterManager.isClustering()) {
-          // register the server once it has been created
-          clusterManager.registerServer(server);
+        // initialise prior to registering with clusterManager
+        server.initialise();
+        if (online) {
+          if (clusterManager.isClustering()) {
+            // register the server once it has been created
+            clusterManager.registerServer(server);
+          }
         }
+        // start any services after registering with clusterManager
+        server.start();
       }
-
-      // start any services after registering with clusterManager
-      server.start();
       DbOffline.reset();
       return server;
     }
@@ -244,7 +238,7 @@ public class DefaultContainer implements SpiContainer {
     if (dbPlatform == null) {
       DatabasePlatformFactory factory = new DatabasePlatformFactory();
       DatabasePlatform db = factory.create(config);
-      db.configure(config.getProperties());
+      db.configure(config);
       config.setDatabasePlatform(db);
       logger.info("DatabasePlatform name:" + config.getName() + " platform:" + db.getName());
     }

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

@@ -40,6 +40,7 @@ import com.avaje.ebeaninternal.server.deploy.BeanDescriptorManager;
 import com.avaje.ebeaninternal.server.deploy.BeanProperty;
 import com.avaje.ebeaninternal.server.deploy.InheritInfo;
 import com.avaje.ebeaninternal.server.el.ElFilter;
+import com.avaje.ebeaninternal.server.grammer.EqlParser;
 import com.avaje.ebeaninternal.server.lib.ShutdownManager;
 import com.avaje.ebeaninternal.server.query.CQuery;
 import com.avaje.ebeaninternal.server.query.CQueryEngine;
@@ -557,7 +558,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
     InheritInfo inheritInfo = desc.getInheritInfo();
     if (inheritInfo == null) {
-      return (T)desc.contextRef(pc, null, id);
+      return (T)desc.contextRef(pc, null, false, id);
     }
 
     BeanProperty idProp = desc.getIdProperty();
@@ -887,6 +888,32 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     return createQuery(beanType);
   }
 
+  @Override
+  public <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
+    BeanDescriptor<T> desc = getBeanDescriptor(beanType);
+    if (desc == null) {
+      throw new PersistenceException(beanType.getName() + " is NOT an Entity Bean registered with this server?");
+    }
+    String named = desc.getNamedQuery(namedQuery);
+    if (named != null) {
+      return createQuery(beanType, named);
+    }
+    RawSql rawSql = desc.getNamedRawSql(namedQuery);
+    if (rawSql != null) {
+      DefaultOrmQuery<T> query = createQuery(beanType);
+      query.setRawSql(rawSql);
+      return query;
+    }
+    throw new PersistenceException("No named query called " + namedQuery + " for bean:" + beanType.getName());
+  }
+
+  @Override
+  public <T> Query<T> createQuery(Class<T> beanType, String eql) {
+    DefaultOrmQuery<T> query = createQuery(beanType);
+    EqlParser.parse(eql, query);
+    return query;
+  }
+
   public <T> DefaultOrmQuery<T> createQuery(Class<T> beanType) {
     BeanDescriptor<T> desc = getBeanDescriptor(beanType);
     if (desc == null) {
@@ -939,12 +966,14 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
     SpiQuery<T> spiQuery = (SpiQuery<T>) query;
     spiQuery.setType(type);
+    spiQuery.checkNamedParameters();
 
     return createQueryRequest(spiQuery, t);
   }
 
   private <T> SpiOrmQueryRequest<T> createQueryRequest(SpiQuery<T> query, Transaction t) {
 
+    query.setDefaultRawSqlIfRequired();
     if (query.isAutoTunable() && !autoTuneService.tuneQuery(query)) {
       // use deployment FetchType.LAZY/EAGER annotations
       // to define the 'default' select clause
@@ -1123,12 +1152,16 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     }
   }
 
-  public <T> int findRowCount(Query<T> query, Transaction t) {
+  public <T> int findCount(Query<T> query, Transaction t) {
 
     SpiQuery<T> copy = ((SpiQuery<T>) query).copy();
     return findRowCountWithCopy(copy, t);
   }
 
+  public <T> int findRowCount(Query<T> query, Transaction t) {
+    return findCount(query, t);
+  }
+
   public <T> int findRowCountWithCopy(Query<T> query, Transaction t) {
 
     SpiOrmQueryRequest<T> request = createQueryRequest(Type.ROWCOUNT, query, t);
@@ -1184,7 +1217,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     }
   }
 
-  public <T> FutureRowCount<T> findFutureRowCount(Query<T> q, Transaction t) {
+  public <T> FutureRowCount<T> findFutureCount(Query<T> q, Transaction t) {
 
     SpiQuery<T> copy = ((SpiQuery<T>) q).copy();
     copy.setFutureFetch(true);
@@ -1199,6 +1232,10 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     return queryFuture;
   }
 
+  public <T> FutureRowCount<T> findFutureRowCount(Query<T> q, Transaction t) {
+    return findFutureCount(q, t);
+  }
+
   public <T> FutureIds<T> findFutureIds(Query<T> query, Transaction t) {
 
     SpiQuery<T> copy = ((SpiQuery<T>) query).copy();

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

@@ -1,6 +1,7 @@
 package com.avaje.ebeaninternal.server.core;
 
 import com.avaje.ebean.ValuePair;
+import com.avaje.ebean.bean.PreGetterCallback;
 import com.avaje.ebeaninternal.api.ConcurrencyMode;
 import com.avaje.ebean.annotation.DocStoreMode;
 import com.avaje.ebean.bean.EntityBean;
@@ -36,7 +37,7 @@ import java.util.Set;
 /**
  * PersistRequest for insert update or delete of a bean.
  */
-public final class PersistRequestBean<T> extends PersistRequest implements BeanPersistRequest<T>, DocStoreUpdate {
+public final class PersistRequestBean<T> extends PersistRequest implements BeanPersistRequest<T>, DocStoreUpdate, PreGetterCallback {
 
   private final BeanManager<T> beanManager;
 
@@ -137,6 +138,11 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
   private long version;
 
+  /**
+   * Flag set when request is added to JDBC batch registered as a "getter callback" to automatically flush batch.
+   */
+  private boolean getterCallback;
+
   public PersistRequestBean(SpiEbeanServer server, T bean, Object parentBean, BeanManager<T> mgr, SpiTransaction t,
                             PersistExecute persistExecute, PersistRequest.Type type, boolean saveRecurse, boolean publish) {
 
@@ -239,8 +245,17 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   public void setBatched() {
     batched = true;
+    if (type == Type.INSERT || type == Type.UPDATE) {
+      // used to trigger automatic jdbc batch flush
+      intercept.registerGetterCallback(this);
+      getterCallback = true;
+    }
   }
 
+  @Override
+  public void preGetterTrigger() {
+    transaction.flushBatch();
+  }
 
   public void setSkipBatchForTopLevel() {
     skipBatchForTopLevel = true;
@@ -548,7 +563,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Create and return a new reference bean matching this beans Id value.
    */
   public T createReference() {
-    return beanDescriptor.createReference(Boolean.FALSE, getBeanId(), null);
+    return beanDescriptor.createReference(Boolean.FALSE, false, getBeanId(), null);
   }
 
   /**
@@ -621,6 +636,9 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
   @Override
   public int executeNow() {
+    if (getterCallback) {
+      intercept.clearGetterCallback();
+    }
     switch (type) {
       case INSERT:
         persistExecute.executeInsertBean(this);

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

@@ -1,7 +1,6 @@
 package com.avaje.ebeaninternal.server.deploy;
 
 import com.avaje.ebean.bean.EntityBean;
-import com.avaje.ebean.bean.EntityBeanIntercept;
 import com.avaje.ebean.bean.PersistenceContext;
 import com.avaje.ebeaninternal.server.query.SqlJoinType;
 
@@ -46,9 +45,11 @@ abstract class AssocOneHelp {
       return existing;
     }
 
-    Object ref = target.contextRef(pc, ctx.isReadOnly(), id);
-    EntityBeanIntercept ebi = ((EntityBean) ref)._ebean_getIntercept();
-    ctx.register(property.name, ebi);
+    boolean disableLazyLoading = ctx.isDisableLazyLoading();
+    Object ref = target.contextRef(pc, ctx.isReadOnly(), disableLazyLoading, id);
+    if (!disableLazyLoading) {
+      ctx.register(property.name, ((EntityBean) ref)._ebean_getIntercept());
+    }
     return ref;
   }
 

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

@@ -1,7 +1,6 @@
 package com.avaje.ebeaninternal.server.deploy;
 
 import com.avaje.ebean.bean.EntityBean;
-import com.avaje.ebean.bean.EntityBeanIntercept;
 import com.avaje.ebean.bean.PersistenceContext;
 import com.avaje.ebeaninternal.server.query.SqlJoinType;
 
@@ -53,9 +52,11 @@ class AssocOneHelpRefInherit extends AssocOneHelp {
     }
 
     // for inheritance hierarchy create the correct type for this row...
-    Object ref = desc.contextRef(pc, ctx.isReadOnly(), id);
-    EntityBeanIntercept ebi = ((EntityBean) ref)._ebean_getIntercept();
-    ctx.register(property.name, ebi);
+    boolean disableLazyLoading = ctx.isDisableLazyLoading();
+    Object ref = desc.contextRef(pc, ctx.isReadOnly(), disableLazyLoading, id);
+    if (disableLazyLoading) {
+      ctx.register(property.name, ((EntityBean) ref)._ebean_getIntercept());
+    }
     return ref;
   }
 

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

@@ -7,7 +7,6 @@ import com.avaje.ebean.RawSql;
 import com.avaje.ebean.SqlUpdate;
 import com.avaje.ebean.Transaction;
 import com.avaje.ebean.ValuePair;
-import com.avaje.ebeaninternal.api.ConcurrencyMode;
 import com.avaje.ebean.annotation.DocStoreMode;
 import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.EntityBean;
@@ -16,8 +15,8 @@ import com.avaje.ebean.bean.PersistenceContext;
 import com.avaje.ebean.bean.PersistenceContextUtil;
 import com.avaje.ebean.config.EncryptKey;
 import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.config.dbplatform.PlatformIdGenerator;
 import com.avaje.ebean.config.dbplatform.IdType;
+import com.avaje.ebean.config.dbplatform.PlatformIdGenerator;
 import com.avaje.ebean.event.BeanFindController;
 import com.avaje.ebean.event.BeanPersistController;
 import com.avaje.ebean.event.BeanPersistListener;
@@ -36,6 +35,7 @@ import com.avaje.ebean.plugin.BeanType;
 import com.avaje.ebean.plugin.ExpressionPath;
 import com.avaje.ebean.plugin.Property;
 import com.avaje.ebeaninternal.api.CQueryPlanKey;
+import com.avaje.ebeaninternal.api.ConcurrencyMode;
 import com.avaje.ebeaninternal.api.LoadContext;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import com.avaje.ebeaninternal.api.SpiQuery;
@@ -109,6 +109,10 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
 
   private final ConcurrentHashMap<String, ElComparator<T>> comparatorCache = new ConcurrentHashMap<String, ElComparator<T>>();
 
+  private final Map<String, RawSql> namedRawSql;
+
+  private final Map<String, String> namedQuery;
+
   public void merge(EntityBean bean, EntityBean existing) {
 
     EntityBeanIntercept fromEbi = bean._ebean_getIntercept();
@@ -412,6 +416,8 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
     this.rootBeanType = PersistenceContextUtil.root(beanType);
     this.prototypeEntityBean = createPrototypeEntityBean(beanType);
 
+    this.namedQuery = deploy.getNamedQuery();
+    this.namedRawSql = deploy.getNamedRawSql();
     this.inheritInfo = deploy.getInheritInfo();
 
     this.beanFinder = deploy.getBeanFinder();
@@ -443,7 +449,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
     this.baseTableVersionsBetween = deploy.getBaseTableVersionsBetween();
     this.dependentTables = deploy.getDependentTables();
     this.dbComment = deploy.getDbComment();
-    this.autoTunable = EntityType.ORM.equals(entityType) && (beanFinder == null);
+    this.autoTunable = EntityType.ORM == entityType && (beanFinder == null);
 
     // helper object used to derive lists of properties
     DeployBeanPropertyLists listHelper = new DeployBeanPropertyLists(owner, this, deploy);
@@ -985,6 +991,20 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
     return this;
   }
 
+  /**
+   * Return the named ORM query.
+   */
+  public String getNamedQuery(String name) {
+    return namedQuery.get(name);
+  }
+
+  /**
+   * Return the named RawSql query.
+   */
+  public RawSql getNamedRawSql(String named) {
+    return namedRawSql.get(named);
+  }
+
   /**
    * Return the type of DocStoreMode that should occur for this type of persist request
    * given the transactions requested mode.
@@ -1559,9 +1579,9 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
    * Create a reference bean based on the id.
    */
   @SuppressWarnings("unchecked")
-  public T createReference(Boolean readOnly, Object id, PersistenceContext pc) {
+  public T createReference(Boolean readOnly, boolean disableLazyLoad, Object id, PersistenceContext pc) {
 
-    if (cacheSharableBeans && !Boolean.FALSE.equals(readOnly)) {
+    if (cacheSharableBeans && !disableLazyLoad && !Boolean.FALSE.equals(readOnly)) {
       CachedBeanData d = cacheHelp.beanCacheGetData(id);
       if (d != null) {
         Object shareableBean = d.getSharableBean();
@@ -1578,7 +1598,11 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
       id = convertSetId(id, eb);
 
       EntityBeanIntercept ebi = eb._ebean_getIntercept();
-      ebi.setBeanLoader(ebeanServer);
+      if (disableLazyLoad) {
+        ebi.setDisableLazyLoad(true);
+      } else {
+        ebi.setBeanLoader(ebeanServer);
+      }
       ebi.setReference(idPropertyIndex);
       if (Boolean.TRUE == readOnly) {
         ebi.setReadOnly(true);
@@ -1750,8 +1774,8 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
   /**
    * Create a reference bean and put it in the persistence context (and return it).
    */
-  public Object contextRef(PersistenceContext pc, Boolean readOnly, Object id) {
-    return createReference(readOnly, id, pc);
+  public Object contextRef(PersistenceContext pc, Boolean readOnly, boolean disableLazyLoad, Object id) {
+    return createReference(readOnly, disableLazyLoad, id, pc);
   }
 
   /**
@@ -2169,7 +2193,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
    * Return true if this is an embedded bean.
    */
   public boolean isEmbedded() {
-    return EntityType.EMBEDDED.equals(entityType);
+    return EntityType.EMBEDDED == entityType;
   }
 
   /**
@@ -2295,15 +2319,10 @@ public class BeanDescriptor<T> implements MetaBeanInfo, BeanType<T> {
   }
 
   /**
-   * Returns true if this bean is based on a table (or possibly view) and
-   * returns false if this bean is based on a raw sql select statement.
-   * <p>
-   * When false querying this bean is based on a supplied sql select statement
-   * placed in the orm xml file (as opposed to Ebean generated sql).
-   * </p>
+   * Returns true if this bean is based on RawSql.
    */
-  public boolean isSqlSelectBased() {
-    return EntityType.SQL.equals(entityType);
+  public boolean isRawSqlBased() {
+    return EntityType.SQL == entityType;
   }
 
   /**

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

@@ -266,7 +266,7 @@ final class BeanDescriptorCacheHelp<T> {
     bc.checkEmptyLazyLoad();
     for (int i = 0; i < idList.size(); i++) {
       Object id = idList.get(i);
-      Object refBean = targetDescriptor.createReference(readOnly, id, persistenceContext);
+      Object refBean = targetDescriptor.createReference(readOnly, false, id, persistenceContext);
       many.add(bc, (EntityBean) refBean);
     }
     return true;

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

@@ -2,6 +2,7 @@ package com.avaje.ebeaninternal.server.deploy;
 
 import com.avaje.ebean.BackgroundExecutor;
 import com.avaje.ebean.Model;
+import com.avaje.ebean.RawSqlBuilder;
 import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.cache.ServerCacheManager;
@@ -22,10 +23,10 @@ import com.avaje.ebean.plugin.BeanType;
 import com.avaje.ebeaninternal.api.ConcurrencyMode;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import com.avaje.ebeaninternal.api.TransactionEventTable;
-import com.avaje.ebeaninternal.server.core.bootup.BootupClasses;
 import com.avaje.ebeaninternal.server.core.InternString;
 import com.avaje.ebeaninternal.server.core.InternalConfiguration;
 import com.avaje.ebeaninternal.server.core.Message;
+import com.avaje.ebeaninternal.server.core.bootup.BootupClasses;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor.EntityType;
 import com.avaje.ebeaninternal.server.deploy.id.IdBinder;
 import com.avaje.ebeaninternal.server.deploy.id.IdBinderEmbedded;
@@ -47,6 +48,13 @@ import com.avaje.ebeaninternal.server.properties.BeanPropertiesReader;
 import com.avaje.ebeaninternal.server.properties.BeanPropertyInfo;
 import com.avaje.ebeaninternal.server.properties.BeanPropertyInfoFactory;
 import com.avaje.ebeaninternal.server.properties.EnhanceBeanPropertyInfoFactory;
+import com.avaje.ebeaninternal.xmlmapping.XmlMappingReader;
+import com.avaje.ebeaninternal.xmlmapping.model.XmAliasMapping;
+import com.avaje.ebeaninternal.xmlmapping.model.XmColumnMapping;
+import com.avaje.ebeaninternal.xmlmapping.model.XmEbean;
+import com.avaje.ebeaninternal.xmlmapping.model.XmEntity;
+import com.avaje.ebeaninternal.xmlmapping.model.XmNamedQuery;
+import com.avaje.ebeaninternal.xmlmapping.model.XmRawSql;
 import com.avaje.ebeanservice.docstore.api.DocStoreBeanAdapter;
 import com.avaje.ebeanservice.docstore.api.DocStoreFactory;
 import org.slf4j.Logger;
@@ -56,12 +64,16 @@ import javax.persistence.MappedSuperclass;
 import javax.persistence.PersistenceException;
 import javax.persistence.Transient;
 import javax.sql.DataSource;
+import java.io.IOException;
+import java.io.InputStream;
 import java.io.Serializable;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -116,7 +128,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
   private final DocStoreFactory docStoreFactory;
 
-  private int enhancedClassCount;
+  private int entityBeanCount;
 
   private final boolean updateChangesOnly;
 
@@ -124,7 +136,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
   private final String serverName;
 
-  private Map<Class<?>, DeployBeanInfo<?>> deplyInfoMap = new HashMap<Class<?>, DeployBeanInfo<?>>();
+  private Map<Class<?>, DeployBeanInfo<?>> deployInfoMap = new HashMap<Class<?>, DeployBeanInfo<?>>();
 
   private final Map<Class<?>, BeanTable> beanTableMap = new HashMap<Class<?>, BeanTable>();
 
@@ -301,6 +313,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     try {
       createListeners();
       readEntityDeploymentInitial();
+      readXmlMapping();
       readEmbeddedDeployment();
       readEntityBeanTable();
       readEntityDeploymentAssociations();
@@ -319,8 +332,8 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
       logStatus();
 
-      deplyInfoMap.clear();
-      deplyInfoMap = null;
+      deployInfoMap.clear();
+      deployInfoMap = null;
 
       return asOfTableMap;
 
@@ -330,6 +343,66 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     }
   }
 
+  private void readXmlMapping() {
+
+    try {
+      ClassLoader classLoader = serverConfig.getClassLoadConfig().getClassLoader();
+
+      Enumeration<URL> resources = classLoader.getResources("ebean.xml");
+
+      List<XmEbean> mappings = new ArrayList<XmEbean>();
+      while (resources.hasMoreElements()) {
+        URL url = resources.nextElement();
+        InputStream is = url.openStream();
+        mappings.add(XmlMappingReader.read(is));
+        is.close();
+      }
+
+      for (XmEbean mapping : mappings) {
+        List<XmEntity> entityDeploy = mapping.getEntity();
+        for (XmEntity deploy : entityDeploy) {
+          readEntityMapping(classLoader, deploy);
+        }
+      }
+
+    } catch (IOException e) {
+      throw new RuntimeException("Error reading ebean.xml", e);
+    }
+  }
+
+  private void readEntityMapping(ClassLoader classLoader, XmEntity entityDeploy) {
+
+    String entityClassName = entityDeploy.getClazz();
+    Class<?> entityClass;
+    try {
+      entityClass = Class.forName(entityClassName, false, classLoader);
+    } catch (Exception e) {
+      logger.error("Could not load entity bean class "+entityClassName+" for ebean.xml entry");
+      return;
+    }
+
+    DeployBeanInfo<?> info = deployInfoMap.get(entityClass);
+    if (info == null) {
+      logger.error("No entity bean for ebean.xml entry "+entityClassName);
+
+    } else {
+      for (XmRawSql sql : entityDeploy.getRawSql()) {
+        RawSqlBuilder builder = RawSqlBuilder.parse(sql.getQuery().getValue());
+        for (XmColumnMapping columnMapping : sql.getColumnMapping()) {
+          builder.columnMapping(columnMapping.getColumn(), columnMapping.getProperty());
+        }
+        for (XmAliasMapping aliasMapping : sql.getAliasMapping()) {
+          builder.tableAliasMapping(aliasMapping.getAlias(), aliasMapping.getProperty());
+        }
+        info.addRawSql(sql.getName(), builder.create());
+      }
+
+      for (XmNamedQuery namedQuery : entityDeploy.getNamedQuery()) {
+        info.addNamedQuery(namedQuery.getName(), namedQuery.getQuery().getValue());
+      }
+    }
+  }
+
   /**
    * Return the Encrypt key given the table and column name.
    */
@@ -381,7 +454,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
     for (String depTable : viewInvalidation) {
       List<BeanDescriptor<?>> list = tableToViewDescMap.get(depTable.toLowerCase());
-      if (list == null) {
+      if (list != null) {
         for (int i = 0; i < list.size(); i++) {
           list.get(i).queryCacheClear();
         }
@@ -557,7 +630,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
   }
 
   private void logStatus() {
-    logger.info("Entities enhanced[" + enhancedClassCount + "]");
+    logger.debug("Entities[{}]", entityBeanCount);
   }
 
   private <T> BeanDescriptor<T> createEmbedded(Class<T> beanClass) {
@@ -569,7 +642,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
    * Return the bean deploy info for the given class.
    */
   public <T> DeployBeanInfo<T> getDeploy(Class<T> cls) {
-    return (DeployBeanInfo<T>) deplyInfoMap.get(cls);
+    return (DeployBeanInfo<T>) deployInfoMap.get(cls);
   }
 
   private void registerBeanDescriptor(BeanDescriptor<?> desc) {
@@ -601,12 +674,12 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
     for (Class<?> entityClass : bootupClasses.getEntities()) {
       DeployBeanInfo<?> info = createDeployBeanInfo(entityClass);
-      deplyInfoMap.put(entityClass, info);
+      deployInfoMap.put(entityClass, info);
     }
     for (Class<?> entityClass : bootupClasses.getEmbeddables()) {
       DeployBeanInfo<?> info = createDeployBeanInfo(entityClass);
       readDeployAssociations(info);
-      deplyInfoMap.put(entityClass, info);
+      deployInfoMap.put(entityClass, info);
     }
   }
 
@@ -618,7 +691,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
    */
   private void readEntityBeanTable() {
 
-    for (DeployBeanInfo<?> info : deplyInfoMap.values()) {
+    for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       BeanTable beanTable = createBeanTable(info);
       beanTableMap.put(beanTable.getBeanType(), beanTable);
     }
@@ -632,18 +705,18 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
    */
   private void readEntityDeploymentAssociations() {
 
-    for (DeployBeanInfo<?> info : deplyInfoMap.values()) {
+    for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       readDeployAssociations(info);
     }
   }
 
   private void readInheritedIdGenerators() {
 
-    for (DeployBeanInfo<?> info : deplyInfoMap.values()) {
+    for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       DeployBeanDescriptor<?> descriptor = info.getDescriptor();
       InheritInfo inheritInfo = descriptor.getInheritInfo();
       if (inheritInfo != null && !inheritInfo.isRoot()) {
-        DeployBeanInfo<?> rootBeanInfo = deplyInfoMap.get(inheritInfo.getRoot().getType());
+        DeployBeanInfo<?> rootBeanInfo = deployInfoMap.get(inheritInfo.getRoot().getType());
         PlatformIdGenerator rootIdGen = rootBeanInfo.getDescriptor().getIdGenerator();
         if (rootIdGen != null) {
           descriptor.setIdGenerator(rootIdGen);
@@ -668,20 +741,20 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     // We only perform 'circular' checks etc after we have
     // all the DeployBeanDescriptors created and in the map.
 
-    for (DeployBeanInfo<?> info : deplyInfoMap.values()) {
+    for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       checkMappedBy(info);
     }
 
-    for (DeployBeanInfo<?> info : deplyInfoMap.values()) {
+    for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       secondaryPropsJoins(info);
     }
 
     // Set inheritance info
-    for (DeployBeanInfo<?> info : deplyInfoMap.values()) {
+    for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       setInheritanceInfo(info);
     }
 
-    for (DeployBeanInfo<?> info : deplyInfoMap.values()) {
+    for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       registerBeanDescriptor(new BeanDescriptor(this, info.getDescriptor()));
     }
   }
@@ -695,7 +768,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
     for (DeployBeanPropertyAssocOne<?> oneProp : info.getDescriptor().propertiesAssocOne()) {
       if (!oneProp.isTransient()) {
-        DeployBeanInfo<?> assoc = deplyInfoMap.get(oneProp.getTargetType());
+        DeployBeanInfo<?> assoc = deployInfoMap.get(oneProp.getTargetType());
         if (assoc != null) {
           oneProp.getTableJoin().setInheritInfo(assoc.getDescriptor().getInheritInfo());
         }
@@ -704,7 +777,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
     for (DeployBeanPropertyAssocMany<?> manyProp : info.getDescriptor().propertiesAssocMany()) {
       if (!manyProp.isTransient()) {
-        DeployBeanInfo<?> assoc = deplyInfoMap.get(manyProp.getTargetType());
+        DeployBeanInfo<?> assoc = deployInfoMap.get(manyProp.getTargetType());
         if (assoc != null) {
           manyProp.getTableJoin().setInheritInfo(assoc.getDescriptor().getInheritInfo());
         }
@@ -763,7 +836,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
   private DeployBeanDescriptor<?> getTargetDescriptor(DeployBeanPropertyAssoc<?> prop) {
 
     Class<?> targetType = prop.getTargetType();
-    DeployBeanInfo<?> info = deplyInfoMap.get(targetType);
+    DeployBeanInfo<?> info = deployInfoMap.get(targetType);
     if (info == null) {
       String msg = "Can not find descriptor [" + targetType + "] for " + prop.getFullBeanName();
       throw new PersistenceException(msg);
@@ -1348,7 +1421,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     checkInheritedClasses(beanClass);
 
     if (!beanClass.getName().startsWith("com.avaje.ebean.meta")) {
-      enhancedClassCount++;
+      entityBeanCount++;
     }
   }
 

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

@@ -27,6 +27,7 @@ import com.avaje.ebeaninternal.server.type.DataBind;
 import com.avaje.ebeaninternal.server.type.ScalarType;
 import com.avaje.ebeaninternal.server.type.ScalarTypeBoolean;
 import com.avaje.ebeaninternal.server.type.ScalarTypeEnum;
+import com.avaje.ebeaninternal.server.type.ScalarTypeLogicalType;
 import com.avaje.ebeaninternal.util.ValueUtil;
 import com.avaje.ebeanservice.docstore.api.mapping.DocMappingBuilder;
 import com.avaje.ebeanservice.docstore.api.mapping.DocPropertyMapping;
@@ -413,7 +414,7 @@ public class BeanProperty implements ElPropertyValue, Property {
     this.generatedProperty = source.getGeneratedProperty();
     this.getter = source.getter;
     this.setter = source.setter;
-    this.dbType = source.getDbType();
+    this.dbType = source.getDbType(true);
     this.scalarType = source.scalarType;
     this.lob = isLobType(dbType);
     this.propertyType = source.getPropertyType();
@@ -1087,9 +1088,14 @@ public class BeanProperty implements ElPropertyValue, Property {
 
   /**
    * Return the database jdbc data type this is mapped to.
+   *
+   * @param platformTypes Set as false when we want logical platform agnostic types.
    */
-  public int getDbType() {
-    return dbType;
+  public int getDbType(boolean platformTypes) {
+    if (platformTypes || !(scalarType instanceof ScalarTypeLogicalType)) {
+      return dbType;
+    }
+    return ((ScalarTypeLogicalType)scalarType).getLogicalType();
   }
 
   /**
@@ -1167,6 +1173,13 @@ public class BeanProperty implements ElPropertyValue, Property {
     return excludedFromHistory;
   }
 
+  /**
+   * Return true if this is a ManyToMany with history support (on the intersection table).
+   */
+  public boolean isManyToManyWithHistory() {
+    return !excludedFromHistory && descriptor.isHistorySupport();
+  }
+
   /**
    * Return true if this property only exists on the draft table.
    */

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

@@ -21,6 +21,7 @@ import org.slf4j.LoggerFactory;
 
 import javax.persistence.PersistenceException;
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Abstract base for properties mapped to an associated bean, list, set or map.
@@ -41,6 +42,11 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty {
 
   String targetIdProperty;
 
+  /**
+   * Derived list of exported property and matching foreignKey
+   */
+  protected ExportedProperty[] exportedProperties;
+
   /**
    * Persist settings.
    */
@@ -322,7 +328,7 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty {
     BeanProperty idProp = target.getIdProperty();
     BeanProperty[] others = target.propertiesBaseScalar();
 
-    if (descriptor.isSqlSelectBased()) {
+    if (descriptor.isRawSqlBased()) {
       String dbColumn = owner.getDbColumn();
       return new ImportedIdSimple(owner, dbColumn, idProp, 0);
     }
@@ -385,4 +391,18 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty {
         + " Perhaps an error in a @JoinColumn";
     throw new PersistenceException(msg);
   }
+
+  protected void bindWhereParentId(List<Object> bindValues, Object parentId) {
+
+    if (exportedProperties.length == 1) {
+      bindValues.add(parentId);
+
+    } else {
+      EntityBean parent = (EntityBean) parentId;
+      for (int i = 0; i < exportedProperties.length; i++) {
+        Object embVal = exportedProperties[i].getValue(parent);
+        bindValues.add(embVal);
+      }
+    }
+  }
 }

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

@@ -85,11 +85,6 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
 
   private BeanProperty mapKeyProperty;
 
-  /**
-   * Derived list of exported property and matching foreignKey
-   */
-  private ExportedProperty[] exportedProperties;
-
   private String exportedPropertyBindProto = "?";
 
   /**
@@ -299,23 +294,25 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
   /**
    * Find the Id's of detail beans given a parent Id or list of parent Id's.
    */
-  public List<Object> findIdsByParentId(Object parentId, List<Object> parentIdist, Transaction t, ArrayList<Object> excludeDetailIds) {
+  public List<Object> findIdsByParentId(Object parentId, List<Object> parentIdList, Transaction t, ArrayList<Object> excludeDetailIds) {
     if (parentId != null) {
       return findIdsByParentId(parentId, t, excludeDetailIds);
     } else {
-      return findIdsByParentIdList(parentIdist, t, excludeDetailIds);
+      return findIdsByParentIdList(parentIdList, t, excludeDetailIds);
     }
   }
 
   private List<Object> findIdsByParentId(Object parentId, Transaction t, ArrayList<Object> excludeDetailIds) {
 
     String rawWhere = deriveWhereParentIdSql(false, "");
+    List<Object> bindValues = new ArrayList<Object>();
+    bindWhereParentId(bindValues, parentId);
 
     EbeanServer server = getBeanDescriptor().getEbeanServer();
     Query<?> q = server.find(getPropertyType())
-        .where().raw(rawWhere).query();
-
-    bindWhereParendId(1, q, parentId);
+        .where()
+        .raw(rawWhere, bindValues.toArray())
+        .query();
 
     if (excludeDetailIds != null && !excludeDetailIds.isEmpty()) {
       Expression idIn = q.getExpressionFactory().idIn(excludeDetailIds);
@@ -360,7 +357,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
 
     String tableAlias = manyToMany ? "int_." : "t0.";
     if (manyToMany) {
-      query.setIncludeTableJoin(inverseJoin);
+      query.setM2MIncludeJoin(inverseJoin);
     }
     String rawWhere = deriveWhereParentIdSql(true, tableAlias);
     String expr = descriptor.getParentIdInExpr(parentIds.size(), rawWhere);
@@ -371,21 +368,24 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
     query.where().raw(expr, bindValues.toArray());
   }
 
-  private List<Object> findIdsByParentIdList(List<Object> parentIdist, Transaction t, ArrayList<Object> excludeDetailIds) {
+  private List<Object> findIdsByParentIdList(List<Object> parentIdList, Transaction t, ArrayList<Object> excludeDetailIds) {
 
     String rawWhere = deriveWhereParentIdSql(true, "");
-    String inClause = buildInClauseBinding(parentIdist.size(), exportedPropertyBindProto);
+    String inClause = buildInClauseBinding(parentIdList.size(), exportedPropertyBindProto);
 
     String expr = rawWhere + inClause;
 
-    EbeanServer server = getBeanDescriptor().getEbeanServer();
-    Query<?> q = server.find(getPropertyType()).where().raw(expr).query();
-
-    int pos = 1;
-    for (int i = 0; i < parentIdist.size(); i++) {
-      pos = bindWhereParendId(pos, q, parentIdist.get(i));
+    List<Object> bindValues = new ArrayList<Object>();
+    for (int i = 0; i < parentIdList.size(); i++) {
+      bindWhereParentId(bindValues, parentIdList.get(i));
     }
 
+    EbeanServer server = getBeanDescriptor().getEbeanServer();
+    Query<?> q = server.find(getPropertyType())
+        .where()
+        .raw(expr, bindValues.toArray())
+        .query();
+
     if (excludeDetailIds != null && !excludeDetailIds.isEmpty()) {
       Expression idIn = q.getExpressionFactory().idIn(excludeDetailIds);
       q.where().not(idIn);
@@ -690,22 +690,6 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
     }
   }
 
-  private int bindWhereParendId(int pos, Query<?> q, Object parentId) {
-
-    if (exportedProperties.length == 1) {
-      q.setParameter(pos++, parentId);
-
-    } else {
-
-      EntityBean parent = (EntityBean) parentId;
-      for (int i = 0; i < exportedProperties.length; i++) {
-        Object embVal = exportedProperties[i].getValue(parent);
-        q.setParameter(pos++, embVal);
-      }
-    }
-    return pos;
-  }
-
   public void addSelectExported(DbSqlContext ctx, String tableAlias) {
 
     String alias = manyToMany ? "int_" : tableAlias;
@@ -1028,7 +1012,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
       if (isManyToMany()) {
         if (liveBean == null) {
           // add new relationship (Map not allowed here)
-          liveVal.addBean(targetDescriptor.createReference(Boolean.FALSE, id, null));
+          liveVal.addBean(targetDescriptor.createReference(Boolean.FALSE, false, id, null));
         }
 
       } else {

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

@@ -3,7 +3,6 @@ package com.avaje.ebeaninternal.server.deploy;
 import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.BeanCollectionAdd;
 import com.avaje.ebean.bean.EntityBean;
-import com.avaje.ebeaninternal.api.ClassUtil;
 import com.avaje.ebeaninternal.server.text.json.ReadJson;
 import com.fasterxml.jackson.core.JsonParseException;
 import com.fasterxml.jackson.core.JsonParser;

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

@@ -50,8 +50,6 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> {
    */
   protected ImportedId importedId;
 
-  private ExportedProperty[] exportedProperties;
-
   private String deleteByParentIdSql;
   private String deleteByParentIdInSql;
 
@@ -240,47 +238,37 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> {
 
     String rawWhere = deriveWhereParentIdSql(false);
 
+    List<Object> bindValues = new ArrayList<Object>();
+    bindWhereParentId(bindValues, parentId);
+
     EbeanServer server = getBeanDescriptor().getEbeanServer();
     Query<?> q = server.find(getPropertyType())
-        .where().raw(rawWhere).query();
+        .where()
+        .raw(rawWhere, bindValues.toArray())
+        .query();
 
-    bindWhereParendId(q, parentId);
     return server.findIds(q, t);
   }
 
-  private List<Object> findIdsByParentIdList(List<Object> parentIdist, Transaction t) {
+  private List<Object> findIdsByParentIdList(List<Object> parentIdList, Transaction t) {
 
     String rawWhere = deriveWhereParentIdSql(true);
-    String inClause = targetIdBinder.getIdInValueExpr(parentIdist.size());
+    String inClause = targetIdBinder.getIdInValueExpr(parentIdList.size());
 
     String expr = rawWhere + inClause;
 
+    List<Object> bindValues = new ArrayList<Object>();
+    for (int i = 0; i < parentIdList.size(); i++) {
+      bindWhereParentId(bindValues, parentIdList.get(i));
+    }
+
     EbeanServer server = getBeanDescriptor().getEbeanServer();
     Query<?> q = (Query<?>) server.find(getPropertyType())
-        .where().raw(expr);
-
-    for (int i = 0; i < parentIdist.size(); i++) {
-      bindWhereParendId(q, parentIdist.get(i));
-    }
+        .where().raw(expr, bindValues.toArray());
 
     return server.findIds(q, t);
   }
 
-  private void bindWhereParendId(Query<?> q, Object parentId) {
-
-    if (exportedProperties.length == 1) {
-      q.setParameter(1, parentId);
-
-    } else {
-      int pos = 1;
-      EntityBean parent = (EntityBean) parentId;
-      for (int i = 0; i < exportedProperties.length; i++) {
-        Object embVal = exportedProperties[i].getValue(parent);
-        q.setParameter(pos++, embVal);
-      }
-    }
-  }
-
   void addFkey() {
     if (importedId != null) {
       importedId.addFkeys(name);
@@ -422,7 +410,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> {
         // cacheData is the id value, maybe already in persistence context
         Object assocBean = targetDescriptor.contextGet(context, cacheData);
         if (assocBean == null) {
-          assocBean = targetDescriptor.createReference(Boolean.FALSE, cacheData, context);
+          assocBean = targetDescriptor.createReference(Boolean.FALSE, false, cacheData, context);
         }
         setValue(bean, assocBean);
       }

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

@@ -84,4 +84,9 @@ public interface DbReadContext {
    * Return true if the underlying query is a 'asDraft' query.
    */
   boolean isDraftQuery();
+
+  /**
+   * Return true if this request disables lazy loading.
+   */
+  boolean isDisableLazyLoading();
 }

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

@@ -51,14 +51,14 @@ public abstract class DeployParser {
 	 */
 	public abstract Set<String> getIncludes();
 
-    public void setEncrypted(boolean encrytped) {
-        this.encrypted = encrytped;
-    }
+	public void setEncrypted(boolean encrypted) {
+		this.encrypted = encrypted;
+	}
 
 	public String parse(String source) {
 
 		if (source == null) {
-			return source;
+			return null;
 		}
 		
 		pos = -1;

src/main/java/com/avaje/ebeaninternal/server/deploy/id/IdBinderSimple.java

@@ -217,12 +217,10 @@ public final class IdBinderSimple implements IdBinder {
     if (!idValue.getClass().equals(expectedType)) {
       idValue = scalarType.toBeanType(idValue);
     }
-
     if (bean != null) {
       // support PropertyChangeSupport
       idProperty.setValueIntercept(bean, idValue);
     }
-
     return idValue;
   }
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/id/ImportedIdEmbedded.java

@@ -144,15 +144,13 @@ public class ImportedIdEmbedded implements ImportedId {
    */
   public BeanProperty findMatchImport(String matchDbColumn) {
 
-    BeanProperty p = null;
     for (int i = 0; i < imported.length; i++) {
-      p = imported[i].findMatchImport(matchDbColumn);
+      BeanProperty p = imported[i].findMatchImport(matchDbColumn);
       if (p != null) {
         return p;
       }
     }
-
-    return p;
+    return null;
   }
 
 }

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

@@ -1,5 +1,6 @@
 package com.avaje.ebeaninternal.server.deploy.meta;
 
+import com.avaje.ebean.RawSql;
 import com.avaje.ebean.annotation.Cache;
 import com.avaje.ebean.annotation.DocStore;
 import com.avaje.ebean.annotation.DocStoreMode;
@@ -35,14 +36,20 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Describes Beans including their deployment information.
  */
 public class DeployBeanDescriptor<T> {
 
+  private static final Map<String, String> EMPTY_NAMED_QUERY = new HashMap<String, String>();
+
+  private static final Map<String, RawSql> EMPTY_RAW_MAP = new HashMap<String, RawSql>();
+
   private static class PropOrder implements Comparator<DeployBeanProperty> {
 
     public int compare(DeployBeanProperty o1, DeployBeanProperty o2) {
@@ -66,6 +73,10 @@ public class DeployBeanDescriptor<T> {
    */
   private LinkedHashMap<String, DeployBeanProperty> propMap = new LinkedHashMap<String, DeployBeanProperty>();
 
+  private Map<String, RawSql> namedRawSql;
+
+  private Map<String, String> namedQuery;
+
   private EntityType entityType;
 
   private DeployBeanPropertyAssocOne<?> unidirectional;
@@ -561,7 +572,7 @@ public class DeployBeanDescriptor<T> {
    * Return the base table with as of suffix.
    */
   public String getBaseTableAsOf() {
-    return baseTableAsOf;
+    return historySupport ? baseTableAsOf : baseTable;
   }
 
   /**
@@ -1047,4 +1058,38 @@ public class DeployBeanDescriptor<T> {
     if (docStorePersist != DocStoreMode.DEFAULT) return docStorePersist;
     return serverConfig.getDocStoreConfig().getPersist();
   }
+
+  /**
+   * Return the named ORM queries.
+   */
+  public Map<String, String> getNamedQuery() {
+    return (namedQuery != null) ? namedQuery : EMPTY_NAMED_QUERY;
+  }
+
+  /**
+   * Add a named query.
+   */
+  public void addNamedQuery(String name, String query) {
+    if (namedQuery == null) {
+      namedQuery = new LinkedHashMap<String, String>();
+    }
+    namedQuery.put(name, query);
+  }
+
+  /**
+   * Return the named RawSql queries.
+   */
+  public Map<String, RawSql> getNamedRawSql() {
+    return (namedRawSql != null) ? namedRawSql : EMPTY_RAW_MAP;
+  }
+
+  /**
+   * Add a named RawSql from ebean.xml file.
+   */
+  public void addRawSql(String name, RawSql rawSql) {
+    if (namedRawSql == null) {
+      namedRawSql = new HashMap<String, RawSql>();
+    }
+    namedRawSql.put(name, rawSql);
+  }
 }

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

@@ -170,9 +170,7 @@ public class AnnotationAssocManys extends AnnotationParser {
 	}
 
 	/**
-	 * Return the full table name 
-	 * @param joinTable
-	 * @return
+	 * Return the full table name
 	 */
 	private String getFullTableName(JoinTable joinTable) {
 	    StringBuilder sb = new StringBuilder();

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

@@ -21,6 +21,8 @@ import javax.persistence.AttributeOverride;
 import javax.persistence.Column;
 import javax.persistence.Embeddable;
 import javax.persistence.Entity;
+import javax.persistence.NamedQueries;
+import javax.persistence.NamedQuery;
 import javax.persistence.Table;
 import javax.persistence.UniqueConstraint;
 
@@ -68,13 +70,11 @@ public class AnnotationClass extends AnnotationParser {
     if (override != null) {
       String propertyName = override.name();
       Column column = override.column();
-      if (column != null) {
-        DeployBeanProperty beanProperty = descriptor.getBeanProperty(propertyName);
-        if (beanProperty == null) {
-          logger.error("AttributeOverride property [" + propertyName + "] not found on " + descriptor.getFullName());
-        } else {
-          readColumn(column, beanProperty);
-        }
+      DeployBeanProperty beanProperty = descriptor.getBeanProperty(propertyName);
+      if (beanProperty == null) {
+        logger.error("AttributeOverride property [" + propertyName + "] not found on " + descriptor.getFullName());
+      } else {
+        readColumn(column, beanProperty);
       }
     }
   }
@@ -179,6 +179,18 @@ public class AnnotationClass extends AnnotationParser {
     if (cache != null && !disableL2Cache) {
       descriptor.setCache(cache);
     }
+
+    NamedQueries namedQueries = cls.getAnnotation(NamedQueries.class);
+    if (namedQueries != null) {
+      for (NamedQuery namedQuery : namedQueries.value()) {
+        descriptor.addNamedQuery(namedQuery.name(), namedQuery.query());
+      }
+    }
+
+    NamedQuery namedQuery = cls.getAnnotation(NamedQuery.class);
+    if (namedQuery != null) {
+      descriptor.addNamedQuery(namedQuery.name(), namedQuery.query());
+    }
   }
 
 }

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

@@ -1,12 +1,13 @@
 package com.avaje.ebeaninternal.server.deploy.parse;
 
-import java.util.HashMap;
-
+import com.avaje.ebean.RawSql;
 import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanDescriptor;
 import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanPropertyAssocOne;
 import com.avaje.ebeaninternal.server.deploy.meta.DeployTableJoin;
 import com.avaje.ebeaninternal.server.query.SqlJoinType;
 
+import java.util.HashMap;
+
 /**
  * Wraps information about a bean during deployment parsing.
  */
@@ -75,4 +76,17 @@ public class DeployBeanInfo<T> {
 		tableJoin.setType(outerJoin ? SqlJoinType.OUTER : SqlJoinType.INNER);
 	}
 
+  /**
+   * Add named RawSql from ebean.xml.
+   */
+	public void addRawSql(String name, RawSql rawSql) {
+		descriptor.addRawSql(name, rawSql);
+	}
+
+	/**
+	 * Add the named query.
+   */
+	public void addNamedQuery(String name, String query) {
+		descriptor.addNamedQuery(name, query);
+	}
 }

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

@@ -4,8 +4,6 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.regex.Pattern;
 
-import com.avaje.ebean.bean.EntityBean;
-
 
 /**
  * Contains the various ElMatcher implementations.

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

@@ -21,6 +21,11 @@ public abstract class AbstractExpression implements SpiExpression {
     this.propName = propName;
   }
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public Object getIdEqualTo(String idName) {
     // override on SimpleExpression

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

@@ -0,0 +1,32 @@
+package com.avaje.ebeaninternal.server.expression;
+
+/**
+ * Abstract expression that helps with named parameter use.
+ */
+public abstract class AbstractValueExpression extends AbstractExpression {
+
+  protected final Object bindValue;
+
+  /**
+   * Construct with property name and potential named parameter.
+   */
+  protected AbstractValueExpression(String propName, Object bindValue) {
+    super(propName);
+    this.bindValue = bindValue;
+  }
+
+  /**
+   * Return the bind value taking into account named parameters.
+   */
+  protected Object value() {
+    return NamedParamHelp.value(bindValue);
+  }
+
+  /**
+   * Return the String bind value taking into account named parameters.
+   */
+  protected String strValue() {
+    return NamedParamHelp.valueAsString(bindValue);
+  }
+
+}

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

@@ -14,21 +14,29 @@ class BetweenExpression extends AbstractExpression {
 
   private final Object valueLow;
 
-  BetweenExpression(String propertyName, Object valLo, Object valHigh) {
+  BetweenExpression(String propertyName, Object valueLow, Object valueHigh) {
     super(propertyName);
-    this.valueLow = valLo;
-    this.valueHigh = valHigh;
+    this.valueLow = valueLow;
+    this.valueHigh = valueHigh;
+  }
+
+  private Object low() {
+    return NamedParamHelp.value(valueLow);
+  }
+
+  private Object high() {
+    return NamedParamHelp.value(valueHigh);
   }
 
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
-    context.writeRange(propName, Op.GT_EQ, valueLow, Op.LT_EQ, valueHigh);
+    context.writeRange(propName, Op.GT_EQ, low(), Op.LT_EQ, high());
   }
 
   @Override
   public void addBindValues(SpiExpressionRequest request) {
-    request.addBindValue(valueLow);
-    request.addBindValue(valueHigh);
+    request.addBindValue(low());
+    request.addBindValue(high());
   }
 
   @Override
@@ -45,8 +53,8 @@ class BetweenExpression extends AbstractExpression {
 
   @Override
   public int queryBindHash() {
-    int hc = valueLow.hashCode();
-    hc = hc * 31 + valueHigh.hashCode();
+    int hc = low().hashCode();
+    hc = hc * 31 + high().hashCode();
     return hc;
   }
 
@@ -63,7 +71,7 @@ class BetweenExpression extends AbstractExpression {
   @Override
   public boolean isSameByBind(SpiExpression other) {
     BetweenExpression that = (BetweenExpression) other;
-    return valueLow.equals(that.valueLow)
-        && valueHigh.equals(that.valueHigh);
+    return low().equals(that.low())
+        && high().equals(that.high());
   }
 }

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

@@ -32,11 +32,15 @@ class BetweenPropertyExpression extends NonPrepareExpression {
     return propName;
   }
 
+  private Object val() {
+    return NamedParamHelp.value(value);
+  }
+
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
     context.startBoolMust();
-    context.writeSimple(Op.LT_EQ, lowProperty, value);
-    context.writeSimple(Op.GT_EQ, highProperty, value);
+    context.writeSimple(Op.LT_EQ, lowProperty, val());
+    context.writeSimple(Op.GT_EQ, highProperty, val());
     context.endBool();
   }
 
@@ -72,7 +76,7 @@ class BetweenPropertyExpression extends NonPrepareExpression {
 
   @Override
   public void addBindValues(SpiExpressionRequest request) {
-    request.addBindValue(value);
+    request.addBindValue(val());
   }
 
   @Override
@@ -89,7 +93,7 @@ class BetweenPropertyExpression extends NonPrepareExpression {
 
   @Override
   public int queryBindHash() {
-    return value.hashCode();
+    return val().hashCode();
   }
 
   @Override
@@ -106,6 +110,6 @@ class BetweenPropertyExpression extends NonPrepareExpression {
   @Override
   public boolean isSameByBind(SpiExpression other) {
     BetweenPropertyExpression that = (BetweenPropertyExpression) other;
-    return value.equals(that.value);
+    return val().equals(that.val());
   }
 }

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

@@ -7,18 +7,22 @@ import com.avaje.ebeaninternal.server.el.ElPropertyValue;
 
 import java.io.IOException;
 
-class CaseInsensitiveEqualExpression extends AbstractExpression {
+class CaseInsensitiveEqualExpression extends AbstractValueExpression {
 
-  private final String value;
+  CaseInsensitiveEqualExpression(String propertyName, Object value) {
+    super(propertyName, value);
+  }
 
-  CaseInsensitiveEqualExpression(String propertyName, String value) {
-    super(propertyName);
-    this.value = value.toLowerCase();
+  /**
+   * Return the bind value taking into account named parameters.
+   */
+  private String val() {
+    return strValue().toLowerCase();
   }
 
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
-    context.writeIEqualTo(propName, value);
+    context.writeIEqualTo(propName, val());
   }
 
   @Override
@@ -31,7 +35,7 @@ class CaseInsensitiveEqualExpression extends AbstractExpression {
       request.addBindEncryptKey(encryptKey);
     }
 
-    request.addBindValue(value);
+    request.addBindValue(val());
   }
 
   @Override
@@ -54,7 +58,7 @@ class CaseInsensitiveEqualExpression extends AbstractExpression {
 
   @Override
   public int queryBindHash() {
-    return value.hashCode();
+    return val().hashCode();
   }
 
   @Override
@@ -70,6 +74,6 @@ class CaseInsensitiveEqualExpression extends AbstractExpression {
   @Override
   public boolean isSameByBind(SpiExpression other) {
     CaseInsensitiveEqualExpression that = (CaseInsensitiveEqualExpression) other;
-    return value.equals(that.value);
+    return val().equals(that.val());
   }
 }

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

@@ -88,6 +88,11 @@ public class DefaultExampleExpression implements SpiExpression, ExampleExpressio
     }
   }
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
     if (!list.isEmpty()) {

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

@@ -157,6 +157,13 @@ public class DefaultExpressionFactory implements SpiExpressionFactory {
     return new CaseInsensitiveEqualExpression(propertyName, value);
   }
 
+  /**
+   * Create for named parameter use (and without support for equalsWithNullAsNoop).
+   */
+  public Expression ieqObject(String propertyName, Object value) {
+    return new CaseInsensitiveEqualExpression(propertyName, value);
+  }
+
   /**
    * Between - property between the two given values.
    */
@@ -251,6 +258,11 @@ public class DefaultExpressionFactory implements SpiExpressionFactory {
     return new DefaultExampleExpression(checkEntityBean(example), caseInsensitive, likeType);
   }
 
+  @Override
+  public Expression like(String propertyName, Object value, boolean caseInsensitive, LikeType likeType) {
+    return new LikeExpression(propertyName, value, caseInsensitive, likeType);
+  }
+
   /**
    * Like - property like value where the value contains the SQL wild card
    * characters % (percentage) and _ (underscore).

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

@@ -97,6 +97,16 @@ public class DefaultExpressionList<T> implements SpiExpressionList<T> {
     }
   }
 
+  void simplifyEntries() {
+    for (SpiExpression element : list) {
+      element.simplify();
+    }
+  }
+
+  public void simplify() {
+    simplifyEntries();
+  }
+
   /**
    * Write being aware if it is the Top level "text" expressions.
    * <p>
@@ -313,9 +323,14 @@ public class DefaultExpressionList<T> implements SpiExpressionList<T> {
     return query.findFutureIds();
   }
 
+  @Override
+  public FutureRowCount<T> findFutureCount() {
+    return query.findFutureCount();
+  }
+
   @Override
   public FutureRowCount<T> findFutureRowCount() {
-    return query.findFutureRowCount();
+    return findFutureCount();
   }
 
   @Override
@@ -328,9 +343,14 @@ public class DefaultExpressionList<T> implements SpiExpressionList<T> {
     return query.findPagedList();
   }
 
+  @Override
+  public int findCount() {
+    return query.findCount();
+  }
+
   @Override
   public int findRowCount() {
-    return query.findRowCount();
+    return findCount();
   }
 
   @Override

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

@@ -36,6 +36,11 @@ class ExistsQueryExpression implements SpiExpression, UnsupportedDocStoreExpress
     this.subQuery = null;
   }
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
     throw new IllegalStateException("Not supported");

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

@@ -48,9 +48,14 @@ public class FilterExpressionList<T> extends DefaultExpressionList<T> {
     return rootQuery.findFutureList();
   }
 
+  @Override
+  public FutureRowCount<T> findFutureCount() {
+    return rootQuery.findFutureCount();
+  }
+
   @Override
   public FutureRowCount<T> findFutureRowCount() {
-    return rootQuery.findFutureRowCount();
+    return findFutureCount();
   }
 
   @Override
@@ -63,9 +68,14 @@ public class FilterExpressionList<T> extends DefaultExpressionList<T> {
     return rootQuery.findMap();
   }
 
+  @Override
+  public int findCount() {
+    return rootQuery.findCount();
+  }
+
   @Override
   public int findRowCount() {
-    return rootQuery.findRowCount();
+    return findCount();
   }
 
   @Override

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

@@ -1,35 +1,54 @@
 package com.avaje.ebeaninternal.server.expression;
 
 import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebean.event.BeanQueryRequest;
 import com.avaje.ebeaninternal.api.HashQueryPlanBuilder;
 import com.avaje.ebeaninternal.api.SpiExpression;
 import com.avaje.ebeaninternal.api.SpiExpressionRequest;
 import com.avaje.ebeaninternal.server.el.ElPropertyValue;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.List;
 
 class InExpression extends AbstractExpression {
 
   private final boolean not;
 
-  private final Object[] values;
+  private final Collection<?> sourceValues;
 
-  InExpression(String propertyName, Collection<?> coll, boolean not) {
+  private Object[] bindValues;
+
+  InExpression(String propertyName, Collection<?> sourceValues, boolean not) {
     super(propertyName);
-    this.values = coll.toArray(new Object[coll.size()]);
+    this.sourceValues = sourceValues;
     this.not = not;
   }
 
   InExpression(String propertyName, Object[] array, boolean not) {
     super(propertyName);
-    this.values = array;
+    this.sourceValues = Arrays.asList(array);
     this.not = not;
   }
 
+  private Object[] values() {
+    List<Object> vals = new ArrayList<Object>();
+    for (Object sourceValue : sourceValues) {
+      NamedParamHelp.valueAdd(vals, sourceValue);
+    }
+    return vals.toArray();
+  }
+
+  @Override
+  public void prepareExpression(BeanQueryRequest<?> request) {
+    bindValues = values();
+  }
+
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
-    context.writeIn(propName, values, not);
+    context.writeIn(propName, values(), not);
   }
 
   @Override
@@ -40,13 +59,13 @@ class InExpression extends AbstractExpression {
       prop = null;
     }
 
-    for (int i = 0; i < values.length; i++) {
+    for (int i = 0; i < bindValues.length; i++) {
       if (prop == null) {
-        request.addBindValue(values[i]);
+        request.addBindValue(bindValues[i]);
 
       } else {
         // extract the id values from the bean
-        Object[] ids = prop.getAssocIdValues((EntityBean) values[i]);
+        Object[] ids = prop.getAssocIdValues((EntityBean) bindValues[i]);
         if (ids != null) {
           for (int j = 0; j < ids.length; j++) {
             request.addBindValue(ids[j]);
@@ -59,7 +78,7 @@ class InExpression extends AbstractExpression {
   @Override
   public void addSql(SpiExpressionRequest request) {
 
-    if (values.length == 0) {
+    if (bindValues.length == 0) {
       String expr = not ? "1=1" : "1=0";
       request.append(expr);
       return;
@@ -72,7 +91,7 @@ class InExpression extends AbstractExpression {
 
     if (prop != null) {
       request.append(prop.getAssocIdInExpr(propName));
-      String inClause = prop.getAssocIdInValueExpr(values.length);
+      String inClause = prop.getAssocIdInValueExpr(bindValues.length);
       request.append(inClause);
 
     } else {
@@ -81,7 +100,7 @@ class InExpression extends AbstractExpression {
         request.append(" not");
       }
       request.append(" in (?");
-      for (int i = 1; i < values.length; i++) {
+      for (int i = 1; i < bindValues.length; i++) {
         request.append(", ").append("?");
       }
 
@@ -94,15 +113,15 @@ class InExpression extends AbstractExpression {
    */
   @Override
   public void queryPlanHash(HashQueryPlanBuilder builder) {
-    builder.add(InExpression.class).add(propName).add(values.length).add(not);
-    builder.bind(values.length);
+    builder.add(InExpression.class).add(propName).add(bindValues.length).add(not);
+    builder.bind(bindValues.length);
   }
 
   @Override
   public int queryBindHash() {
     int hc = 31;
-    for (int i = 0; i < values.length; i++) {
-      hc = 31 * hc + values[i].hashCode();
+    for (int i = 0; i < bindValues.length; i++) {
+      hc = 31 * hc + bindValues[i].hashCode();
     }
     return hc;
   }
@@ -116,17 +135,17 @@ class InExpression extends AbstractExpression {
     InExpression that = (InExpression) other;
     return propName.equals(that.propName)
         && not == that.not
-        && values.length == that.values.length;
+        && bindValues.length == that.bindValues.length;
   }
 
   @Override
   public boolean isSameByBind(SpiExpression other) {
     InExpression that = (InExpression) other;
-    if (this.values.length != that.values.length) {
+    if (this.bindValues.length != that.bindValues.length) {
       return false;
     }
-    for (int i = 0; i < values.length; i++) {
-      if (!values[i].equals(that.values[i])) {
+    for (int i = 0; i < bindValues.length; i++) {
+      if (!bindValues[i].equals(that.bindValues[i])) {
         return false;
       }
     }

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

@@ -38,6 +38,11 @@ class InQueryExpression extends AbstractExpression implements UnsupportedDocStor
     this.bindParams = bindParams;
   }
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
     throw new IllegalStateException("Not supported");

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

@@ -39,9 +39,9 @@ import java.util.Set;
  */
 class JunctionExpression<T> implements SpiJunction<T>, SpiExpression, ExpressionList<T> {
 
-  protected final DefaultExpressionList<T> exprList;
+  protected DefaultExpressionList<T> exprList;
 
-  protected final Junction.Type type;
+  protected Junction.Type type;
 
   JunctionExpression(Junction.Type type, Query<T> query, ExpressionList<T> parent) {
     this.type = type;
@@ -56,6 +56,31 @@ class JunctionExpression<T> implements SpiJunction<T>, SpiExpression, Expression
     this.exprList = exprList;
   }
 
+  /**
+   * Simplify nested expressions where possible.
+   * <p>
+   * This is expected to only used after expressions are built via query language parsing.
+   * </p>
+   */
+  public void simplify() {
+    exprList.simplifyEntries();
+
+    List<SpiExpression> list = exprList.list;
+    if (list.size() == 1 && list.get(0) instanceof JunctionExpression) {
+      JunctionExpression nested = (JunctionExpression)list.get(0);
+      if (type == Type.AND && !nested.type.isText()) {
+        // and (and (a, b, c)) -> and (a, b, c)
+        // and (not (a, b, c)) -> not (a, b, c)
+        // and (or  (a, b, c)) -> or  (a, b, c)
+        this.exprList = nested.exprList;
+        this.type = nested.type;
+      } else if (type == Type.NOT && nested.type == Type.AND) {
+        // not (and (a, b, c)) -> not (a, b, c)
+        this.exprList = nested.exprList;
+      }
+    }
+  }
+
   public SpiExpression copyForPlanKey() {
     return new JunctionExpression<T>(type, exprList.copyForPlanKey());
   }
@@ -335,9 +360,14 @@ class JunctionExpression<T> implements SpiJunction<T>, SpiExpression, Expression
     return exprList.findFutureList();
   }
 
+  @Override
+  public FutureRowCount<T> findFutureCount() {
+    return exprList.findFutureCount();
+  }
+
   @Override
   public FutureRowCount<T> findFutureRowCount() {
-    return exprList.findFutureRowCount();
+    return findFutureCount();
   }
 
   @Override
@@ -376,10 +406,15 @@ class JunctionExpression<T> implements SpiJunction<T>, SpiExpression, Expression
   }
 
   @Override
-  public int findRowCount() {
+  public int findCount() {
     return exprList.findRowCount();
   }
 
+  @Override
+  public int findRowCount() {
+    return findCount();
+  }
+
   @Override
   public Set<T> findSet() {
     return exprList.findSet();

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

@@ -8,24 +8,21 @@ import com.avaje.ebeaninternal.server.el.ElPropertyValue;
 
 import java.io.IOException;
 
-class LikeExpression extends AbstractExpression {
-
-  private final String val;
+class LikeExpression extends AbstractValueExpression {
 
   private final boolean caseInsensitive;
 
   private final LikeType type;
 
-  LikeExpression(String propertyName, String value, boolean caseInsensitive, LikeType type) {
-    super(propertyName);
+  LikeExpression(String propertyName, Object value, boolean caseInsensitive, LikeType type) {
+    super(propertyName, value);
     this.caseInsensitive = caseInsensitive;
     this.type = type;
-    this.val = value;
   }
 
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
-    context.writeLike(propName, val, type, caseInsensitive);
+    context.writeLike(propName, strValue(), type, caseInsensitive);
   }
 
   @Override
@@ -38,7 +35,7 @@ class LikeExpression extends AbstractExpression {
       request.addBindEncryptKey(encryptKey);
     }
 
-    String bindValue = getValue(val, caseInsensitive, type);
+    String bindValue = getValue(strValue(), caseInsensitive, type);
     request.addBindValue(bindValue);
   }
 
@@ -74,7 +71,7 @@ class LikeExpression extends AbstractExpression {
 
   @Override
   public int queryBindHash() {
-    return val.hashCode();
+    return strValue().hashCode();
   }
 
   @Override
@@ -92,7 +89,7 @@ class LikeExpression extends AbstractExpression {
   @Override
   public boolean isSameByBind(SpiExpression other) {
     LikeExpression that = (LikeExpression) other;
-    return val.equals(that.val);
+    return strValue().equals(that.strValue());
   }
 
   private static String getValue(String value, boolean caseInsensitive, LikeType type) {

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

@@ -57,6 +57,11 @@ abstract class LogicExpression implements SpiExpression {
     this.expTwo = (SpiExpression) expTwo;
   }
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
 

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

@@ -0,0 +1,43 @@
+package com.avaje.ebeaninternal.server.expression;
+
+import com.avaje.ebeaninternal.api.SpiNamedParam;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Helper for evaluating named parameters.
+ */
+class NamedParamHelp {
+
+  /**
+   * Return the bind value taking into account named parameters.
+   */
+  static Object value(Object val) {
+    if (val instanceof SpiNamedParam) {
+      return ((SpiNamedParam) val).getValue();
+    }
+    return val;
+  }
+
+  /**
+   * Return the value as a string.
+   */
+  static String valueAsString(Object val) {
+    Object value = value(val);
+    return (value == null) ? null : value.toString();
+  }
+
+  /**
+   * Add the potentially named parameter(s) to the values.
+   */
+  public static void valueAdd(List<Object> values, Object sourceValue) {
+
+    Object value = value(sourceValue);
+    if (value instanceof Collection) {
+      values.addAll((Collection)value);
+    } else {
+      values.add(value);
+    }
+  }
+}

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

@@ -24,6 +24,11 @@ class NestedPathWrapperExpression implements SpiExpression {
     this.delegate = delegate;
   }
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
     context.startNested(nestedPath);

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

@@ -8,6 +8,11 @@ import com.avaje.ebeaninternal.api.SpiExpression;
  */
 abstract class NonPrepareExpression implements SpiExpression {
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public void prepareExpression(BeanQueryRequest<?> request) {
     // do nothing

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

@@ -17,6 +17,11 @@ class NoopExpression implements SpiExpression {
 
   protected static final NoopExpression INSTANCE = new NoopExpression();
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public SpiExpression copyForPlanKey() {
     return this;

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

@@ -22,6 +22,11 @@ final class NotExpression implements SpiExpression {
     this.exp = (SpiExpression) exp;
   }
 
+  @Override
+  public void simplify() {
+    // do nothing
+  }
+
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
     context.startBoolMustNot();

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

@@ -9,22 +9,19 @@ import com.avaje.ebeaninternal.server.el.ElPropertyValue;
 
 import java.io.IOException;
 
-public class SimpleExpression extends AbstractExpression {
+public class SimpleExpression extends AbstractValueExpression {
 
   private final Op type;
 
-  private final Object value;
-
   public SimpleExpression(String propertyName, Op type, Object value) {
-    super(propertyName);
+    super(propertyName, value);
     this.type = type;
-    this.value = value;
   }
 
   @Override
   public Object getIdEqualTo(String idName) {
     if (type == Op.EQ && idName.equals(propName)) {
-      return value;
+      return value();
     }
     return null;
   }
@@ -37,13 +34,13 @@ public class SimpleExpression extends AbstractExpression {
     ExpressionPath prop = context.getExpressionPath(propName);
     if (prop != null && prop.isAssocId()) {
       String idName = prop.getAssocIdExpression(propName, "");
-      Object[] ids = prop.getAssocIdValues((EntityBean) value);
+      Object[] ids = prop.getAssocIdValues((EntityBean) value());
       if (ids == null || ids.length != 1) {
         throw new IllegalArgumentException("Expecting 1 Id value for " + idName + " but got " + ids);
       }
       context.writeSimple(type, idName, ids[0]);
     } else {
-      context.writeSimple(type, propName, value);
+      context.writeSimple(type, propName, value());
     }
   }
 
@@ -56,7 +53,7 @@ public class SimpleExpression extends AbstractExpression {
   }
 
   public Object getValue() {
-    return value;
+    return value();
   }
 
   @Override
@@ -65,7 +62,7 @@ public class SimpleExpression extends AbstractExpression {
     ElPropertyValue prop = getElProp(request);
     if (prop != null) {
       if (prop.isAssocId()) {
-        Object[] ids = prop.getAssocIdValues((EntityBean) value);
+        Object[] ids = prop.getAssocIdValues((EntityBean) value());
         if (ids != null) {
           for (int i = 0; i < ids.length; i++) {
             request.addBindValue(ids[i]);
@@ -83,7 +80,7 @@ public class SimpleExpression extends AbstractExpression {
       // prop.getBeanProperty().getScalarType();
     }
 
-    request.addBindValue(value);
+    request.addBindValue(value());
   }
 
   @Override
@@ -115,7 +112,7 @@ public class SimpleExpression extends AbstractExpression {
 
   @Override
   public int queryBindHash() {
-    return value.hashCode();
+    return value().hashCode();
   }
 
   @Override
@@ -132,6 +129,6 @@ public class SimpleExpression extends AbstractExpression {
   @Override
   public boolean isSameByBind(SpiExpression other) {
     SimpleExpression that = (SimpleExpression) other;
-    return value.equals(that.value);
+    return value().equals(that.value());
   }
 }

src/main/java/com/avaje/ebeaninternal/server/grammer/EqlAdapter.java

@@ -0,0 +1,374 @@
+package com.avaje.ebeaninternal.server.grammer;
+
+import com.avaje.ebean.Expression;
+import com.avaje.ebean.ExpressionList;
+import com.avaje.ebean.FetchConfig;
+import com.avaje.ebean.LikeType;
+import com.avaje.ebean.OrderBy;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.grammer.antlr.EQLBaseListener;
+import com.avaje.ebeaninternal.server.grammer.antlr.EQLLexer;
+import com.avaje.ebeaninternal.server.grammer.antlr.EQLParser;
+import com.avaje.ebeaninternal.server.util.ArrayStack;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class EqlAdapter<T> extends EQLBaseListener {
+
+  private static final OperatorMapping operatorMapping = new OperatorMapping();
+
+  private static final String DISTINCT = "distinct";
+
+  private static final String NULLS = "nulls";
+
+  private static final String ASC = "asc";
+
+  private final SpiQuery<T> query;
+
+  private final EqlAdapterHelper helper;
+
+  private ArrayStack<ExpressionList<T>> textStack;
+
+  private ArrayStack<ExpressionList<T>> whereStack;
+
+  private boolean textMode;
+
+  private List<Object> inValues;
+
+  private String inPropertyName;
+
+  public EqlAdapter(SpiQuery<T> query) {
+    this.query = query;
+    this.helper = new EqlAdapterHelper(this);
+  }
+
+  /**
+   * Return the current expression list that expressions should be added to.
+   */
+  protected ExpressionList<T> peekExprList() {
+
+    if (textMode) {
+      // return the current text expression list
+      return _peekText();
+    }
+
+    if (whereStack == null) {
+      whereStack = new ArrayStack<ExpressionList<T>>();
+      whereStack.push(query.where());
+    }
+    // return the current expression list
+    return whereStack.peek();
+  }
+
+  private ExpressionList<T> _peekText() {
+    if (textStack == null) {
+      textStack = new ArrayStack<ExpressionList<T>>();
+      // empty so push on the queries base expression list
+      textStack.push(query.text());
+    }
+    // return the current expression list
+    return textStack.peek();
+  }
+
+  /**
+   * Push the expression list onto the appropriate stack.
+   */
+  private void pushExprList(ExpressionList<T> list) {
+    if (textMode) {
+      textStack.push(list);
+    } else {
+      whereStack.push(list);
+    }
+  }
+
+  /**
+   * End a list of expressions added by 'OR'.
+   */
+  private void popJunction() {
+    if (textMode) {
+      textStack.pop();
+    } else {
+      whereStack.pop();
+    }
+  }
+
+  @Override
+  public void enterSelect_clause(EQLParser.Select_clauseContext ctx) {
+
+    checkChildren(ctx, 4);
+    if (DISTINCT.equals(child(ctx, 1))) {
+      query.setDistinct(true);
+      query.select(child(ctx, 3));
+    } else {
+      query.select(child(ctx, 2));
+    }
+  }
+
+  @Override
+  public void enterFetch_path(EQLParser.Fetch_pathContext ctx) {
+
+    int childCount = ctx.getChildCount();
+    checkChildren(ctx, 2);
+    String path = child(ctx, 1);
+
+    int noPropertiesLength = 2;
+
+    FetchConfig fetchConfig = ParseFetchConfig.parse(path);
+    if (fetchConfig != null) {
+      noPropertiesLength = 3;
+      path = child(ctx, 2);
+    }
+    if (childCount == noPropertiesLength) {
+      query.fetch(path, fetchConfig);
+
+    } else {
+      String fetchProperties = trimParenthesis(ctx.getChild(noPropertiesLength).getText());
+      query.fetch(path, fetchProperties, fetchConfig);
+    }
+  }
+
+  @Override
+  public void enterOrderby_property(EQLParser.Orderby_propertyContext ctx) {
+
+    int childCount = ctx.getChildCount();
+
+    String path = child(ctx, 0);
+    boolean asc = true;
+    String nulls = null;
+    String nullsFirstLast = null;
+
+    if (childCount == 3) {
+      asc = child(ctx, 1).startsWith(ASC);
+      nullsFirstLast = ctx.getChild(2).getChild(1).getText();
+      nulls = NULLS;
+
+    } else if (childCount == 2) {
+      String firstChild = child(ctx, 1);
+      if (firstChild.startsWith(NULLS)) {
+        nullsFirstLast = ctx.getChild(1).getChild(1).getText();
+        nulls = NULLS;
+      } else {
+        asc = firstChild.startsWith(ASC);
+      }
+    }
+
+    query.orderBy().add(new OrderBy.Property(path, asc, nulls, nullsFirstLast));
+  }
+
+  @Override
+  public void enterLimit_clause(EQLParser.Limit_clauseContext ctx) {
+
+    try {
+      String limitValue = child(ctx, 1);
+      query.setMaxRows(Integer.parseInt(limitValue));
+
+      int childCount = ctx.getChildCount();
+      if (childCount == 3) {
+        ParseTree offsetTree = ctx.getChild(2);
+        String offsetValue = offsetTree.getChild(1).getText();
+        query.setFirstRow(Integer.parseInt(offsetValue));
+      }
+    } catch (NumberFormatException e) {
+      throw new IllegalArgumentException("Error parsing limit or offset parameter - not an integer", e);
+    }
+  }
+
+  /**
+   * Trim leading '(' and trailing ')'
+   */
+  private String trimParenthesis(String text) {
+    text = text.substring(1);
+    text = text.substring(0, text.length()-1);
+    return text;
+  }
+
+  private String getLeftHandSidePath(ParserRuleContext ctx) {
+    TerminalNode pathToken = ctx.getToken(EQLLexer.PATH_VARIABLE, 0);
+    return pathToken.getText();
+  }
+
+  @Override
+  public void enterBetween_expression(EQLParser.Between_expressionContext ctx) {
+
+    checkChildren(ctx, 5);
+    String path = getLeftHandSidePath(ctx);
+    EqlOperator op = getOperator(ctx);
+    if (op != EqlOperator.BETWEEN) {
+      throw new IllegalStateException("Expecting BETWEEN operator but got "+op);
+    }
+    helper.addBetween(path, child(ctx,2), child(ctx,4));
+  }
+
+  @Override
+  public void enterPropertyBetween_expression(EQLParser.PropertyBetween_expressionContext ctx) {
+    checkChildren(ctx, 5);
+    String rawValue = child(ctx,0);
+    EqlOperator op = getOperator(ctx);
+    if (op != EqlOperator.BETWEEN) {
+      throw new IllegalStateException("Expecting BETWEEN operator but got "+op);
+    }
+    helper.addBetweenProperty(rawValue, child(ctx,2), child(ctx,4));
+  }
+
+  @Override
+  public void enterIn_expression(EQLParser.In_expressionContext ctx) {
+    this.inValues = new ArrayList<Object>();
+    this.inPropertyName = getLeftHandSidePath(ctx);
+  }
+
+  @Override
+  public void enterIn_value(EQLParser.In_valueContext ctx) {
+    int childCount = ctx.getChildCount();
+    for (int i = 0; i < childCount; i++) {
+      String text = child(ctx, i);
+      if (isValue(text)) {
+        inValues.add(helper.bind(text));
+      }
+    }
+  }
+
+  private String child(ParserRuleContext ctx, int position) {
+    ParseTree child = ctx.getChild(position);
+    return child.getText();
+  }
+
+  private boolean isValue(String text) {
+    if (text.length() == 1 && (text.equals("(") || text.equals(")") || text.equals(","))) {
+      return false;
+    }
+    return true;
+  }
+
+  @Override
+  public void exitIn_expression(EQLParser.In_expressionContext ctx) {
+    helper.addIn(inPropertyName, inValues);
+  }
+
+  @Override
+  public void enterIsNull_expression(EQLParser.IsNull_expressionContext ctx) {
+    String path = getLeftHandSidePath(ctx);
+    peekExprList().isNull(path);
+  }
+
+  @Override
+  public void enterIsNotNull_expression(EQLParser.IsNotNull_expressionContext ctx) {
+    String path = getLeftHandSidePath(ctx);
+    peekExprList().isNotNull(path);
+  }
+
+  @Override
+  public void enterIsEmpty_expression(EQLParser.IsEmpty_expressionContext ctx) {
+    String path = getLeftHandSidePath(ctx);
+    peekExprList().isEmpty(path);
+  }
+
+  @Override
+  public void enterIsNotEmpty_expression(EQLParser.IsNotEmpty_expressionContext ctx) {
+    String path = getLeftHandSidePath(ctx);
+    peekExprList().isNotEmpty(path);
+  }
+
+  @Override
+  public void enterLike_expression(EQLParser.Like_expressionContext ctx) {
+    addExpression(ctx);
+  }
+
+  @Override
+  public void enterComparison_expression(EQLParser.Comparison_expressionContext ctx) {
+    addExpression(ctx);
+  }
+
+  private void addExpression(ParserRuleContext ctx) {
+    int childCount = ctx.getChildCount();
+    if (childCount < 3) {
+      throw new IllegalStateException("expecting 3 children for comparison? " + ctx);
+    }
+    String path = getLeftHandSidePath(ctx);
+    String operator = child(ctx, 1);
+    EqlOperator op = operatorMapping.get(operator);
+    if (op == null) {
+      throw new IllegalStateException("No operator found for " + operator);
+    }
+
+    // RHS is Path, Literal or Named input parameter
+    helper.addExpression(path, op, child(ctx, 2));
+  }
+
+
+  @Override
+  public void enterConditional_term(EQLParser.Conditional_termContext ctx) {
+    int childCount = ctx.getChildCount();
+    if (childCount > 1) {
+      pushExprList(peekExprList().and());
+    }
+  }
+
+  @Override
+  public void exitConditional_term(EQLParser.Conditional_termContext ctx) {
+    if (ctx.getChildCount() > 1) {
+      popJunction();
+    }
+  }
+
+  @Override
+  public void enterConditional_expression(EQLParser.Conditional_expressionContext ctx) {
+    if (ctx.getChildCount() > 1) {
+      pushExprList(peekExprList().or());
+    }
+  }
+
+  @Override
+  public void exitConditional_expression(EQLParser.Conditional_expressionContext ctx) {
+    if (ctx.getChildCount() > 1) {
+      popJunction();
+    }
+  }
+
+  @Override
+  public void enterConditional_factor(EQLParser.Conditional_factorContext ctx) {
+    if (ctx.getChildCount() > 1) {
+      pushExprList(peekExprList().not());
+    }
+  }
+
+  @Override
+  public void exitConditional_factor(EQLParser.Conditional_factorContext ctx) {
+    if (ctx.getChildCount() > 1) {
+      popJunction();
+    }
+  }
+
+  private EqlOperator getOperator(ParserRuleContext ctx) {
+    String operator = child(ctx,1);
+    EqlOperator op = operatorMapping.get(operator);
+    if (op == null) {
+      throw new IllegalStateException("No operator found for " + operator);
+    }
+    return op;
+  }
+
+  /**
+   * Check for the minimum number of children.
+   */
+  private void checkChildren(ParserRuleContext ctx, int min) {
+    if (ctx.getChildCount() < min) {
+      throw new IllegalStateException("expecting " + min + " children for comparison? " + ctx);
+    }
+  }
+
+  public Object namedParam(String parameterName) {
+    return query.createNamedParameter(parameterName);
+  }
+
+  public Expression like(boolean caseInsensitive, LikeType likeType, String property, Object bindValue) {
+    return query.getExpressionFactory().like(property, bindValue, caseInsensitive, likeType);
+  }
+
+  public Expression ieq(String property, Object bindValue) {
+    return query.getExpressionFactory().ieqObject(property, bindValue);
+  }
+}

src/main/java/com/avaje/ebeaninternal/server/grammer/EqlAdapterHelper.java

@@ -0,0 +1,140 @@
+package com.avaje.ebeaninternal.server.grammer;
+
+import com.avaje.ebean.ExpressionList;
+import com.avaje.ebean.LikeType;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+class EqlAdapterHelper {
+
+  private final EqlAdapter owner;
+
+  public EqlAdapterHelper(EqlAdapter owner) {
+    this.owner = owner;
+  }
+
+  enum ValueType {
+    NAMED_PARAM,
+    STRING,
+    BOOL,
+    NUMBER
+  }
+
+  private ValueType getValueType(String valueAsText) {
+
+    char firstChar = Character.toLowerCase(valueAsText.charAt(0));
+    switch (firstChar) {
+      case ':':
+        return ValueType.NAMED_PARAM;
+      case 't':
+        return ValueType.BOOL;
+      case 'f':
+        return ValueType.BOOL;
+      case '\'':
+        return ValueType.STRING;
+      default:
+        if (Character.isDigit(firstChar)) {
+          return ValueType.NUMBER;
+        }
+        throw new IllegalArgumentException("Unexpected first character in value [" + valueAsText + "]");
+    }
+  }
+
+  protected void addBetweenProperty(String rawValue, String lowProperty, String highProperty) {
+    peekExprList().betweenProperties(lowProperty, highProperty, bind(rawValue));
+  }
+
+  protected void addBetween(String path, String value1, String value2) {
+    peekExprList().between(path, bind(value1), bind(value2));
+  }
+
+  @SuppressWarnings("unchecked")
+  protected void addIn(String path, List<Object> inValues) {
+    peekExprList().in(path, inValues);
+  }
+
+  protected void addExpression(String path, EqlOperator op, String value) {
+
+    switch (op) {
+      case EQ:
+        peekExprList().eq(path, bind(value));
+        break;
+      case IEQ:
+        peekExprList().add(owner.ieq(path, bind(value)));
+        break;
+      case NE:
+        peekExprList().ne(path, bind(value));
+        break;
+      case GT:
+        peekExprList().gt(path, bind(value));
+        break;
+      case LT:
+        peekExprList().lt(path, bind(value));
+        break;
+      case GTE:
+        peekExprList().ge(path, bind(value));
+        break;
+      case LTE:
+        peekExprList().le(path, bind(value));
+        break;
+      case LIKE:
+        addLike(false, LikeType.RAW, path, bind(value));
+        break;
+      case CONTAINS:
+        addLike(false, LikeType.CONTAINS, path, bind(value));
+        break;
+      case STARTS_WITH:
+        addLike(false, LikeType.STARTS_WITH, path, bind(value));
+        break;
+      case ENDS_WITH:
+        addLike(false, LikeType.ENDS_WITH, path, bind(value));
+        break;
+      case ILIKE:
+        addLike(true, LikeType.RAW, path, bind(value));
+        break;
+      case ICONTAINS:
+        addLike(true, LikeType.CONTAINS, path, bind(value));
+        break;
+      case ISTARTS_WITH:
+        addLike(true, LikeType.STARTS_WITH, path, bind(value));
+        break;
+      case IENDS_WITH:
+        addLike(true, LikeType.ENDS_WITH, path, bind(value));
+        break;
+      default:
+        throw new IllegalStateException("Unhandled operator " + op);
+    }
+
+  }
+
+  private void addLike(boolean caseInsensitive, LikeType likeType, String path, Object bindValue) {
+    peekExprList().add(owner.like(caseInsensitive, likeType, path, bindValue));
+  }
+
+  protected Object bind(String value) {
+    ValueType valueType = getValueType(value);
+    return getBindValue(valueType, value);
+  }
+
+  private ExpressionList peekExprList() {
+    return owner.peekExprList();
+  }
+
+  private Object getBindValue(ValueType valueType, String value) {
+    switch (valueType) {
+      case BOOL: return Boolean.parseBoolean(value);
+      case NUMBER: return new BigDecimal(value);
+      case STRING: return unquote(value);
+      case NAMED_PARAM: return owner.namedParam(value.substring(1));
+      default:
+        throw new IllegalArgumentException("Unhandled valueType "+valueType);
+    }
+  }
+
+  private String unquote(String value) {
+    String raw = value.substring(1, value.length() - 1);
+    //raw.replaceAll();
+    return raw;
+  }
+}