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

review duplicate var

pom.xml

@@ -3,13 +3,13 @@
 
   <parent>
     <groupId>org.avaje</groupId>
-    <artifactId>avaje-javaparent</artifactId>
-    <version>1.2</version>
+    <artifactId>oss-parent</artifactId>
+    <version>1.1</version>
   </parent>
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>6.17.2</version>
+  <version>7.8.1</version>
   <packaging>jar</packaging>
 
   <name>avaje-ebeanorm</name>
@@ -36,9 +36,8 @@
   </developers>
 
   <scm>
-    <connection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm.git</connection>
     <developerConnection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm.git</developerConnection>
-    <url>https://github.com/ebean-orm/avaje-ebeanorm.git</url>
+    <tag>avaje-ebeanorm-7.8.1</tag>
   </scm>
 
   <dependencies>
@@ -55,33 +54,49 @@
       <version>1.0</version>
     </dependency>
 
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-datasource-api</artifactId>
+      <version>1.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-datasource</artifactId>
+      <version>1.1.3</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-classpath-scanner-api</artifactId>
+      <version>2.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-classpath-scanner</artifactId>
+      <version>2.1.1</version>
+    </dependency>
+
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
-      <version>1.7.7</version>
-    </dependency>
-
-    <!-- provided scope for Spring boot loader classpath scanning support -->
-    <dependency>
-      <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-loader</artifactId>
-      <version>1.2.7.RELEASE</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <!-- provided scope for JsonNode support -->
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-databind</artifactId>
-      <version>2.5.3</version>
-      <scope>provided</scope>
+      <version>[1.7.1,1.7.99)</version>
     </dependency>
 
     <!-- Jackson core used internally by Ebean -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
-      <version>2.5.3</version>
+      <version>2.6.5</version>
+    </dependency>
+
+    <!-- provided scope for JsonNode support -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.6.5</version>
+      <scope>provided</scope>
     </dependency>
 
     <dependency>
@@ -121,6 +136,8 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- Test scope -->
+
     <!--<dependency>-->
       <!--<groupId>oracle</groupId>-->
       <!--<artifactId>oracle-jdbc</artifactId>-->
@@ -135,13 +152,6 @@
       <!--<scope>test</scope>-->
     <!--</dependency>-->
 
-    <dependency>
-      <groupId>com.squareup.okhttp</groupId>
-      <artifactId>okhttp</artifactId>
-      <version>2.1.0</version>
-      <scope>test</scope>
-    </dependency>
-
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-agentloader</artifactId>
@@ -152,7 +162,7 @@
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.9.1</version>
+      <version>4.9.2</version>
       <scope>test</scope>
     </dependency>
 
@@ -168,7 +178,7 @@
     <dependency>
       <groupId>org.xerial</groupId>
       <artifactId>sqlite-jdbc</artifactId>
-      <version>3.7.2</version>
+      <version>3.8.11.2</version>
       <scope>test</scope>
     </dependency>
 
@@ -204,9 +214,9 @@
   </dependencies>
 
 
-  <!-- Enhance the meta beans -->
   <build>
     <plugins>
+
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
@@ -216,12 +226,12 @@
           <target>1.6</target>
         </configuration>
       </plugin>
+
       <plugin>
         <groupId>org.avaje.ebeanorm</groupId>
         <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.9.1</version>
+        <version>4.9.2</version>
         <executions>
-          <!--   Not going to enhance Model bean -->
           <execution>
             <id>test</id>
             <phase>process-test-classes</phase>
@@ -258,7 +268,8 @@
           </systemProperties>
         </configuration>
       </plugin>
- 	 <plugin>
+
+      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-jar-plugin</artifactId>
         <version>2.5</version>
@@ -268,12 +279,13 @@
           </archive>
         </configuration>
       </plugin>
+
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>2.9.1</version>
         <configuration>
-          <doctitle>Ebean 6</doctitle>
+          <doctitle>Ebean 7</doctitle>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
@@ -292,9 +304,7 @@
           </additionalparam>
           <linksource>true</linksource>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
-
         </configuration>
-
         <executions>
           <execution>
             <id>attach-javadocs</id>
@@ -304,6 +314,7 @@
           </execution>
         </executions>
       </plugin>
+
     </plugins>
 
   </build>

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

@@ -71,7 +71,7 @@ class DRawSqlParser {
 
     preFrom = trimSelectKeyword(preFrom);
 
-    return new Sql(sql.hashCode(), preFrom, preWhere, whereExprAnd, preHaving, havingExprAnd, orderByPrefix, orderBySql, (distinctPos > -1));
+    return new Sql(sql, preFrom, preWhere, whereExprAnd, preHaving, havingExprAnd, orderByPrefix, orderBySql, (distinctPos > -1));
   }
 
   /**

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

@@ -0,0 +1,94 @@
+package com.avaje.ebean;
+
+/**
+ * Bean holding the details to update the document store.
+ */
+public final class DocStoreQueueEntry {
+
+  /**
+   * Action to either update or delete a document from the index.
+   */
+  public enum Action {
+
+    /**
+     * Action is to update a document in the doc store.
+     */
+    INDEX(1),
+
+    /**
+     * Action is to delete a document from the doc store..
+     */
+    DELETE(2),
+
+    /**
+     * An update is required based on a change to a nested/embedded object at a given path.
+     */
+    NESTED(3);
+
+    int value;
+
+    Action(int value) {
+      this.value = value;
+    }
+
+    /**
+     * Return the value associated with this action type.
+     */
+    public int getValue() {
+      return value;
+    }
+  }
+
+  final Action type;
+
+  final String queueId;
+
+  final String path;
+
+  final Object beanId;
+
+  /**
+   * Construct for an INDEX or DELETE action.
+   */
+  public DocStoreQueueEntry(Action type, String queueId, Object beanId) {
+    this(type, queueId, null, beanId);
+  }
+
+  /**
+   * Construct for an NESTED/embedded path invalidation action.
+   */
+  public DocStoreQueueEntry(Action type, String queueId, String path, Object beanId) {
+    this.type = type;
+    this.queueId = queueId;
+    this.path = path;
+    this.beanId = beanId;
+  }
+
+  /**
+   * Return the event type.
+   */
+  public Action getType() {
+    return type;
+  }
+
+  /**
+   * Return the associate queueId.
+   */
+  public String getQueueId() {
+    return queueId;
+  }
+
+  /**
+   * Return the path if this is a nested update.
+   */
+  public String getPath() {
+    return path;
+  }
+
+  /**
+   * Return the bean id (which matches the document id).
+   */
+  public Object getBeanId() {
+    return beanId;
+  }
+}

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

@@ -0,0 +1,270 @@
+package com.avaje.ebean;
+
+import com.avaje.ebeanservice.docstore.api.DocQueryRequest;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Document storage operations.
+ */
+public interface DocumentStore {
+
+  /**
+   * Update the associated document store using the result of the query.
+   * <p>
+   * This will execute the query against the database creating a document for each
+   * bean graph and sending this to the document store.
+   * </p>
+   * <p>
+   * Note that the select and fetch paths of the query is set for you to match the
+   * document structure needed based on <code>@DocStore</code> and <code>@DocStoreEmbedded</code>
+   * so what this query requires is the predicates only.
+   * </p>
+   * <p>
+   * This query will be executed using findEach so it is safe to use a query
+   * that will fetch a lot of beans. The default bulkBatchSize is used.
+   * </p>
+   *
+   * @param query The query that selects object to send to the document store.
+   */
+  <T> void indexByQuery(Query<T> query);
+
+  /**
+   * Update the associated document store index using the result of the query additionally specifying a
+   * bulkBatchSize to use for sending the messages to ElasticSearch.
+   *
+   * @param query         The query that selects object to send to the document store.
+   * @param bulkBatchSize The batch size to use when bulk sending to the document store.
+   */
+  <T> void indexByQuery(Query<T> query, int bulkBatchSize);
+
+  /**
+   * Update the document store for all beans of this type.
+   * <p>
+   * This is the same as indexByQuery where the query has no predicates and so fetches all rows.
+   * </p>
+   */
+  void indexAll(Class<?> beanType);
+
+  /**
+   * Return the bean by fetching it's content from the document store.
+   * If the document is not found null is returned.
+   * <p>
+   * Typically this is called indirectly by findUnique() on the query.
+   * </p>
+   * <pre>{@code
+   *
+   * Customer customer =
+   *   server.find(Customer.class)
+   *     .setUseDocStore(true)
+   *     .setId(42)
+   *     .findUnique();
+   *
+   * }</pre>
+   */
+  @Nullable
+  <T> T find(DocQueryRequest<T> request);
+
+  /**
+   * Execute the find list query. This request is prepared to execute secondary queries.
+   * <p>
+   * Typically this is called indirectly by findList() on the query that has setUseDocStore(true).
+   * </p>
+   * <pre>{@code
+   *
+   * List<Customer> newCustomers =
+   *  server.find(Customer.class)
+   *    .setUseDocStore(true)
+   *    .where().eq("status, Customer.Status.NEW)
+   *    .findList();
+   *
+   * }</pre>
+   */
+  <T> List<T> findList(DocQueryRequest<T> request);
+
+  /**
+   * Execute the query against the document store returning the paged list.
+   * <p>
+   * The query should have <code>firstRow</code> or <code>maxRows</code> set prior to calling this method.
+   * </p>
+   * <p>
+   * Typically this is called indirectly by findPagedList() on the query that has setUseDocStore(true).
+   * </p>
+   *
+   * <pre>{@code
+   *
+   * PagedList<Customer> newCustomers =
+   *  server.find(Customer.class)
+   *    .setUseDocStore(true)
+   *    .where().eq("status, Customer.Status.NEW)
+   *    .setMaxRows(50)
+   *    .findPagedList();
+   *
+   * }</pre>
+   *
+   */
+  <T> PagedList<T> findPagedList(DocQueryRequest<T> request);
+
+  /**
+   * Execute the query against the document store with the expectation of a large set of results
+   * that are processed in a scrolling resultSet fashion.
+   * <p>
+   * For example, with the ElasticSearch doc store this uses SCROLL.
+   * </p>
+   * <p>
+   * Typically this is called indirectly by findEach() on the query that has setUseDocStore(true).
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  server.find(Order.class)
+   *    .setUseDocStore(true)
+   *    .where()... // perhaps add predicates
+   *    .findEach(new QueryEachConsumer<Order>() {
+   *      @Override
+   *      public void accept(Order bean) {
+   *        // process the bean
+   *      }
+   *    });
+   *
+   * }</pre>
+   */
+  <T> void findEach(DocQueryRequest<T> query, QueryEachConsumer<T> consumer);
+
+  /**
+   * Execute the query against the document store with the expectation of a large set of results
+   * that are processed in a scrolling resultSet fashion.
+   * <p>
+   * Unlike findEach() this provides the opportunity to stop iterating through the large query.
+   * </p>
+   * <p>
+   * For example, with the ElasticSearch doc store this uses SCROLL.
+   * </p>
+   * <p>
+   * Typically this is called indirectly by findEachWhile() on the query that has setUseDocStore(true).
+   * </p>
+   *
+   *
+   * <pre>{@code
+   *
+   *  server.find(Order.class)
+   *    .setUseDocStore(true)
+   *    .where()... // perhaps add predicates
+   *    .findEachWhile(new QueryEachWhileConsumer<Order>() {
+   *      @Override
+   *      public void accept(Order bean) {
+   *        // process the bean
+   *
+   *        // return true to continue, false to stop
+   *        // boolean shouldContinue = ...
+   *        return shouldContinue;
+   *      }
+   *    });
+   *
+   * }</pre>
+   */
+  <T> void findEachWhile(DocQueryRequest<T> query, QueryEachWhileConsumer<T> consumer);
+
+  /**
+   * Process the queue entries sending updates to the document store or queuing them for later processing.
+   */
+  long process(List<DocStoreQueueEntry> queueEntries) throws IOException;
+
+  /**
+   * Drop the index from the document store (similar to DDL drop table).
+   *
+   * <pre>{@code
+   *
+   *   DocumentStore documentStore = server.docStore();
+   *
+   *   documentStore.dropIndex("product_copy");
+   *
+   * }</pre>
+   *
+   */
+  void dropIndex(String indexName);
+
+  /**
+   * Create an index given a mapping file as a resource in the classPath (similar to DDL create table).
+   *
+   * <pre>{@code
+   *
+   *   DocumentStore documentStore = server.docStore();
+   *
+   *   // uses product_copy.mapping.json resource
+   *   // ... to define mappings for the index
+   *
+   *   documentStore.createIndex("product_copy", null);
+   *
+   * }</pre>
+   *
+   * @param indexName       the name of the new index
+   * @param alias           the alias of the index
+   */
+  void createIndex(String indexName, String alias);
+
+  /**
+   * Copy the index to a new index.
+   * <p>
+   * This copy process does not use the database but instead will copy from the source index to a destination index.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  long copyCount = documentStore.copyIndex(Product.class, "product_copy");
+   *
+   * }</pre>
+   *
+   * @param beanType The bean type of the source index
+   * @param newIndex The name of the index to copy to
+   * @return the number of documents copied to the new index
+   */
+  long copyIndex(Class<?> beanType, String newIndex);
+
+  /**
+   * Copy entries from an index to a new index but limiting to documents that have been
+   * modified since the sinceEpochMillis time.
+   * <p>
+   * To support this the document needs to have a <code>@WhenModified</code> property.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  long copyCount = documentStore.copyIndex(Product.class, "product_copy", sinceMillis);
+   *
+   * }</pre>
+   *
+   * @param beanType The bean type of the source index
+   * @param newIndex The name of the index to copy to
+   * @return the number of documents copied to the new index
+   */
+  long copyIndex(Class<?> beanType, String newIndex, long sinceEpochMillis);
+
+  /**
+   * Copy from a source index to a new index taking only the documents
+   * matching the given query.
+   *
+   * <pre>{@code
+   *
+   *  // predicates to select the source documents to copy
+   *  Query<Product> query = server.find(Product.class)
+   *    .where()
+   *      .ge("whenModified", new Timestamp(since))
+   *      .ge("name", "A")
+   *      .lt("name", "D")
+   *      .query();
+   *
+   *  // copy from the source index to "product_copy" index
+   *  long copyCount = documentStore.copyIndex(query, "product_copy", 1000);
+   *
+   * }</pre>
+   *
+   * @param query         The query to select the source documents to copy
+   * @param newIndex      The target index to copy the documents to
+   * @param bulkBatchSize The ElasticSearch bulk batch size, if 0 uses the default.
+   * @return The number of documents copied to the new index.
+   */
+  long copyIndex(Query<?> query, String newIndex, int bulkBatchSize);
+}

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

@@ -1,24 +1,21 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.cache.ServerCacheManager;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.text.csv.CsvReader;
+import com.avaje.ebean.text.json.JsonContext;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.persistence.OptimisticLockException;
+import javax.persistence.PersistenceException;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-import javax.persistence.OptimisticLockException;
-import javax.persistence.PersistenceException;
-
-import org.jetbrains.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.avaje.ebean.annotation.CacheStrategy;
-import com.avaje.ebean.cache.ServerCacheManager;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.text.csv.CsvReader;
-import com.avaje.ebean.text.json.JsonContext;
-
 /**
  * This Ebean object is effectively a singleton that holds a map of registered
  * {@link EbeanServer}s. It additionally provides a convenient way to use the
@@ -731,11 +728,25 @@ public final class Ebean {
     return serverMgr.getDefaultServer().delete(beanType, id);
   }
 
+  /**
+   * Delete permanent the bean given its type and id.
+   */
+  public static int deletePermanent(Class<?> beanType, Object id) {
+    return serverMgr.getDefaultServer().deletePermanent(beanType, id);
+  }
+
   /**
    * Delete several beans given their type and id values.
    */
-  public static void deleteAll(Class<?> beanType, Collection<?> ids) {
-    serverMgr.getDefaultServer().deleteAll(beanType, ids);
+  public static int deleteAll(Class<?> beanType, Collection<?> ids) {
+    return serverMgr.getDefaultServer().deleteAll(beanType, ids);
+  }
+
+  /**
+   * Delete permanent several beans given their type and id values.
+   */
+  public static int deleteAllPermanent(Class<?> beanType, Collection<?> ids) {
+    return serverMgr.getDefaultServer().deleteAllPermanent(beanType, ids);
   }
 
   /**
@@ -1484,29 +1495,6 @@ public final class Ebean {
     return serverMgr.getDefaultServer().getBackgroundExecutor();
   }
 
-  /**
-   * Run the cache warming queries on all bean types that have one defined for
-   * the default/primary EbeanServer.
-   * <p>
-   * A cache warming query can be defined via {@link CacheStrategy}.
-   * </p>
-   */
-  public static void runCacheWarming() {
-    serverMgr.getDefaultServer().runCacheWarming();
-  }
-
-  /**
-   * Run the cache warming query for a specific bean type for the
-   * default/primary EbeanServer.
-   * <p>
-   * A cache warming query can be defined via {@link CacheStrategy}.
-   * </p>
-   */
-  public static void runCacheWarming(Class<?> beanType) {
-
-    serverMgr.getDefaultServer().runCacheWarming(beanType);
-  }
-
   /**
    * Return the JsonContext for reading/writing JSON.
    */

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

@@ -1,6 +1,5 @@
 package com.avaje.ebean;
 
-import com.avaje.ebean.annotation.CacheStrategy;
 import com.avaje.ebean.cache.ServerCacheManager;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.meta.MetaInfoManager;
@@ -146,6 +145,17 @@ public interface EbeanServer {
    */
   Object getBeanId(Object bean);
 
+  /**
+   * Set the Id value onto the bean converting the type of the id value if necessary.
+   * <p>
+   * For example, if the id value passed in is a String but ought to be a Long or UUID etc
+   * then it will automatically be converted.
+   * </p>
+   *  @param bean The entity bean to set the id value on.
+   * @param id   The id value to set.
+   */
+  Object setBeanId(Object bean, Object id);
+
   /**
    * Return a map of the differences between two objects of the same type.
    * <p>
@@ -1340,6 +1350,16 @@ public interface EbeanServer {
    */
   int delete(Class<?> beanType, Object id, Transaction transaction);
 
+  /**
+   * Delete permanent given the bean type and id.
+   */
+  int deletePermanent(Class<?> beanType, Object id);
+
+  /**
+   * Delete permanent given the bean type and id with an explicit transaction.
+   */
+  int deletePermanent(Class<?> beanType, Object id, Transaction transaction);
+
   /**
    * Delete all the beans in the collection.
    */
@@ -1353,13 +1373,22 @@ public interface EbeanServer {
   /**
    * Delete several beans given their type and id values.
    */
-  void deleteAll(Class<?> beanType, Collection<?> ids);
+  int deleteAll(Class<?> beanType, Collection<?> ids);
 
   /**
-   * Delete several beans given their type and id values with an explicit
-   * transaction.
+   * Delete several beans given their type and id values with an explicit transaction.
    */
-  void deleteAll(Class<?> beanType, Collection<?> ids, Transaction transaction);
+  int deleteAll(Class<?> beanType, Collection<?> ids, Transaction transaction);
+
+  /**
+   * Delete permanent for several beans given their type and id values.
+   */
+  int deleteAllPermanent(Class<?> beanType, Collection<?> ids);
+
+  /**
+   * Delete permanent for several beans given their type and id values with an explicit transaction.
+   */
+  int deleteAllPermanent(Class<?> beanType, Collection<?> ids, Transaction transaction);
 
   /**
    * Execute a Sql Update Delete or Insert statement. This returns the number of
@@ -1835,22 +1864,6 @@ public interface EbeanServer {
    */
   BackgroundExecutor getBackgroundExecutor();
 
-  /**
-   * Run the cache warming queries on all bean types that have one defined.
-   * <p>
-   * A cache warming query can be defined via {@link CacheStrategy}.
-   * </p>
-   */
-  void runCacheWarming();
-
-  /**
-   * Run the cache warming query for a specific bean type.
-   * <p>
-   * A cache warming query can be defined via {@link CacheStrategy}.
-   * </p>
-   */
-  void runCacheWarming(Class<?> beanType);
-
   /**
    * Return the JsonContext for reading/writing JSON.
    * <p>
@@ -1886,11 +1899,16 @@ public interface EbeanServer {
    *
    * }</pre>
    *
-   * @see com.avaje.ebean.text.PathProperties
-   * @see Query#apply(com.avaje.ebean.text.PathProperties)
+   * @see FetchPath
+   * @see Query#apply(FetchPath)
    */
   JsonContext json();
 
+  /**
+   * Return the Document store.
+   */
+  DocumentStore docStore();
+
   /**
    * Publish a single bean given its type and id returning the resulting live bean.
    * <p>

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

@@ -133,7 +133,7 @@ public class EbeanServerFactory {
   /**
    * Create the container instance using the configuration.
    */
-  private static SpiContainer createContainer(ContainerConfig containerConfig) {
+  protected static SpiContainer createContainer(ContainerConfig containerConfig) {
 
     String implClassName = System.getProperty("ebean.container", DEFAULT_CONTAINER);
 

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

@@ -209,6 +209,20 @@ public class Expr {
     return Ebean.getExpressionFactory().icontains(propertyName, value);
   }
 
+  /**
+   * For collection properties that are empty (have not existing elements).
+   */
+  public static Expression isEmpty(String propertyName) {
+    return Ebean.getExpressionFactory().isEmpty(propertyName);
+  }
+
+  /**
+   * For collection properties that are not empty (have existing elements).
+   */
+  public static Expression isNotEmpty(String propertyName) {
+    return Ebean.getExpressionFactory().isNotEmpty(propertyName);
+  }
+
   /**
    * In - property has a value in the array of values.
    */

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

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

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

@@ -1,5 +1,11 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.search.Match;
+import com.avaje.ebean.search.MultiMatch;
+import com.avaje.ebean.search.TextCommonTerms;
+import com.avaje.ebean.search.TextQueryString;
+import com.avaje.ebean.search.TextSimple;
+
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -240,11 +246,26 @@ public interface ExpressionFactory {
    */
   Expression notExists(Query<?> subQuery);
 
+  /**
+   * Is empty expression for collection properties.
+   */
+  Expression isEmpty(String propertyName);
+
+  /**
+   * Is not empty expression for collection properties.
+   */
+  Expression isNotEmpty(String propertyName);
+
   /**
    * Id Equal to - ID property is equal to the value.
    */
   Expression idEq(Object value);
 
+  /**
+   * Id IN a list of Id values.
+   */
+  Expression idIn(Object... idValues);
+
   /**
    * Id IN a list of Id values.
    */
@@ -285,6 +306,31 @@ public interface ExpressionFactory {
    */
   Expression raw(String raw);
 
+  /**
+   * Create a Text Match expression (currently doc store/Elastic only).
+   */
+  Expression textMatch(String propertyName, String search, Match options);
+
+  /**
+   * Create a Text Multi match expression (currently doc store/Elastic only).
+   */
+  Expression textMultiMatch(String query, MultiMatch options);
+
+  /**
+   * Create a text simple query expression (currently doc store/Elastic only).
+   */
+  Expression textSimple(String search, TextSimple options);
+
+  /**
+   * Create a text query string expression (currently doc store/Elastic only).
+   */
+  Expression textQueryString(String search, TextQueryString options);
+
+  /**
+   * Create a text common terms expression (currently doc store/Elastic only).
+   */
+  Expression textCommonTerms(String search, TextCommonTerms options);
+
   /**
    * And - join two expressions with a logical and.
    */
@@ -319,4 +365,13 @@ public interface ExpressionFactory {
    * Return a list of expressions that will be joined by OR's.
    */
   <T> Junction<T> disjunction(Query<T> query, ExpressionList<T> parent);
+
+  /**
+   * Return a Text query junction for MUST, SHOULD or MUST NOT.
+   * <p>
+   * This is doc store Elastic only.
+   * </p>
+   */
+  <T> Junction<T> junction(Junction.Type type, Query<T> query, ExpressionList<T> parent);
+
 }

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

@@ -1,10 +1,13 @@
 package com.avaje.ebean;
 
-import com.avaje.ebean.text.PathProperties;
+import com.avaje.ebean.search.Match;
+import com.avaje.ebean.search.MultiMatch;
+import com.avaje.ebean.search.TextCommonTerms;
+import com.avaje.ebean.search.TextQueryString;
+import com.avaje.ebean.search.TextSimple;
 import org.jetbrains.annotations.Nullable;
 
 import javax.persistence.NonUniqueResultException;
-import java.io.Serializable;
 import java.sql.Timestamp;
 import java.util.Collection;
 import java.util.List;
@@ -31,7 +34,7 @@ import java.util.Set;
  * 
  * @see Query#where()
  */
-public interface ExpressionList<T> extends Serializable {
+public interface ExpressionList<T> {
 
   /**
    * Return the query that owns this expression list.
@@ -95,7 +98,7 @@ public interface ExpressionList<T> extends Serializable {
   /**
    * Apply the path properties to the query replacing the select and fetch clauses.
    */
-  Query<T> apply(PathProperties pathProperties);
+  Query<T> apply(FetchPath fetchPath);
 
   /**
    * Perform an 'As of' query using history tables to return the object graph
@@ -113,10 +116,16 @@ public interface ExpressionList<T> extends Serializable {
    */
   Query<T> asDraft();
 
+  /**
+   * Deprecated in favour of setIncludeSoftDeletes().
+   */
+  @Deprecated
+  Query<T> includeSoftDeletes();
+
   /**
    * Execute the query including soft deleted rows.
    */
-  Query<T> includeSoftDeletes();
+  Query<T> setIncludeSoftDeletes();
 
   /**
    * Execute as a delete query deleting the 'root level' beans that match the predicates
@@ -381,6 +390,32 @@ public interface ExpressionList<T> extends Serializable {
    */
   Query<T> setUseQueryCache(boolean useCache);
 
+  /**
+   * Set to true if this query should execute against the doc store.
+   * <p>
+   * When setting this you may also consider disabling lazy loading.
+   * </p>
+   */
+  Query<T> setUseDocStore(boolean useDocsStore);
+
+  /**
+   * Set true if you want to disable lazy loading.
+   * <p>
+   * That is, once the object graph is returned further lazy loading is disabled.
+   * </p>
+   */
+  Query<T> setDisableLazyLoading(boolean disableLazyLoading);
+
+  /**
+   * Disable read auditing for this query.
+   * <p>
+   * This is intended to be used when the query is not a user initiated query and instead
+   * part of the internal processing in an application to load a cache or document store etc.
+   * In these cases we don't want the query to be part of read auditing.
+   * </p>
+   */
+  Query<T> setDisableReadAuditing();
+
   /**
    * Add expressions to the having clause.
    * <p>
@@ -719,6 +754,16 @@ public interface ExpressionList<T> extends Serializable {
    */
   ExpressionList<T> notIn(String propertyName, Query<?> subQuery);
 
+  /**
+   * Is empty expression for collection properties.
+   */
+  ExpressionList<T> isEmpty(String propertyName);
+
+  /**
+   * Is not empty expression for collection properties.
+   */
+  ExpressionList<T> isNotEmpty(String propertyName);
+
   /**
    * Exists expression
    */
@@ -729,6 +774,11 @@ public interface ExpressionList<T> extends Serializable {
    */
   ExpressionList<T> notExists(Query<?> subQuery);
 
+  /**
+   * Id IN a list of id values.
+   */
+  ExpressionList<T> idIn(Object... idValues);
+
   /**
    * Id IN a list of id values.
    */
@@ -803,6 +853,47 @@ public interface ExpressionList<T> extends Serializable {
    */
   ExpressionList<T> raw(String raw);
 
+  /**
+   * Add a match expression.
+   *
+   * @param propertyName The property name for the match
+   * @param search The search value
+   */
+  ExpressionList<T> match(String propertyName, String search);
+
+  /**
+   * Add a match expression with options.
+   *
+   * @param propertyName The property name for the match
+   * @param search The search value
+   */
+  ExpressionList<T> match(String propertyName, String search, Match options);
+
+  /**
+   * Add a multi-match expression.
+   */
+  ExpressionList<T>  multiMatch(String search, String... properties);
+
+  /**
+   * Add a multi-match expression using options.
+   */
+  ExpressionList<T> multiMatch(String search, MultiMatch options);
+
+  /**
+   * Add a simple query string expression.
+   */
+  ExpressionList<T> textSimple(String search, TextSimple options);
+
+  /**
+   * Add a query string expression.
+   */
+  ExpressionList<T> textQueryString(String search, TextQueryString options);
+
+  /**
+   * Add common terms expression.
+   */
+  ExpressionList<T> textCommonTerms(String search, TextCommonTerms options);
+
   /**
    * And - join two expressions with a logical and.
    */
@@ -819,20 +910,168 @@ public interface ExpressionList<T> extends Serializable {
   ExpressionList<T> not(Expression exp);
 
   /**
-   * Return a list of expressions that will be joined by AND's.
+   * Start a list of expressions that will be joined by AND's
+   * returning the expression list the expressions are added to.
+   * <p>
+   * This is exactly the same as conjunction();
+   * </p>
+   * <p>
+   * Use endJunction() to end the AND junction.
+   * </p>
+   * <p>
+   * Note that a where() clause defaults to an AND junction so
+   * typically you only explicitly need to use the and() junction
+   * when it is nested inside an or() or not() junction.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  // Example: Nested and()
+   *
+   *  Ebean.find(Customer.class)
+   *    .where()
+   *    .or()
+   *      .and() // nested and
+   *        .startsWith("name", "r")
+   *        .eq("anniversary", onAfter)
+   *        .endJunction() // end AND junction
+   *      .and()
+   *        .eq("status", Customer.Status.ACTIVE)
+   *        .gt("id", 0)
+   *        .endJunction() // end AND junction
+   *      .orderBy().asc("name")
+   *      .findList();
+   * }</pre>
+   */
+  Junction<T> and();
+
+  /**
+   * Return a list of expressions that will be joined by OR's.
+   * This is exactly the same as disjunction();
+   *
+   * <p>
+   *   Use endJunction() to end the OR junction.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  // Example: Use or() to join
+   *  // two nested and() expressions
+   *
+   *  Ebean.find(Customer.class)
+   *    .where()
+   *    .or()
+   *      .and()
+   *        .startsWith("name", "r")
+   *        .eq("anniversary", onAfter)
+   *        .endJunction() // end AND junction
+   *      .and()
+   *        .eq("status", Customer.Status.ACTIVE)
+   *        .gt("id", 0)
+   *        .endJunction() // end AND junction
+   *      .orderBy().asc("name")
+   *      .findList();
+   *
+   * }</pre>
+   */
+  Junction<T> or();
+
+  /**
+   * Return a list of expressions that will be wrapped by NOT.
+   * <p>
+   *   Use endJunction() to end expressions being added to the
+   *   NOT expression list.
+   * </p>
+   *
+   * <pre>@{code
+   *
+   *    .where()
+   *      .not()
+   *        .gt("id", 1)
+   *        .eq("anniversary", onAfter)
+   *        .endJunction() // end the not expressions
+   *
+   * }</pre>
+   *
+   * <pre>@{code
+   *
+   * // Example: nested not()
+   *
+   * Ebean.find(Customer.class)
+   *   .where()
+   *     .eq("status", Customer.Status.ACTIVE)
+   *     .not()
+   *       .gt("id", 1)
+   *       .eq("anniversary", onAfter)
+   *       .endJunction() // end the not expressions
+   *     .orderBy()
+   *       .asc("name")
+   *     .findList();
+   *
+   * }</pre>
+   */
+  Junction<T> not();
+
+  /**
+   * Start (and return) a list of expressions that will be joined by AND's.
+   * <p>
+   * This is the same as and().
+   * </p>
    */
   Junction<T> conjunction();
 
   /**
-   * Return a list of expressions that will be joined by OR's.
+   * Start (and return) a list of expressions that will be joined by OR's.
+   * <p>
+   * This is the same as or().
+   * </p>
    */
   Junction<T> disjunction();
 
   /**
-   * End a Conjunction or Disjunction returning the parent expression list.
+   * Start a list of expressions that will be joined by MUST.
    * <p>
-   * Alternatively you can always use where() to return the top level expression
-   * list.
+   * This automatically makes the query a useDocStore(true) query that
+   * will execute against the document store (ElasticSearch etc).
+   * </p>
+   * <p>
+   * This is logically similar to and().
+   * </p>
+   */
+  Junction<T> must();
+
+  /**
+   * Start a list of expressions that will be joined by SHOULD.
+   * <p>
+   * This automatically makes the query a useDocStore(true) query that
+   * will execute against the document store (ElasticSearch etc).
+   * </p>
+   * <p>
+   * This is logically similar to or().
+   * </p>
+   */
+  Junction<T> should();
+
+  /**
+   * Start a list of expressions that will be joined by MUST NOT.
+   * <p>
+   * This automatically makes the query a useDocStore(true) query that
+   * will execute against the document store (ElasticSearch etc).
+   * </p>
+   * <p>
+   * This is logically similar to not().
+   * </p>
+   */
+  Junction<T> mustNot();
+
+  /**
+   * End a junction returning the parent expression list.
+   * <p>
+   * Ends a and(), or(), not(), must(), mustNot() or should() junction
+   * such that you get the parent expression.
+   * </p>
+   * <p>
+   * Alternatively you can always use where() to return the top level expression list.
    * </p>
    */
   ExpressionList<T> endJunction();

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

@@ -249,4 +249,22 @@ public class FetchConfig implements Serializable {
     return queryAll;
   }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    FetchConfig that = (FetchConfig) o;
+    if (lazyBatchSize != that.lazyBatchSize) return false;
+    if (queryBatchSize != that.queryBatchSize) return false;
+    return queryAll == that.queryAll;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = lazyBatchSize;
+    result = 92821 * result + queryBatchSize;
+    result = 92821 * result + (queryAll ? 1 : 0);
+    return result;
+  }
 }

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

@@ -0,0 +1,26 @@
+package com.avaje.ebean;
+
+import java.util.Set;
+
+/**
+ * Provides paths and properties for an object graph that can be used to control what parts of the object graph
+ * is fetching (select and fetch clauses) and also can be used to control JSON marshalling (what parts of the object
+ * graph are included in the JSON).
+ */
+public interface FetchPath {
+
+  /**
+   * Return true if the path is included in this FetchPath.
+   */
+  boolean hasPath(String path);
+
+  /**
+   * Return the properties at the given path.
+   */
+  Set<String> getProperties(String path);
+
+  /**
+   * Apply the fetch path to the query.
+   */
+  <T> void apply(Query<T> query);
+}

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

@@ -9,70 +9,129 @@ package com.avaje.ebean;
  * <p>
  * Note: where() always takes you to the top level WHERE expression list.
  * </p>
- * 
- * <pre class="code">
+ *
+ * <pre>{@code
  * Query q =
  *     Ebean.find(Person.class)
- *         .where().disjunction()
- *         .like(&quot;name&quot;, &quot;Rob%&quot;)
- *         .eq(&quot;status&quot;, Status.NEW)
- * 
- *         // where() returns us to the top level expression list
- *         .where().gt(&quot;id&quot;, 10);
- * 
+ *       .where()
+ *         .or()
+ *           .like("name", "Rob%")
+ *           .eq("status", Status.NEW)
+ *
+ *       // where() returns us to the top level expression list
+ *       .where().gt("id", 10);
+ *
  * // read as...
  * // where ( ((name like Rob%) or (status = NEW)) AND (id &gt; 10) )
- * </pre>
- * 
+ * }</pre>
+ *
  * <p>
  * Note: endJunction() takes you to the parent expression list
  * </p>
- * 
- * <pre class="code">
+ *
+ * <pre>{@code
  * Query q =
  *     Ebean.find(Person.class)
- *         .where().disjunction()
- *         .like(&quot;name&quot;, &quot;Rob%&quot;)
- *         .eq(&quot;status&quot;, Status.NEW)
- *         .endJunction()
- * 
- *         // endJunction().. takes us to the 'parent' expression list
- *         // which in this case is the top level (same as where())
- * 
- *         .gt(&quot;id&quot;, 10);
- * 
+ *       .where()
+ *         .or()
+ *           .like("name", "Rob%")
+ *           .eq("status", Status.NEW)
+ *           .endJunction()
+ *
+ *           // endJunction().. takes us to the 'parent' expression list
+ *           // which in this case is the top level (same as where())
+ *
+ *         .gt("id", 10);
+ *
  * // read as...
- * // where ( ((name like Rob%) or (status = NEW)) AND (id &gt; 10) )
- * </pre>
- * 
+ * // where ( ((name like Rob%) or (status = NEW)) AND (id > 10) )
+ * }</pre>
+ *
  * <p>
  * Example of a nested disjunction.
  * </p>
- * 
- * <pre class="code">
- * Query&lt;Customer&gt; q = 
+ *
+ * <pre>{@code
+ * Query<Customer> q =
  *  Ebean.find(Customer.class)
  *      .where()
- *          .disjunction()
- *              .conjunction()
- *                  .startsWith(&quot;name&quot;, &quot;r&quot;)
- *                  .eq(&quot;anniversary&quot;, onAfter)
- *                  .endJunction()
- *              .conjunction()
- *                  .eq(&quot;status&quot;, Customer.Status.ACTIVE)
- *                  .gt(&quot;id&quot;, 0)
- *                  .endJunction()
- *      .order().asc(&quot;name&quot;);
- * 
+ *        .or()
+ *          .and()
+ *            .startsWith("name", "r")
+ *            .eq("anniversary", onAfter)
+ *            .endJunction()
+ *          .and()
+ *            .eq("status", Customer.Status.ACTIVE)
+ *            .gt("id", 0)
+ *            .endJunction()
+ *      .order().asc("name");
+ *
  * q.findList();
  * String s = q.getGeneratedSql();
- * 
+ *
  *  // this produces an expression like:
- *  
- *  ( name like ? and c.anniversary = ? ) or (c.status = ?  and c.id &gt; ? )
- * 
- * </pre>
+ *  ( name like ? and c.anniversary = ? ) or (c.status = ?  and c.id > ? )
+ *
+ * }</pre>
  */
 public interface Junction<T> extends Expression, ExpressionList<T> {
 
+  /**
+   * The type of Junction used in full text expressions.
+   */
+  enum Type {
+
+    /**
+     * AND group.
+     */
+    AND(" and ", ""),
+
+    /**
+     * OR group.
+     */
+    OR(" or ", ""),
+
+    /**
+     * NOT group.
+     */
+    NOT(" and ", "not "),
+
+    /**
+     * Text search AND group.
+     */
+    MUST("must", ""),
+
+    /**
+     * Text search NOT group.
+     */
+    MUST_NOT("must_not", ""),
+
+    /**
+     * Text search OR group.
+     */
+    SHOULD("should", "");
+
+    String prefix;
+    String literal;
+
+    Type(String literal, String prefix) {
+      this.literal = literal;
+      this.prefix = prefix;
+    }
+
+    /**
+     * Return the literal value for this type.
+     */
+    public String literal() {
+      return literal;
+    }
+
+    /**
+     * Return the prefix value for this type.
+     */
+    public String prefix() {
+      return prefix;
+    }
+  }
+
 }

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

@@ -1,7 +1,6 @@
 package com.avaje.ebean;
 
 import com.avaje.ebean.bean.EntityBean;
-import com.avaje.ebean.text.PathProperties;
 import com.avaje.ebean.util.ClassUtil;
 import org.jetbrains.annotations.Nullable;
 
@@ -271,6 +270,19 @@ public abstract class Model {
     return db().delete(this);
   }
 
+  /**
+   * Delete a bean permanently without soft delete.
+   * <p>
+   * This is used when the bean contains a <code>@SoftDelete</code> property and we
+   * want to perform a hard/permanent delete.
+   * </p>
+   *
+   * @see EbeanServer#deletePermanent(Object)
+   */
+  public boolean deletePermanent() {
+    return db().deletePermanent(this);
+  }
+
   /**
    * Perform an update using this entity against the specified server.
    */
@@ -588,10 +600,10 @@ public abstract class Model {
     /**
      * Creates a query applying the path properties to set the select and fetch clauses.
      * <p>
-     * Equivalent to {@link Query#apply(com.avaje.ebean.text.PathProperties)}
+     * Equivalent to {@link Query#apply(FetchPath)}
      */
-    public Query<T> apply(PathProperties pathProperties) {
-      return db().find(type).apply(pathProperties);
+    public Query<T> apply(FetchPath fetchPath) {
+      return db().find(type).apply(fetchPath);
     }
 
     /**

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

@@ -221,24 +221,39 @@ public final class OrderBy<T> implements Serializable {
 
     private boolean ascending;
 
+    private String nulls;
+
+    private String highLow;
+
     public Property(String property, boolean ascending) {
       this.property = property;
       this.ascending = ascending;
     }
 
+    public Property(String property, boolean ascending, String nulls, String highLow) {
+      this.property = property;
+      this.ascending = ascending;
+      this.nulls = nulls;
+      this.highLow = highLow;
+    }
+
     /**
      * Return a copy of this Property with the path trimmed.
      */
     public Property copyWithTrim(String path) {
-      return new Property(property.substring(path.length() + 1), ascending);
+      return new Property(property.substring(path.length() + 1), ascending, nulls, highLow);
     }
 
+    @Override
     public int hashCode() {
       int hc = property.hashCode();
       hc = hc * 31 + (ascending ? 0 : 1);
+      hc = hc * 31 + (nulls == null ? 0 : nulls.hashCode());
+      hc = hc * 31 + (highLow == null ? 0 : highLow.hashCode());
       return hc;
     }
-    
+
+    @Override
     public boolean equals(Object obj) {
       if (obj == this) {
         return true;
@@ -246,10 +261,11 @@ public final class OrderBy<T> implements Serializable {
       if (!(obj instanceof Property)) {
         return false;
       }
-      
       Property e = (Property) obj;
-      return e.ascending == ascending 
-          && e.property.equals(property);
+      if (ascending != e.ascending) return false;
+      if (!property.equals(e.property)) return false;
+      if (nulls != null ? !nulls.equals(e.nulls) : e.nulls != null) return false;
+      return highLow != null ? highLow.equals(e.highLow) : e.highLow == null;
     }
 
     public String toString() {
@@ -257,10 +273,20 @@ public final class OrderBy<T> implements Serializable {
     }
 
     public String toStringFormat() {
-      if (ascending) {
-        return property;
+      if (nulls == null) {
+        if (ascending) {
+          return property;
+        } else {
+          return property + " desc";
+        }
       } else {
-        return property + " desc";
+        StringBuilder sb = new StringBuilder();
+        sb.append(property);
+        if (!ascending) {
+          sb.append(" ").append("desc");
+        }
+        sb.append(" ").append(nulls).append(" ").append(highLow);
+        return  sb.toString();
       }
     }
 
@@ -282,7 +308,7 @@ public final class OrderBy<T> implements Serializable {
      * Return a copy of this property.
      */
     public Property copy() {
-      return new Property(property, ascending);
+      return new Property(property, ascending, nulls, highLow);
     }
 
     /**
@@ -323,7 +349,6 @@ public final class OrderBy<T> implements Serializable {
 
     String[] chunks = orderByClause.split(",");
     for (int i = 0; i < chunks.length; i++) {
-
       String[] pairs = chunks[i].split(" ");
       Property p = parseProperty(pairs);
       if (p != null) {
@@ -353,8 +378,12 @@ public final class OrderBy<T> implements Serializable {
       boolean asc = isAscending(wordList.get(1));
       return new Property(wordList.get(0), asc);
     }
-    String m = "Expecting a max of 2 words in [" + Arrays.toString(pairs)
-        + "] but got " + wordList.size();
+    if (wordList.size() == 4) {
+      // nulls high or nulls low as 3rd and 4th
+      boolean asc = isAscending(wordList.get(1));
+      return new Property(wordList.get(0), asc, wordList.get(2), wordList.get(3));
+    }
+    String m = "Expecting a 1, 2 or 4 words in [" + Arrays.toString(pairs) + "] but got " + wordList;
     throw new RuntimeException(m);
   }
 

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

@@ -0,0 +1,18 @@
+package com.avaje.ebean;
+
+import javax.persistence.PersistenceException;
+
+/**
+ * Captures and wraps IOException's occurring during ElasticSearch processing etc.
+ */
+public class PersistenceIOException extends PersistenceException {
+
+  public PersistenceIOException(String msg, Exception cause) {
+    super(msg, cause);
+  }
+
+  public PersistenceIOException(Exception cause) {
+    super(cause);
+  }
+
+}

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

@@ -1,10 +1,8 @@
 package com.avaje.ebean;
 
-import com.avaje.ebean.text.PathProperties;
 import org.jetbrains.annotations.Nullable;
 
 import javax.persistence.NonUniqueResultException;
-import java.io.Serializable;
 import java.sql.Timestamp;
 import java.util.List;
 import java.util.Map;
@@ -275,7 +273,7 @@ import java.util.Set;
  * @param <T>
  *          the type of Entity bean this query will fetch.
  */
-public interface Query<T> extends Serializable {
+public interface Query<T> {
 
   /**
    * Return the RawSql that was set to use for this query.
@@ -304,8 +302,9 @@ public interface Query<T> extends Serializable {
   Query<T> asDraft();
 
   /**
-   * Execute the query including soft deleted rows.
+   * Deprecated in favour of setIncludeSoftDeletes().
    */
+  @Deprecated
   Query<T> includeSoftDeletes();
 
   /**
@@ -377,6 +376,11 @@ public interface Query<T> extends Serializable {
    */
   Query<T> setLazyLoadBatchSize(int lazyLoadBatchSize);
 
+  /**
+   * Execute the query including soft deleted rows.
+   */
+  Query<T> setIncludeSoftDeletes();
+
   /**
    * Disable read auditing for this query.
    * <p>
@@ -522,10 +526,10 @@ public interface Query<T> extends Serializable {
   /**
    * Apply the path properties replacing the select and fetch clauses.
    * <p>
-   * This is typically used when the PathProperties is applied to both the query and the JSON output.
+   * This is typically used when the FetchPath is applied to both the query and the JSON output.
    * </p>
    */
-  Query<T> apply(PathProperties pathProperties);
+  Query<T> apply(FetchPath fetchPath);
 
   /**
    * Execute the query returning the list of Id's.
@@ -1043,6 +1047,27 @@ public interface Query<T> extends Serializable {
    */
   ExpressionList<T> where();
 
+  /**
+   * Add Full text search expressions for Document store queries.
+   * <p>
+   * This is currently ElasticSearch only and provides the full text
+   * expressions such as Match and Multi-Match.
+   * </p>
+   * <p>
+   * This automatically makes this query a "Doc Store" query and will execute
+   * against the document store (ElasticSearch).
+   * </p>
+   * <p>
+   * Expressions added here are added to the "query" section of an ElasticSearch
+   * query rather than the "filter" section.
+   * </p>
+   * <p>
+   * Expressions added to the where() are added to the "filter" section of an
+   * ElasticSearch query.
+   * </p>
+   */
+  ExpressionList<T> text();
+
   /**
    * This applies a filter on the 'many' property list rather than the root
    * level objects.
@@ -1286,6 +1311,14 @@ public interface Query<T> extends Serializable {
    */
   Query<T> setUseQueryCache(boolean useQueryCache);
 
+  /**
+   * Set to true if this query should execute against the doc store.
+   * <p>
+   *   When setting this you may also consider disabling lazy loading.
+   * </p>
+   */
+  Query<T> setUseDocStore(boolean useDocStore);
+
   /**
    * When set to true when you want the returned beans to be read only.
    */
@@ -1365,4 +1398,5 @@ public interface Query<T> extends Serializable {
    * </p>
    */
   Set<String> validate();
+
 }

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

@@ -206,6 +206,14 @@ public final class RawSql implements Serializable {
     return sql;
   }
 
+  /**
+   * Return the key;
+   */
+  public Key getKey() {
+    boolean parsed = sql != null && sql.parsed;
+    String unParsedSql = (sql == null) ? "" : sql.unparsedSql;
+    return new Key(parsed, unParsedSql, columnMapping);
+  }
   
   /**
    * Return the resultSet if this is a ResultSet based RawSql.
@@ -221,16 +229,6 @@ public final class RawSql implements Serializable {
     return columnMapping;
   }
 
-  /**
-   * Return the hash for this query.
-   */
-  public int queryHash() {
-    if (resultSet != null) {
-      return 31 * columnMapping.queryHash();
-    }
-    return 31 * sql.queryHash() + columnMapping.queryHash();
-  }
-
   /**
    * Represents the sql part of the query. For parsed RawSql the sql is broken
    * up so that Ebean can insert extra WHERE and HAVING expressions into the
@@ -260,13 +258,10 @@ public final class RawSql implements Serializable {
 
     private final boolean distinct;
 
-    private final int queryHashCode;
-
     /**
      * Construct for unparsed SQL.
      */
     protected Sql(String unparsedSql) {
-      this.queryHashCode = unparsedSql.hashCode();
       this.parsed = false;
       this.unparsedSql = unparsedSql;
       this.preFrom = null;
@@ -282,12 +277,11 @@ public final class RawSql implements Serializable {
     /**
      * Construct for parsed SQL.
      */
-    protected Sql(int queryHashCode, String preFrom, String preWhere, boolean andWhereExpr,
+    protected Sql(String unparsedSql, String preFrom, String preWhere, boolean andWhereExpr,
         String preHaving, boolean andHavingExpr, String orderByPrefix, String orderBy, boolean distinct) {
 
-      this.queryHashCode = queryHashCode;
+      this.unparsedSql = unparsedSql;
       this.parsed = true;
-      this.unparsedSql = null;
       this.preFrom = preFrom;
       this.preHaving = preHaving;
       this.preWhere = preWhere;
@@ -298,13 +292,6 @@ public final class RawSql implements Serializable {
       this.distinct = distinct;
     }
 
-    /**
-     * Return a hash for this query.
-     */
-    public int queryHash() {
-      return queryHashCode;
-    }
-
     public String toString() {
       if (!parsed) {
         return "unparsed[" + unparsedSql + "]";
@@ -406,13 +393,10 @@ public final class RawSql implements Serializable {
 
     private final boolean immutable;
 
-    private final int queryHashCode;
-
     /**
      * Construct from parsed sql where the columns have been identified.
      */
     protected ColumnMapping(List<Column> columns) {
-      this.queryHashCode = 0;
       this.immutable = false;
       this.parsed = true;
       this.propertyMap = null;
@@ -428,7 +412,6 @@ public final class RawSql implements Serializable {
      * Construct for unparsed sql.
      */
     protected ColumnMapping() {
-      this.queryHashCode = 0;
       this.immutable = false;
       this.parsed = false;
       this.propertyMap = null;
@@ -443,17 +426,13 @@ public final class RawSql implements Serializable {
       this.immutable = false;
       this.parsed = false;
       this.propertyMap = null;
-      //this.propertyColumnMap = null;
       this.dbColumnMap = new LinkedHashMap<String, Column>();
-      
-      int hc = 31;
+
       int pos = 0;
       for (String prop : propertyNames) {
-        hc = 31 * hc + prop.hashCode();
         dbColumnMap.put(prop, new Column(pos++, prop, null, prop));
       }
       propertyColumnMap = dbColumnMap;
-      this.queryHashCode = hc;
     }
 
     /**
@@ -464,20 +443,28 @@ public final class RawSql implements Serializable {
       this.parsed = parsed;
       this.dbColumnMap = dbColumnMap;
 
-      int hc = ColumnMapping.class.getName().hashCode();
-
       HashMap<String, Column> pcMap = new HashMap<String, Column>();
       HashMap<String, String> pMap = new HashMap<String, String>();
 
       for (Column c : dbColumnMap.values()) {
         pMap.put(c.getPropertyName(), c.getDbColumn());
         pcMap.put(c.getPropertyName(), c);
-        hc = 31 * hc + ((c.getPropertyName() == null) ? 0 : c.getPropertyName().hashCode());
-        hc = 31 * hc + ((c.getDbColumn() == null) ? 0 : c.getDbColumn().hashCode());
       }
       this.propertyMap = Collections.unmodifiableMap(pMap);
       this.propertyColumnMap = Collections.unmodifiableMap(pcMap);
-      this.queryHashCode = hc;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      ColumnMapping that = (ColumnMapping) o;
+      return dbColumnMap.equals(that.dbColumnMap);
+    }
+
+    @Override
+    public int hashCode() {
+      return dbColumnMap.hashCode();
     }
 
     /**
@@ -521,16 +508,6 @@ public final class RawSql implements Serializable {
       }
     }
 
-    /**
-     * Return the query hash for this column mapping.
-     */
-    public int queryHash() {
-      if (queryHashCode == 0) {
-        throw new RuntimeException("Bug: queryHashCode == 0");
-      }
-      return queryHashCode;
-    }
-
     /**
      * Returns true if the Columns where supplied by parsing the sql select
      * clause.
@@ -648,6 +625,27 @@ public final class RawSql implements Serializable {
         }
       }
 
+      @Override
+      public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Column that = (Column) o;
+        if (indexPos != that.indexPos) return false;
+        if (!dbColumn.equals(that.dbColumn)) return false;
+        if (dbAlias != null ? !dbAlias.equals(that.dbAlias) : that.dbAlias != null) return false;
+        return propertyName != null ? propertyName.equals(that.propertyName) : that.propertyName == null;
+      }
+
+      @Override
+      public int hashCode() {
+        int result = indexPos;
+        result = 31 * result + dbColumn.hashCode();
+        result = 31 * result + (dbAlias != null ? dbAlias.hashCode() : 0);
+        result = 31 * result + (propertyName != null ? propertyName.hashCode() : 0);
+        return result;
+      }
+
       public String toString() {
         return dbColumn + "->" + propertyName;
       }
@@ -699,4 +697,39 @@ public final class RawSql implements Serializable {
       }
     }
   }
+
+  /**
+   * A key for the RawSql object using for the query plan.
+   */
+  public static final class Key {
+
+    private final boolean parsed;
+    private final ColumnMapping columnMapping;
+    private final String unParsedSql;
+
+    Key(boolean parsed, String unParsedSql, ColumnMapping columnMapping) {
+      this.parsed = parsed;
+      this.unParsedSql = unParsedSql;
+      this.columnMapping = columnMapping;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+
+      Key that = (Key) o;
+      return parsed == that.parsed
+          && columnMapping.equals(that.columnMapping)
+          && unParsedSql.equals(that.unParsedSql);
+    }
+
+    @Override
+    public int hashCode() {
+      int result = (parsed ? 1 : 0);
+      result = 31 * result + columnMapping.hashCode();
+      result = 31 * result + unParsedSql.hashCode();
+      return result;
+    }
+  }
 }

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

@@ -1,5 +1,7 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.annotation.DocStoreMode;
+import com.avaje.ebean.config.DocStoreConfig;
 import com.avaje.ebean.config.PersistBatch;
 
 import javax.persistence.PersistenceException;
@@ -81,6 +83,29 @@ public interface Transaction extends Closeable {
    */
   boolean isActive();
 
+  /**
+   * Set the behavior for document store updates on this transaction.
+   * <p>
+   *   For example, set the mode to DocStoreEvent.IGNORE for this transaction and
+   *   then any changes via this transaction are not sent to the doc store. This
+   *   would be used when doing large bulk inserts into the database and we want
+   *   to control how that is sent to the document store.
+   * </p>
+   */
+  void setDocStoreMode(DocStoreMode mode);
+
+  /**
+   * Set the batch size to use for sending messages to the document store.
+   * <p>
+   *   You might set this if you know the changes in this transaction result in especially large or
+   *   especially small payloads and want to adjust the batch size to match.
+   * </p>
+   * <p>
+   *   Setting this overrides the default of {@link DocStoreConfig#getBulkBatchSize()}
+   * </p>
+   */
+  void setDocStoreBatchSize(int batchSize);
+
   /**
    * Explicitly turn off or on the cascading nature of save() and delete(). This
    * gives the developer exact control over what beans are saved and deleted

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

@@ -0,0 +1,55 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify cache tuning for query caching on a specific entity type.
+ * <p>
+ * If this is not specified then the system default settings are used.
+ * </p>
+ */
+@Target({ ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CacheQueryTuning {
+
+  /**
+   * The maximum size for the cache.
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxSize() default 0;
+
+  /**
+   * The maximum time (in seconds) that a cache entry is allowed to stay in the
+   * cache when it has not been accessed.
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxIdleSecs() default 0;
+
+  /**
+   * The maximum time (in seconds) a cache entry is allowed to stay in the
+   * cache.
+   * <p>
+   * This is not generally required as the cache entries are automatically
+   * evicted when related data changes are committed.
+   * </p>
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxSecsToLive() default 0;
+
+  /**
+   * The frequency (in seconds) that cache trimming should occur.
+   * <p>
+   * This is a hint for cache implementations that use background cache trimming.
+   * </p>
+   */
+  int trimFrequency() default 0;
+}

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

@@ -42,17 +42,4 @@ public @interface CacheStrategy {
    */
   boolean readOnly() default false;
 
-  /**
-   * Specify a query that can be used to warm the cache.
-   * <p>
-   * All the beans fetched by this query will be loaded into the bean cache and
-   * the query itself will be loaded into the query cache.
-   * </p>
-   * <p>
-   * The warming query will typically be executed at startup time after a short
-   * delay (defaults to a 30 seconds delay).
-   * </p>
-   */
-  String warmingQuery() default "";
-
 }

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

@@ -0,0 +1,32 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Used to indicate that a particular string property should be treated as a 'code' and not analysed for text searching.
+ * <p>
+ * By default all Id properties and all Enum properties are treated as 'code' and not analysed.
+ * </p>
+ */
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocCode {
+
+  /**
+   * Set to true to have the property additionally stored separately from _source.
+   */
+  boolean store() default false;
+
+  /**
+   * Set a boost value specific to this property.
+   */
+  float boost() default 1;
+
+  /**
+   * Set a value to use instead of null.
+   */
+  String nullValue() default "";
+}

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

@@ -0,0 +1,37 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the property is included in the parent document store index.
+ *
+ * <pre>{@code
+ *
+ *
+ * @DocStore
+ * @Entity @Table(name = "o_order")
+ * public class Order {
+ *
+ *   ...
+ *   // include some customer details including
+ *   // nested billingAddress
+ *   @DocEmbedded(doc = "id,status,name,billingAddress(*,country(*)")
+ *   @ManyToOne
+ *   Customer customer;
+ *
+ *
+ * }</pre>
+ */
+@Target({ ElementType.FIELD })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocEmbedded {
+
+  /**
+   * The properties on the embedded bean to include in the index.
+   */
+  String doc() default "";
+
+}

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

@@ -0,0 +1,24 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the entity type maps to a document store (like ElasticSearch).
+ */
+@Target({ ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocMapping {
+
+  /**
+   * The property name the mapping applies to.
+   */
+  String name();
+
+  /**
+   * Mapping options.
+   */
+  DocProperty options();
+}

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

@@ -0,0 +1,110 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the entity type maps to a document store (like ElasticSearch).
+ */
+@Target({ ElementType.FIELD })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocProperty {
+
+  /**
+   * Set this to true to indicate that this property should be un-analysed.
+   */
+  boolean code() default false;
+
+  /**
+   * Set this to true to get an additional un-analysed 'raw' field to use for sorting etc.
+   */
+  boolean sortable() default false;
+
+  /**
+   * Set to true to have the property additionally stored separately from _source.
+   */
+  boolean store() default false;
+
+  /**
+   * Set a boost value specific to this property.
+   */
+  float boost() default 1;
+
+  /**
+   * Set a value to use instead of null.
+   */
+  String nullValue() default "";
+
+  /**
+   * Set this to false to exclude this from the _all property.
+   */
+  boolean includeInAll() default true;
+
+  /**
+   * The analyzer to use.
+   */
+  String analyzer() default "";
+
+  /**
+   * The analyzer to use for searches.
+   */
+  String searchAnalyzer() default "";
+
+  /**
+   * The index options for this property.
+   */
+  Option options() default Option.DEFAULT;
+
+  /**
+   * Set this to false such that doc values are not stored separately for this property.
+   */
+  boolean docValues() default true;
+
+  /**
+   * Set a copyTo field.
+   */
+  String copyTo() default "";
+
+  /**
+   * Set to false to disable the field from indexing, it will only be get/set in _source.
+   */
+  boolean enabled() default true;
+
+  /**
+   * Set to false such that norms are not stored.
+   */
+  boolean norms() default true;
+
+  /**
+   * Index options for a property.
+   */
+  enum Option {
+
+    /**
+     * Only index the doc number.
+     */
+    DOCS,
+
+    /**
+     * Doc number and term frequencies are indexed.
+     */
+    FREQS,
+
+    /**
+     * Doc number, term frequencies and term positions are indexed.
+     */
+    POSITIONS,
+
+    /**
+     * Doc number, term frequencies, term positions and start/end offsets are indexed.
+     */
+    OFFSETS,
+
+    /**
+     * Use the default which means analysed string properties use POSITIONS as the default and all other types use DOCS.
+     */
+    DEFAULT
+  }
+}

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

@@ -0,0 +1,34 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Used to indicate that a particular string property should support sorting. What this typically means is that
+ * for ElasticSearch an additional 'raw' field is added that stores the un-analysed value. This un-analysed value
+ * can be used for sorting etc and the original field used for text searching.
+ * <p>
+ * For example, customer name and product name are good candidates for marking with @DocSortable.
+ * </p>
+ */
+@Target({ ElementType.FIELD })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocSortable {
+
+  /**
+   * Set to true to have the property additionally stored separately from _source.
+   */
+  boolean store() default false;
+
+  /**
+   * Set a boost value specific to this property.
+   */
+  float boost() default 1;
+
+  /**
+   * Set a value to use instead of null.
+   */
+  String nullValue() default "";
+}

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

@@ -0,0 +1,88 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the entity type maps to a document store (like ElasticSearch).
+ */
+@Target({ ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocStore {
+
+  /**
+   * A unique Id used when queuing reindex events.
+   */
+  String queueId() default "";
+
+  /**
+   * The ElasticSearch index name. If left unspecified the short name of the bean type is used.
+   */
+  String indexName() default "";
+
+  /**
+   * The ElasticSearch index type. If left unspecified the short name of the bean type is used.
+   */
+  String indexType() default "";
+
+  /**
+   * The number of shards this index should use.
+   */
+  int shards() default 0;
+
+  /**
+   * The number of replicas this index should use.
+   */
+  int replicas() default 0;
+
+  /**
+   * Additional mapping that can be defined on the properties.
+   */
+  DocMapping[] mapping() default {};
+
+  /**
+   * Specify the behavior when bean Insert, Update, Delete events occur.
+   */
+  DocStoreMode persist() default DocStoreMode.DEFAULT;
+
+  /**
+   * Specify the behavior when bean Insert occurs.
+   */
+  DocStoreMode insert() default DocStoreMode.DEFAULT;
+
+  /**
+   * Specify the behavior when bean Update occurs.
+   */
+  DocStoreMode update() default DocStoreMode.DEFAULT;
+
+  /**
+   * Specify the behavior when bean Delete occurs.
+   */
+  DocStoreMode delete() default DocStoreMode.DEFAULT;
+
+  /**
+   * Specify to include only some properties in the doc store document.
+   * <p>
+   * If this is left as default then all scalar properties are included,
+   * all @ManyToOne properties are included with just the nested id property
+   * and no @OneToMany properties are included.
+   * </p>
+   * <p>
+   * Note that typically DocStoreEmbedded is used on @ManyToOne and @OneToMany
+   * properties to indicate what part of the nested document should be included.
+   * </p>
+   *
+   * <h3>Example:</h3>
+   * <pre>{@code
+   *
+   * // only include the customer id and name
+   * @DocStore(doc = "id,name")
+   * @Entity @Table(name = "o_order")
+   * public class Customer {
+   *
+   * }</pre>
+   */
+  String doc() default "";
+}

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

@@ -0,0 +1,38 @@
+package com.avaje.ebean.annotation;
+
+/**
+ * Defines the behavior options when a Insert, Update or Delete event occurs
+ * on a bean with an associated ElasticSearch index.
+ * <p>
+ * For some indexes or some transactions it can be beneficial to queue the event
+ * for later processing rather than look to update ElasticSearch at that time.
+ * </p>
+ */
+public enum DocStoreMode {
+
+  /**
+   * Add the event to the queue for processing later (delaying the update to the document store).
+   */
+  QUEUE,
+
+  /**
+   * Update the document store when transaction succeeds.
+   */
+  UPDATE,
+
+  /**
+   * Ignore the event and not update the document store.
+   * <p>
+   *   This can be used on a index or for a transaction where you want to have more
+   *   manual programmatic control over the updating of the document store.  Say you want to
+   *   IGNORE on a particular transaction and instead manually queue a bulk update.
+   * </p>
+   */
+  IGNORE,
+
+  /**
+   * The actual mode of QUEUE, UPDATE or IGNORE is set from the default configuration.
+   */
+  DEFAULT
+
+}

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

@@ -6,19 +6,13 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * Specify explicit sql for multiple select statements. Need to use this if you
- * have more than one SqlSelect for a given bean.
+ * Mark and entity bean that is used solely via RawSql.
  * <p>
- * FUTURE: Support explicit sql for SqlInsert, SqlUpdate and SqlDelete.
+ * This means the entity bean has no base table specified (via @Table).
  * </p>
  */
 @Target({ ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Sql {
 
-  /**
-   * The sql select statements.
-   */
-  SqlSelect[] select() default { @SqlSelect };
-
 }

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

@@ -1,298 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import com.avaje.ebean.Query;
-
-/**
- * Specify an explicit sql select statement to use for querying an entity bean.
- * <p>
- * The reason for using explicit sql is that you want better control over the
- * exact sql or sql that Ebean does not generate for you (such as group by,
- * union, intersection, window functions, recursive queries).
- * </p>
- * <p>
- * An example of two sql select queries deployed on the ReportTopic entity bean.
- * The first one has no name specified so it becomes the default query. The
- * second query extends the first adding a where clause with a named parameter.
- * </p>
- * 
- * <pre class="code">
- * ...
- * &#064;Entity
- *   &#064;Sql(select = {
- *     &#064;SqlSelect(query = 
- *       &quot;select t.id, t.title, count(p.id) as score &quot;+
- *       &quot;from f_topic t &quot;+
- *       &quot;join f_topic_post p on p.topic_id = t.id &quot;+
- *       &quot;group by t.id, t.title&quot;),
- *     &#064;SqlSelect(
- *       name = &quot;with.title&quot;,
- *       extend = &quot;default&quot;,
- *       debug = true,
- *       where = &quot;title like :likeTitle&quot;)
- *  })
- *  public class ReportTopic
- *    &#064;Id Integer id;
- *    String title;
- *    Double score;
- *    ...
- * </pre>
- * 
- * <p>
- * An example using the first "default" query.
- * </p>
- * 
- * <pre class="code">
- * 
- * List&lt;ReportTopic&gt; list =
- *     Ebean.find(ReportTopic.class)
- *         .having().gt(&quot;score&quot;, 0)
- *         .findList();
- * 
- * </pre>
- * 
- * <p>
- * The resulting sql, note the having clause has been added.
- * </p>
- * 
- * <pre class="code">
- * select t.id, t.title, count(p.id) as score 
- * from f_topic t join f_topic_post p on p.topic_id = t.id 
- * group by t.id, t.title  
- * having count(p.id) &gt; ?
- * </pre>
- * 
- * <p>
- * An example using the second query. Note the named parameter "likeTitle" must
- * be set.
- * </p>
- * 
- * <pre class="code">
- * List&lt;ReportTopic&gt; list =
- *     Ebean.find(ReportTopic.class, &quot;with.title&quot;)
- *         .set(&quot;likeTitle&quot;, &quot;a%&quot;)
- *         .findList();
- * </pre>
- * 
- * <p>
- * Ebean tries to parse the sql in the query to determine 4 things
- * <li>Location for inserting WHERE expressions (if required)</li>
- * <li>Location for inserting HAVING expressions (if required)</li>
- * <li>Mapping of columns to bean properties</li>
- * <li>The order by clause</li>
- * </p>
- * <p>
- * If Ebean is unable to parse out this information (perhaps because the sql
- * contains multiple select from keywords etc) then you need to manually specify
- * it.
- * </p>
- * <p>
- * Insert ${where} or ${andWhere} into the location where Ebean can insert any
- * expressions added to the where clause. Use ${andWhere} if the sql already has
- * the WHERE keyword and Ebean will instead start with a AND keyword.
- * </p>
- * <p>
- * Insert ${having} or ${andHaving} into the location where Ebean can insert any
- * expressions added to the having clause. Use ${andHaving} if the sql already
- * has a HAVING keyword and Ebean will instead start with a AND keyword.
- * </p>
- * <p>
- * Use the columnMapping property if Ebean is unable to determine the columns
- * and map them to bean properties.
- * </p>
- * <p>
- * Example with ${andWhere} & ${having}.
- * </p>
- * 
- * <pre class="code">
- *    &#064;SqlSelect(
- *          name = &quot;explicit.where&quot;,
- *          query = 
- *              &quot;select t.id, t.title, count(p.id) as score &quot;+
- *              &quot;from f_topic t, f_topic_post p &quot;+
- *              &quot;where p.topic_id = t.id ${andWhere} &quot;+
- *              &quot;group by t.id, t.title ${having}&quot;),
- * </pre>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-@Deprecated
-public @interface SqlSelect {
-
-  /**
-   * The name of the query. If left blank this is assumed to be the default
-   * query for this bean type.
-   * <p>
-   * This will default to "default" and in that case becomes the default query
-   * used for the bean.
-   * </p>
-   */
-  String name() default "default";
-
-  /**
-   * The tableAlias used when adding where expressions to the query.
-   */
-  String tableAlias() default "";
-
-  /**
-   * The sql select statement.
-   * <p>
-   * If this query <em>extends</em> another then this string is appended to the
-   * parent query string. Often when using <em>extend</em> you will leave the
-   * query part blank and just specify a where and/or having clauses.
-   * </p>
-   * <p>
-   * This sql <em>CAN NOT</em> contain named parameters. You have to put these
-   * in the separate where and/or having sections.
-   * </p>
-   * <p>
-   * Ebean automatically tries to determine the location in the sql string for
-   * putting in additional where or having clauses. If Ebean is unable to
-   * successfully determine this then you have to explicitly specify these
-   * locations by including
-   * <em>${where} or ${andWhere} and  ${having} or ${andHaving}</em> in the sql.
-   * </p>
-   * <p>
-   * <b>${where}</b> location of where clause (and will add WHERE ... ) <br/>
-   * Use this when there is no where clause in the sql. If expressions are added
-   * to the where clause Ebean will put them in at this location starting with
-   * the WHERE keyword.
-   * <p>
-   * <p>
-   * <b>${andWhere}</b> <br/>
-   * Use this instead of ${where} if there IS an existing where clause in the
-   * sql. Ebean will add the expressions starting with the AND keyword.
-   * <p>
-   * <b>${having}</b> location of having clause (and will add HAVING... ) <br/>
-   * </p>
-   * <p>
-   * <b>${andHaving}</b> <br/>
-   * Use this instead of ${having} when there IS an existing HAVING clause.
-   * Ebean will add the expressions starting with the AND keyword.
-   * </p>
-   * <p>
-   * You can include one of ${where} OR ${andWhere} but not both.
-   * </p>
-   * <p>
-   * You can include one of ${having} OR ${andHaving} but not both.
-   * </p>
-   */
-  String query() default "";
-
-  /**
-   * Specify the name of a sql-select query that this one 'extends'.
-   * <p>
-   * When a query is extended the sql query contents are appended together. The
-   * where and having clauses are NOT appended but overridden.
-   * </p>
-   */
-  String extend() default "";
-
-  /**
-   * Specify a where clause typically containing named parameters.
-   * <p>
-   * If a where clause is specified with named parameters then they will need to
-   * be set on the query via {@link Query#setParameter(String, Object)}.
-   * </p>
-   * <p>
-   * In the example below the query specifies a where clause that includes a
-   * named parameter "likeTitle".
-   * </p>
-   * 
-   * <pre class="code">
-   * ...
-   * &#064;Entity
-   * &#064;Sql(select = {
-   *  ...
-   *  &#064;SqlSelect(
-   *  name = &quot;with.title&quot;,
-   *  extend = &quot;default&quot;,
-   *  debug = true,
-   *  where = &quot;title like :likeTitle&quot;)
-   *  })
-   *  public class ReportTopic
-   *  ...
-   * </pre>
-   * 
-   * <p>
-   * Example use of the above named query.
-   * </p>
-   * 
-   * <pre class="code">
-   * 
-   * Query&lt;ReportTopic&gt; query0 = Ebean.createQuery(ReportTopic.class, &quot;with.title&quot;);
-   * 
-   * query0.set(&quot;likeTitle&quot;, &quot;Bana%&quot;);
-   * 
-   * List&lt;ReportTopic&gt; list0 = query0.findList();
-   * </pre>
-   * 
-   */
-  String where() default "";
-
-  /**
-   * Specify a having clause typically containing named parameters.
-   * <p>
-   * If a having clause is specified with named parameters then they will need
-   * to be set on the query via {@link Query#setParameter(String, Object)}.
-   * </p>
-   */
-  String having() default "";
-
-  /**
-   * (Optional) Explicitly specify column to property mapping.
-   * <p>
-   * This is required when Ebean is unable to parse the sql. This could occur if
-   * the sql contains multiple select keywords etc.
-   * </p>
-   * <p>
-   * Specify the columns and property names they map to in the format.
-   * </p>
-   * 
-   * <pre class="code">
-   *  column1 propertyName1, column2 propertyName2, ...
-   * </pre>
-   * 
-   * <p>
-   * Optionally put a AS keyword between the column and property.
-   * </p>
-   * 
-   * <pre class="code">
-   *   // the AS keyword is optional
-   *  column1 AS propertyName1, column2 propertyName2, ...
-   * </pre>
-   * 
-   * <p>
-   * <b>column</b> should contain the table alias if there is one
-   * </p>
-   * <p>
-   * <b>propertyName</b> should match the property name.
-   * </p>
-   * 
-   * <p>
-   * Example mapping 5 columns to properties.
-   * </p>
-   * 
-   * <pre class="code">
-   * columnMapping=&quot;t.id, t.bug_body description, t.bug_title as title, count(p.id) as scoreValue&quot;,
-   * </pre>
-   * 
-   * <p>
-   * Without this set Ebean will parse the sql looking for the select clause and
-   * try to map the columns to property names. It is expected that Ebean will
-   * not be able to successfully parse some sql and for those cases you should
-   * specify the column to property mapping explicitly.
-   * </p>
-   * 
-   */
-  String columnMapping() default "";
-
-  /**
-   * Set this to true to have debug output when Ebean parses the sql-select.
-   */
-  boolean debug() default false;
-}

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

@@ -31,6 +31,11 @@ public interface BeanCollection<E> extends Serializable {
     ALL
   }
 
+  /**
+   * Load bean from another collection.
+   */
+  void loadFrom(BeanCollection<?> other);
+
   /**
    * Add a bean to the list/set with modifyListen notification.
    */
@@ -125,6 +130,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   void internalAdd(Object bean);
 
+  /**
+   * Add the bean with a check to see if it is already contained.
+   */
+  void internalAddWithCheck(Object bean);
+
   /**
    * Return the number of elements in the List Set or Map.
    */

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

@@ -219,6 +219,18 @@ public final class EntityBeanIntercept implements Serializable {
     this.fullyLoadedBean = fullyLoadedBean;
   }
 
+  /**
+   * Check each property to see if the bean is partially loaded.
+   */
+  public boolean isPartial() {
+    for (int i = 0; i < loadedProps.length; i++) {
+      if (!loadedProps[i]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Return true if this bean has been directly modified (it has oldValues) or
    * if any embedded beans are either new or dirty (and hence need saving).
@@ -469,7 +481,7 @@ public final class EntityBeanIntercept implements Serializable {
   public void setLoadedProperty(int propertyIndex) {
     loadedProps[propertyIndex] = true;
   }
-  
+
   /**
    * Return true if the property is loaded.
    */
@@ -560,6 +572,23 @@ public final class EntityBeanIntercept implements Serializable {
     return props;
   }
 
+  /**
+   * Return the array of flags indicating the dirty properties.
+   */
+  public boolean[] getDirtyProperties() {
+    int len = getPropertyLength();
+    boolean[] dirties = new boolean[len];
+    for (int i = 0; i < len; i++) {
+      if (changedProps != null && changedProps[i]) {
+        dirties[i] = true;
+      } else if (embeddedDirty != null && embeddedDirty[i]) {
+        // an embedded property has been changed - recurse
+        dirties[i] = true;
+      }
+    }
+    return dirties;
+  }
+
   /**
    * Return the set of dirty properties.
    */

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

@@ -10,31 +10,31 @@ package com.avaje.ebean.bean;
 public interface PersistenceContext {
 
   /**
-   * Put the entity bean into the PersistanceContext.
+   * Put the entity bean into the PersistenceContext.
    */
-  void put(Object id, Object bean);
+  void put(Class<?> rootType, Object id, Object bean);
 
   /**
-   * Put the entity bean into the PersistanceContext if one is not already
+   * Put the entity bean into the PersistenceContext if one is not already
    * present (for this id).
    * <p>
    * Returns an existing entity bean (if one is already there) and otherwise
    * returns null.
    * </p>
    */
-  Object putIfAbsent(Object id, Object bean);
+  Object putIfAbsent(Class<?> rootType, Object id, Object bean);
 
   /**
    * Return an object given its type and unique id.
    */
-  Object get(Class<?> beanType, Object uid);
+  Object get(Class<?> rootType, Object uid);
 
   /**
    * Get the bean from the persistence context also checked to see if it had
    * been previously deleted (if so then you also can't hit the L2 cache to
    * fetch the bean for this particular persistence context).
    */
-  WithOption getWithOption(Class<?> beanType, Object uid);
+  WithOption getWithOption(Class<?> rootType, Object uid);
 
   /**
    * Clear all the references.
@@ -44,22 +44,22 @@ public interface PersistenceContext {
   /**
    * Clear all the references for a given type of entity bean.
    */
-  void clear(Class<?> beanType);
+  void clear(Class<?> rootType);
 
   /**
    * Clear the reference to a specific entity bean.
    */
-  void clear(Class<?> beanType, Object uid);
+  void clear(Class<?> rootType, Object uid);
 
   /**
    * Clear the reference as a result of an entity being deleted.
    */
-  void deleted(Class<?> beanType, Object id);
+  void deleted(Class<?> rootType, Object id);
 
   /**
    * Return the number of beans of the given type in the persistence context.
    */
-  int size(Class<?> beanType);
+  int size(Class<?> rootType);
 
   /**
    * Wrapper on a bean to also indicate if a bean has been deleted.

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

@@ -0,0 +1,21 @@
+package com.avaje.ebean.bean;
+
+import javax.persistence.Entity;
+
+/**
+ * Utility to find the root bean type.
+ */
+public class PersistenceContextUtil {
+
+  /**
+   * Find and return the root bean type for the given class.
+   */
+  public static Class<?> root(Class<?> beanType) {
+    Class<?> parent = beanType.getSuperclass();
+    while (parent != null && parent.isAnnotationPresent(Entity.class)) {
+      beanType = parent;
+      parent = parent.getSuperclass();
+    }
+    return beanType;
+  }
+}

src/main/java/com/avaje/ebean/cache/ServerCacheFactory.java

@@ -21,6 +21,6 @@ public interface ServerCacheFactory {
   /**
    * Create the cache for the given type with options.
    */
-  ServerCache createCache(String cacheKey, ServerCacheOptions cacheOptions);
+  ServerCache createCache(ServerCacheType type, String cacheKey, ServerCacheOptions cacheOptions);
 
 }

src/main/java/com/avaje/ebean/cache/ServerCacheOptions.java

@@ -1,5 +1,6 @@
 package com.avaje.ebean.cache;
 
+import com.avaje.ebean.annotation.CacheQueryTuning;
 import com.avaje.ebean.annotation.CacheTuning;
 
 /**
@@ -30,13 +31,13 @@ public class ServerCacheOptions {
   }
 
   /**
-   * Create merging default options with the deployment specified ones.
+   * Create from the cacheTuning deployment annotation.
    */
-  public ServerCacheOptions(ServerCacheOptions defaults) {
-    this.maxSize = defaults.getMaxSize();
-    this.maxIdleSecs = defaults.getMaxIdleSecs();
-    this.maxSecsToLive = defaults.getMaxIdleSecs();
-    this.trimFrequency = defaults.getTrimFrequency();
+  public ServerCacheOptions(CacheQueryTuning cacheTuning) {
+    this.maxSize = cacheTuning.maxSize();
+    this.maxIdleSecs = cacheTuning.maxIdleSecs();
+    this.maxSecsToLive = cacheTuning.maxSecsToLive();
+    this.trimFrequency = cacheTuning.trimFrequency();
   }
 
   /**

src/main/java/com/avaje/ebean/cache/ServerCacheType.java

@@ -0,0 +1,27 @@
+package com.avaje.ebean.cache;
+
+/**
+ * The type of L2 caches.
+ */
+public enum ServerCacheType {
+
+  /**
+   * Bean cache.
+   */
+  BEAN,
+
+  /**
+   * Natural key cache.
+   */
+  NATURAL_KEY,
+
+  /**
+   * Collection Ids for Many properties.
+   */
+  COLLECTION_IDS,
+
+  /**
+   * Query cache.
+   */
+  QUERY
+}

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

@@ -1,5 +1,10 @@
 package com.avaje.ebean.common;
 
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.bean.BeanCollectionAdd;
+import com.avaje.ebean.bean.BeanCollectionLoader;
+import com.avaje.ebean.bean.EntityBean;
+
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -8,17 +13,13 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 
-import com.avaje.ebean.bean.BeanCollectionAdd;
-import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
-
 /**
  * List capable of lazy loading.
  */
 public final class BeanList<E> extends AbstractBeanCollection<E> implements List<E>, BeanCollectionAdd {
 
   private static final long serialVersionUID = 1L;
-  
+
   /**
    * The underlying List implementation.
    */
@@ -64,6 +65,15 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     list.add((E) bean);
   }
 
+  @Override
+  @SuppressWarnings("unchecked")
+  public void loadFrom(BeanCollection<?> other) {
+    if (list == null) {
+      list = new ArrayList<E>();
+    }
+    list.addAll((Collection<? extends E>) other.getActualDetails());
+  }
+
   @SuppressWarnings("unchecked")
   public void internalAdd(Object bean) {
     if (list == null) {
@@ -74,6 +84,13 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     }
   }
 
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    if (list == null || !list.contains(bean)) {
+      internalAdd(bean);
+    }
+  }
+
   public boolean checkEmptyLazyLoad() {
     if (list == null) {
       list = new ArrayList<E>();
@@ -99,11 +116,11 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   private void initAsUntouched() {
     init(false);
   }
-  
+
   private void init() {
     init(true);
   }
-  
+
   private void init(boolean setTouched) {
     synchronized (this) {
       if (list == null) {
@@ -134,7 +151,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   public Collection<E> getActualDetails() {
     return list;
   }
-  
+
   @Override
   public Collection<?> getActualEntries() {
     return list;

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

@@ -1,5 +1,6 @@
 package com.avaje.ebean.common;
 
+import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.BeanCollectionLoader;
 import com.avaje.ebean.bean.EntityBean;
 
@@ -51,6 +52,14 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
     return !touched && (map == null || map.isEmpty());
   }
 
+  @Override
+  @SuppressWarnings("unchecked")
+  public void loadFrom(BeanCollection<?> other) {
+    BeanMap<K,E> otherMap = (BeanMap<K,E>)other;
+    internalPutNull();
+    map.putAll(otherMap.getActualMap());
+  }
+
   public void internalPutNull() {
     if (map == null) {
       map = new LinkedHashMap<K, E>();
@@ -66,7 +75,18 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
       map.put((K) key, (E) bean);
     }
   }
-  
+
+  public void internalPutWithCheck(Object key, Object bean) {
+    if (map == null || !map.containsKey(key)) {
+      internalPut(key, bean);
+    }
+  }
+
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    throw new RuntimeException("Not allowed for map");
+  }
+
   public void internalAdd(Object bean) {
     throw new RuntimeException("Not allowed for map");
   }

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

@@ -1,15 +1,16 @@
 package com.avaje.ebean.common;
 
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.bean.BeanCollectionAdd;
+import com.avaje.ebean.bean.BeanCollectionLoader;
+import com.avaje.ebean.bean.EntityBean;
+
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Set;
 
-import com.avaje.ebean.bean.BeanCollectionAdd;
-import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
-
 /**
  * Set capable of lazy loading.
  */
@@ -57,6 +58,22 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
     set.add((E) bean);
   }
 
+  @Override
+  @SuppressWarnings("unchecked")
+  public void loadFrom(BeanCollection<?> other) {
+    if (set == null) {
+      set = new LinkedHashSet<E>();
+    }
+    set.addAll((Collection<? extends E>) other.getActualDetails());
+  }
+
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    if (set == null || !set.contains(bean)) {
+      internalAdd(bean);
+    }
+  }
+
   @SuppressWarnings("unchecked")
   public void internalAdd(Object bean) {
     if (set == null) {
@@ -107,11 +124,11 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   private void initAsUntouched() {
     init(false);
   }
-  
+
   private void init() {
     init(true);
   }
-  
+
   private void init(boolean setTouched) {
     synchronized (this) {
       if (set == null) {

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

@@ -1,6 +1,10 @@
 package com.avaje.ebean.config;
 
 
+import java.io.IOException;
+import java.net.URL;
+import java.util.Enumeration;
+
 /**
  * Helper to find classes taking into account the context class loader.
  */
@@ -29,6 +33,13 @@ public class ClassLoadConfig {
     return isPresent("java.time.LocalDate");
   }
 
+  /**
+   * Return true if Java7 is present.
+   */
+  public boolean isJava7Present() {
+    return isPresent("java.nio.file.Path");
+  }
+
   /**
    * Return true if the Joda types are available and should be supported.
    */
@@ -70,6 +81,13 @@ public class ClassLoadConfig {
     }
   }
 
+  /**
+   * Return the resources for the given name.
+   */
+  public Enumeration<URL> getResources(String name) throws IOException {
+    return context.getResources(name);
+  }
+
   /**
    * Return true if the given class is present.
    */
@@ -90,6 +108,13 @@ public class ClassLoadConfig {
     return context.forName(name);
   }
 
+  /**
+   * Return the classLoader to use for service loading etc.
+   */
+  public ClassLoader getClassLoader() {
+    return context.getClassLoader();
+  }
+
   /**
    * Wraps the preferred, caller and context class loaders.
    */
@@ -115,6 +140,13 @@ public class ClassLoadConfig {
       return (loader != null) ? loader: callerLoader;
     }
 
+    Enumeration<URL> getResources(String name) throws IOException {
+      if (preferredLoader != null) {
+        return preferredLoader.getResources(name);
+      }
+      return contextLoader().getResources(name);
+    }
+
     Class<?> forName(String name) throws ClassNotFoundException {
 
       if (preferredLoader != null) {
@@ -138,6 +170,9 @@ public class ClassLoadConfig {
       return Class.forName(name, true, classLoader);
     }
 
+    ClassLoader getClassLoader() {
+      return preferredLoader != null ? preferredLoader : contextLoader;
+    }
   }
 }
 

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

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

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

@@ -1,556 +0,0 @@
-package com.avaje.ebean.config;
-
-import java.sql.Connection;
-import java.util.Map;
-import java.util.Properties;
-
-import com.avaje.ebean.Transaction;
-import com.avaje.ebean.util.StringHelper;
-
-/**
- * Used to config a DataSource when using the internal Ebean DataSource
- * implementation.
- * <p>
- * If a DataSource instance is already defined via
- * {@link ServerConfig#setDataSource(javax.sql.DataSource)} or defined as JNDI
- * dataSource via {@link ServerConfig#setDataSourceJndiName(String)} then those
- * will used and not this DataSourceConfig.
- * </p>
- */
-public class DataSourceConfig {
-
-  private String url;
-
-  private String username;
-
-  private String password;
-
-  private String driver;
-
-  private int minConnections = 2;
-
-  private int maxConnections = 20;
-
-  private int isolationLevel = Transaction.READ_COMMITTED;
-
-  private boolean autoCommit;
-  
-  private String heartbeatSql;
-  
-  private int heartbeatFreqSecs = 30;
-  
-  private int heartbeatTimeoutSeconds = 3;
-  
-  private boolean captureStackTrace;
-
-  private int maxStackTraceSize = 5;
-
-  private int leakTimeMinutes = 30;
-
-  private int maxInactiveTimeSecs = 720;
-  
-  private int maxAgeMinutes = 0;
-  
-  private int trimPoolFreqSecs = 59;
-
-  private int pstmtCacheSize = 20;
-  
-  private int cstmtCacheSize = 20;
-
-  private int waitTimeoutMillis = 1000;
-  
-  private String poolListener;
-
-  private boolean offline;
-  
-  protected Map<String, String> customProperties;
-
-  /**
-   * Return the connection URL.
-   */
-  public String getUrl() {
-    return url;
-  }
-
-  /**
-   * Set the connection URL.
-   */
-  public void setUrl(String url) {
-    this.url = url;
-  }
-
-  /**
-   * Return the database username.
-   */
-  public String getUsername() {
-    return username;
-  }
-
-  /**
-   * Set the database username.
-   */
-  public void setUsername(String username) {
-    this.username = username;
-  }
-
-  /**
-   * Return the database password.
-   */
-  public String getPassword() {
-    return password;
-  }
-
-  /**
-   * Set the database password.
-   */
-  public void setPassword(String password) {
-    this.password = password;
-  }
-
-  /**
-   * Return the database driver.
-   */
-  public String getDriver() {
-    return driver;
-  }
-
-  /**
-   * Set the database driver.
-   */
-  public void setDriver(String driver) {
-    this.driver = driver;
-  }
-
-  /**
-   * Return the transaction isolation level.
-   */
-  public int getIsolationLevel() {
-    return isolationLevel;
-  }
-
-  /**
-   * Set the transaction isolation level.
-   */
-  public void setIsolationLevel(int isolationLevel) {
-    this.isolationLevel = isolationLevel;
-  }
-  
-  /**
-   * Return autoCommit setting.
-   */
-  public boolean isAutoCommit() {
-    return autoCommit;
-  }
-
-  /**
-   * Set to true to turn on autoCommit.
-   */
-  public void setAutoCommit(boolean autoCommit) {
-    this.autoCommit = autoCommit;
-  }
-
-  /**
-   * Return the minimum number of connections the pool should maintain.
-   */
-  public int getMinConnections() {
-    return minConnections;
-  }
-
-  /**
-   * Set the minimum number of connections the pool should maintain.
-   */
-  public void setMinConnections(int minConnections) {
-    this.minConnections = minConnections;
-  }
-
-  /**
-   * Return the maximum number of connections the pool can reach.
-   */
-  public int getMaxConnections() {
-    return maxConnections;
-  }
-
-  /**
-   * Set the maximum number of connections the pool can reach.
-   */
-  public void setMaxConnections(int maxConnections) {
-    this.maxConnections = maxConnections;
-  }
-
-  /**
-   * Return a SQL statement used to test the database is accessible.
-   * <p>
-   * Note that if this is not set then it can get defaulted from the
-   * DatabasePlatform.
-   * </p>
-   */
-  public String getHeartbeatSql() {
-    return heartbeatSql;
-  }
-
-  /**
-   * Set a SQL statement used to test the database is accessible.
-   * <p>
-   * Note that if this is not set then it can get defaulted from the
-   * DatabasePlatform.
-   * </p>
-   */
-  public void setHeartbeatSql(String heartbeatSql) {
-    this.heartbeatSql = heartbeatSql;
-  }
-
-  
-  /**
-   * Return the heartbeat frequency in seconds.
-   * <p>
-   * This is the expected frequency in which the DataSource should be checked to
-   * make sure it is healthy and trim idle connections.
-   * </p>
-   */
-  public int getHeartbeatFreqSecs() {
-    return heartbeatFreqSecs;
-  }
-
-  /**
-   * Set the expected heartbeat frequency in seconds.
-   */
-  public void setHeartbeatFreqSecs(int heartbeatFreqSecs) {
-    this.heartbeatFreqSecs = heartbeatFreqSecs;
-  }
-  
-  /**
-   * Return the heart beat timeout in seconds.
-   */
-  public int getHeartbeatTimeoutSeconds() {
-    return heartbeatTimeoutSeconds;
-  }
-
-  /**
-   * Set the heart beat timeout in seconds.
-   */
-  public void setHeartbeatTimeoutSeconds(int heartbeatTimeoutSeconds) {
-    this.heartbeatTimeoutSeconds = heartbeatTimeoutSeconds;
-  }
-
-  /**
-   * Return true if a stack trace should be captured when obtaining a connection
-   * from the pool.
-   * <p>
-   * This can be used to diagnose a suspected connection pool leak.
-   * </p>
-   * <p>
-   * Obviously this has a performance overhead.
-   * </p>
-   */
-  public boolean isCaptureStackTrace() {
-    return captureStackTrace;
-  }
-
-  /**
-   * Set to true if a stack trace should be captured when obtaining a connection
-   * from the pool.
-   * <p>
-   * This can be used to diagnose a suspected connection pool leak.
-   * </p>
-   * <p>
-   * Obviously this has a performance overhead.
-   * </p>
-   */
-  public void setCaptureStackTrace(boolean captureStackTrace) {
-    this.captureStackTrace = captureStackTrace;
-  }
-
-  /**
-   * Return the max size for reporting stack traces on busy connections.
-   */
-  public int getMaxStackTraceSize() {
-    return maxStackTraceSize;
-  }
-
-  /**
-   * Set the max size for reporting stack traces on busy connections.
-   */
-  public void setMaxStackTraceSize(int maxStackTraceSize) {
-    this.maxStackTraceSize = maxStackTraceSize;
-  }
-
-  /**
-   * Return the time in minutes after which a connection could be considered to
-   * have leaked.
-   */
-  public int getLeakTimeMinutes() {
-    return leakTimeMinutes;
-  }
-
-  /**
-   * Set the time in minutes after which a connection could be considered to
-   * have leaked.
-   */
-  public void setLeakTimeMinutes(int leakTimeMinutes) {
-    this.leakTimeMinutes = leakTimeMinutes;
-  }
-
-  /**
-   * Return the size of the PreparedStatement cache (per connection).
-   */
-  public int getPstmtCacheSize() {
-    return pstmtCacheSize;
-  }
-
-  /**
-   * Set the size of the PreparedStatement cache (per connection).
-   */
-  public void setPstmtCacheSize(int pstmtCacheSize) {
-    this.pstmtCacheSize = pstmtCacheSize;
-  }
-
-  /**
-   * Return the size of the CallableStatement cache (per connection).
-   */
-  public int getCstmtCacheSize() {
-    return cstmtCacheSize;
-  }
-
-  /**
-   * Set the size of the CallableStatement cache (per connection).
-   */
-  public void setCstmtCacheSize(int cstmtCacheSize) {
-    this.cstmtCacheSize = cstmtCacheSize;
-  }
-
-  /**
-   * Return the time in millis to wait for a connection before timing out once
-   * the pool has reached its maximum size.
-   */
-  public int getWaitTimeoutMillis() {
-    return waitTimeoutMillis;
-  }
-
-  /**
-   * Set the time in millis to wait for a connection before timing out once the
-   * pool has reached its maximum size.
-   */
-  public void setWaitTimeoutMillis(int waitTimeoutMillis) {
-    this.waitTimeoutMillis = waitTimeoutMillis;
-  }
-
-  /**
-   * Return the time in seconds a connection can be idle after which it can be
-   * trimmed from the pool.
-   * <p>
-   * This is so that the pool after a busy period can trend over time back
-   * towards the minimum connections.
-   * </p>
-   */
-  public int getMaxInactiveTimeSecs() {
-    return maxInactiveTimeSecs;
-  }
-
-  /**
-   * Return the maximum age a connection is allowed to be before it is closed.
-   * <p>
-   * This can be used to close really old connections.
-   * </p>
-   */
-  public int getMaxAgeMinutes() {
-    return maxAgeMinutes;
-  }
-  
-  /**
-   * Set the maximum age a connection can be in minutes.
-   */
-  public void setMaxAgeMinutes(int maxAgeMinutes) {
-    this.maxAgeMinutes = maxAgeMinutes;
-  }
-
-  /**
-   * Set the time in seconds a connection can be idle after which it can be
-   * trimmed from the pool.
-   * <p>
-   * This is so that the pool after a busy period can trend over time back
-   * towards the minimum connections.
-   * </p>
-   */
-  public void setMaxInactiveTimeSecs(int maxInactiveTimeSecs) {
-    this.maxInactiveTimeSecs = maxInactiveTimeSecs;
-  }
-
-  
-  /**
-   * Return the minimum time gap between pool trim checks.
-   * <p>
-   * This defaults to 59 seconds meaning that the pool trim check will run every
-   * minute assuming the heart beat check runs every 30 seconds.
-   * </p>
-   */
-  public int getTrimPoolFreqSecs() {
-    return trimPoolFreqSecs;
-  }
-
-  /**
-   * Set the minimum trim gap between pool trim checks.
-   */
-  public void setTrimPoolFreqSecs(int trimPoolFreqSecs) {
-    this.trimPoolFreqSecs = trimPoolFreqSecs;
-  }
-
-  /**
-   * Return the pool listener.
-   */
-  public String getPoolListener() {
-    return poolListener;
-  }
-
-  /**
-   * Set a pool listener.
-   */
-  public void setPoolListener(String poolListener) {
-    this.poolListener = poolListener;
-  }
-
-  /**
-   * Return true if the DataSource should be left offline.
-   * <p>
-   * This is to support DDL generation etc without having a real database.
-   * </p>
-   */
-  public boolean isOffline() {
-    return offline;
-  }
-
-  /**
-   * Set to true if the DataSource should be left offline.
-   * <p>
-   * This is to support DDL generation etc without having a real database.
-   * </p>
-   * <p>
-   * Note that you MUST specify the database platform name (oracle, postgres,
-   * h2, mysql etc) using {@link ServerConfig#setDatabasePlatformName(String)}
-   * when you do this.
-   * </p>
-   */
-  public void setOffline(boolean offline) {
-    this.offline = offline;
-  }
-  
-  /**
-   * Return a map of custom properties for the jdbc driver connection.
-   */
-  public Map<String, String> getCustomProperties() {
-    return customProperties;
-  }
-
-  /**
-   * Set custom properties for the jdbc driver connection.
-   * 
-   * @param customProperties
-   */
-  public void setCustomProperties(Map<String, String> customProperties) {
-    this.customProperties = customProperties;
-  }
-
-  /**
-   * Load the settings by reading the ebean.properties file.
-   *
-   * @param serverName name of the server
-   */
-  public void loadSettings(String serverName) {
-    loadSettings(new PropertiesWrapper("datasource", serverName, PropertyMap.defaultProperties()));
-  }
-
-  /**
-   * Load the settings from the properties supplied.
-   * <p>
-   * You can use this when you have your own properties to use for configuration.
-   * </p>
-   *
-   * @param properties the properties to configure the datasource
-   * @param serverName the name of the specific datasource (optional)
-   */
-  public void loadSettings(Properties properties, String serverName) {
-    PropertiesWrapper dbProps = new PropertiesWrapper("datasource", serverName, properties);
-    loadSettings(dbProps);
-  }
-
-  /**
-   * Load the settings from the PropertiesWrapper.
-   */
-  public void loadSettings(PropertiesWrapper properties) {
-
-    username = properties.get("username", username);
-    password = properties.get("password", password);
-    driver = properties.get("driver", properties.get("databaseDriver", driver));
-    url = properties.get("url", properties.get("databaseUrl", url));
-
-    autoCommit = properties.getBoolean("autoCommit", autoCommit);
-    captureStackTrace = properties.getBoolean("captureStackTrace", captureStackTrace);
-    maxStackTraceSize = properties.getInt("maxStackTraceSize", maxStackTraceSize);
-    leakTimeMinutes = properties.getInt("leakTimeMinutes", leakTimeMinutes);
-    maxInactiveTimeSecs = properties.getInt("maxInactiveTimeSecs", maxInactiveTimeSecs);
-    trimPoolFreqSecs = properties.getInt("trimPoolFreqSecs", trimPoolFreqSecs);
-    maxAgeMinutes = properties.getInt("maxAgeMinutes", maxAgeMinutes);
-
-    minConnections = properties.getInt("minConnections", minConnections);
-    maxConnections = properties.getInt("maxConnections", maxConnections);
-    pstmtCacheSize = properties.getInt("pstmtCacheSize", pstmtCacheSize);
-    cstmtCacheSize = properties.getInt("cstmtCacheSize", cstmtCacheSize);
-
-    waitTimeoutMillis = properties.getInt("waitTimeout", waitTimeoutMillis);
-
-    heartbeatSql = properties.get("heartbeatSql", heartbeatSql);
-    heartbeatTimeoutSeconds =  properties.getInt("heartbeatTimeoutSeconds", heartbeatTimeoutSeconds);
-    poolListener = properties.get("poolListener", poolListener);
-    offline = properties.getBoolean("offline", offline);
-
-    String isoLevel = properties.get("isolationlevel", getTransactionIsolationLevel(isolationLevel));
-    this.isolationLevel = getTransactionIsolationLevel(isoLevel);
-
-    String customProperties = properties.get("customProperties", null);
-    if (customProperties != null && customProperties.length() > 0) {
-      this.customProperties = StringHelper.delimitedToMap(customProperties, ";", "=");
-    }
-
-  }
-
-  /**
-   * Return the isolation level description from the associated Connection int value.
-   */
-  public String getTransactionIsolationLevel(int level) {
-    switch (level) {
-      case Connection.TRANSACTION_NONE : return "NONE";
-      case Connection.TRANSACTION_READ_COMMITTED : return "READ_COMMITTED";
-      case Connection.TRANSACTION_READ_UNCOMMITTED : return "READ_UNCOMMITTED";
-      case Connection.TRANSACTION_REPEATABLE_READ : return "REPEATABLE_READ";
-      case Connection.TRANSACTION_SERIALIZABLE : return "SERIALIZABLE";
-      default: throw new RuntimeException("Transaction Isolation level [" + level + "] is not known.");
-    }
-  }
-
-  /**
-   * Return the isolation level for a given string description.
-   */
-  public int getTransactionIsolationLevel(String level) {
-    level = level.toUpperCase();
-    if (level.startsWith("TRANSACTION")) {
-      level = level.substring("TRANSACTION".length());
-    }
-    level = level.replace("_", "");
-    if ("NONE".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_NONE;
-    }
-    if ("READCOMMITTED".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_READ_COMMITTED;
-    }
-    if ("READUNCOMMITTED".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_READ_UNCOMMITTED;
-    }
-    if ("REPEATABLEREAD".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_REPEATABLE_READ;
-    }
-    if ("SERIALIZABLE".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_SERIALIZABLE;
-    }
-
-    throw new RuntimeException("Transaction Isolation level [" + level + "] is not known.");
-  }
-}

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

@@ -6,6 +6,8 @@ import com.avaje.ebean.dbmigration.DbMigration;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Map;
+
 /**
  * Configuration for the DB migration processing.
  */
@@ -67,6 +69,36 @@ public class DbMigrationConfig {
    */
   protected String generatePendingDrop;
 
+  /**
+   * For running migration the DB table that holds migration execution status.
+   */
+  protected String metaTable = "db_migration";
+
+  /**
+   * Flag set to true means to run any outstanding migrations on startup.
+   */
+  protected boolean runMigration;
+
+  /**
+   * Comma and equals delimited key/value placeholders to replace in DDL scripts.
+   */
+  protected String runPlaceholders;
+
+  /**
+   * Map of key/value placeholders to replace in DDL scripts.
+   */
+  protected Map<String,String> runPlaceholderMap;
+
+  /**
+   * DB user used to run the DB migration.
+   */
+  protected String dbUser;
+
+  /**
+   * DB password used to run the DB migration.
+   */
+  protected String dbPassword;
+
   /**
    * Return the DB platform to generate migration DDL for.
    *
@@ -199,10 +231,119 @@ public class DbMigrationConfig {
     this.modelPath = "";
   }
 
+  /**
+   * Return the table name that holds the migration run details
+   * (used by DB Migration runner only).
+   */
+  public String getMetaTable() {
+    return metaTable;
+  }
+
+  /**
+   * Set the table name that holds the migration run details
+   * (used by DB Migration runner only).
+   */
+  public void setMetaTable(String metaTable) {
+    this.metaTable = metaTable;
+  }
+
+  /**
+   * Return a comma and equals delimited placeholders that are substituted in SQL scripts when running migration
+   * (used by DB Migration runner only).
+   */
+  public String getRunPlaceholders() {
+    // environment properties take precedence
+    String placeholders = readEnvironment("ddl.migration.placeholders");
+    if (placeholders != null) {
+      return placeholders;
+    }
+    return runPlaceholders;
+  }
+
+  /**
+   * Set a comma and equals delimited placeholders that are substituted in SQL scripts when running migration
+   * (used by DB Migration runner only).
+   */
+  public void setRunPlaceholders(String runPlaceholders) {
+    this.runPlaceholders = runPlaceholders;
+  }
+
+  /**
+   * Return a map of placeholder values that are substituted in SQL scripts when running migration
+   * (used by DB Migration runner only).
+   */
+  public Map<String, String> getRunPlaceholderMap() {
+    return runPlaceholderMap;
+  }
+
+  /**
+   * Set a map of placeholder values that are substituted when running migration
+   * (used by DB Migration runner only).
+   */
+  public void setRunPlaceholderMap(Map<String, String> runPlaceholderMap) {
+    this.runPlaceholderMap = runPlaceholderMap;
+  }
+
+  /**
+   * Return true if the DB migration should be run on startup.
+   */
+  public boolean isRunMigration() {
+    // environment properties take precedence
+    String run = readEnvironment("ddl.migration.run");
+    if (run != null) {
+      return "true".equalsIgnoreCase(run.trim());
+    }
+    return runMigration;
+  }
+
+  /**
+   * Set to true to run the DB migration on startup.
+   */
+  public void setRunMigration(boolean runMigration) {
+    this.runMigration = runMigration;
+  }
+
+  /**
+   * Return the DB user to use for running DB migrations.
+   */
+  public String getDbUser() {
+    // environment properties take precedence
+    String user = readEnvironment("ddl.migration.user");
+    if (user != null) {
+      return user;
+    }
+    return dbUser;
+  }
+
+  /**
+   * Set the DB user to use for running DB migrations.
+   */
+  public void setDbUser(String dbUser) {
+    this.dbUser = dbUser;
+  }
+
+  /**
+   * Return the DB password to use for running DB migrations.
+   */
+  public String getDbPassword() {
+    String user = readEnvironment("ddl.migration.password");
+    if (user != null) {
+      return user;
+    }
+    return dbPassword;
+  }
+
+  /**
+   * Set the DB password to use for running DB migrations.
+   */
+  public void setDbPassword(String dbPassword) {
+    this.dbPassword = dbPassword;
+  }
+
   /**
    * Load the settings from the PropertiesWrapper.
    */
-  public void loadSettings(PropertiesWrapper properties) {
+  public void loadSettings(PropertiesWrapper properties, String serverName) {
 
     migrationPath = properties.get("migration.migrationPath", migrationPath);
     if (properties.getBoolean("migration.singleDirectory", false)) {
@@ -219,7 +360,19 @@ public class DbMigrationConfig {
 
     generate = properties.getBoolean("migration.generate", generate);
     version = properties.get("migration.version", version);
-    name = properties.get("migration.name", name);
+    this.name = properties.get("migration.name", this.name);
+
+    runMigration = properties.getBoolean("migration.run", runMigration);
+    metaTable = properties.get("migration.metaTable", metaTable);
+    runPlaceholders = properties.get("migration.placeholders", runPlaceholders);
+
+    String adminUser = properties.get("datasource."+serverName+".username", dbUser);
+    adminUser = properties.get("datasource."+serverName+".adminusername", adminUser);
+    dbUser = properties.get("migration.dbuser", adminUser);
+
+    String adminPwd = properties.get("datasource."+serverName+".password", dbPassword);
+    adminPwd = properties.get("datasource."+serverName+".adminpassword", adminPwd);
+    dbPassword = properties.get("migration.dbpassword", adminPwd);
   }
 
   /**

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

@@ -0,0 +1,248 @@
+package com.avaje.ebean.config;
+
+import com.avaje.ebean.annotation.DocStoreMode;
+
+/**
+ * Configuration for the Document store integration (e.g. ElasticSearch).
+ */
+public class DocStoreConfig {
+
+  /**
+   * True when the Document store integration is active/on.
+   */
+  protected boolean active;
+
+  /**
+   * Set to true means Ebean will generate mapping files on startup.
+   */
+  protected boolean generateMapping;
+
+  /**
+   * When true the Document store should drop and re-create document indexes.
+   */
+  protected boolean dropCreate;
+
+  /**
+   * When true the Document store should create any document indexes that don't already exist.
+   */
+  protected boolean create;
+
+  /**
+   * The URL of the Document store server. For example: http://localhost:9200.
+   */
+  protected String url;
+
+  /**
+   * The default mode used by indexes.
+   */
+  protected DocStoreMode persist = DocStoreMode.UPDATE;
+
+  /**
+   * The default batch size to use for the Bulk API calls.
+   */
+  protected int bulkBatchSize = 1000;
+
+  /**
+   * Resource path for the Document store mapping files.
+   */
+  protected String mappingPath;
+
+  /**
+   * Suffix used for mapping files.
+   */
+  protected String mappingSuffix;
+
+  /**
+   * Location of resources that mapping files are generated into.
+   */
+  protected String pathToResources = "src/main/resources";
+
+  /**
+   * Return true if the Document store (ElasticSearch) integration is active.
+   */
+  public boolean isActive() {
+    String systemValue = System.getProperty("ebean.docstore.active");
+    if (systemValue != null) {
+      return Boolean.parseBoolean(systemValue);
+    }
+    return active;
+  }
+
+  /**
+   * Set to true to make the Document store (ElasticSearch) integration active.
+   */
+  public void setActive(boolean active) {
+    this.active = active;
+  }
+
+  /**
+   * Return the URL to the Document store.
+   */
+  public String getUrl() {
+    String systemValue = System.getProperty("ebean.docstore.url");
+    if (systemValue != null) {
+      return systemValue;
+    }
+
+    return url;
+  }
+
+  /**
+   * Set the URL to the Document store server.
+   * <p>
+   * For a local ElasticSearch server this would be: http://localhost:9200
+   */
+  public void setUrl(String url) {
+    this.url = url;
+  }
+
+  /**
+   * Return true if Ebean should generate mapping files on server startup.
+   */
+  public boolean isGenerateMapping() {
+    return generateMapping;
+  }
+
+  /**
+   * Set to true if Ebean should generate mapping files on server startup.
+   */
+  public void setGenerateMapping(boolean generateMapping) {
+    this.generateMapping = generateMapping;
+  }
+
+  /**
+   * Return true if the document store should recreate mapped indexes.
+   */
+  public boolean isDropCreate() {
+    return dropCreate;
+  }
+
+  /**
+   * Set to true if the document store should recreate mapped indexes.
+   */
+  public void setDropCreate(boolean dropCreate) {
+    this.dropCreate = dropCreate;
+  }
+
+  /**
+   * Create true if the document store should create mapped indexes that don't yet exist.
+   * This is only used if dropCreate is false.
+   */
+  public boolean isCreate() {
+    return create;
+  }
+
+  /**
+   * Set to true if the document store should create mapped indexes that don't yet exist.
+   * This is only used if dropCreate is false.
+   */
+  public void setCreate(boolean create) {
+    this.create = create;
+  }
+
+  /**
+   * Return the default batch size to use for calls to the Bulk API.
+   */
+  public int getBulkBatchSize() {
+    return bulkBatchSize;
+  }
+
+  /**
+   * Set the default batch size to use for calls to the Bulk API.
+   * <p>
+   * The batch size can be set on a transaction via {@link com.avaje.ebean.Transaction#setDocStoreBatchSize(int)}.
+   * </p>
+   */
+  public void setBulkBatchSize(int bulkBatchSize) {
+    this.bulkBatchSize = bulkBatchSize;
+  }
+
+  /**
+   * Return the mapping path.
+   */
+  public String getMappingPath() {
+    return mappingPath;
+  }
+
+  /**
+   * Set the mapping path.
+   */
+  public void setMappingPath(String mappingPath) {
+    this.mappingPath = mappingPath;
+  }
+
+  /**
+   * Return the mapping suffix.
+   */
+  public String getMappingSuffix() {
+    return mappingSuffix;
+  }
+
+  /**
+   * Set the mapping suffix.
+   */
+  public void setMappingSuffix(String mappingSuffix) {
+    this.mappingSuffix = mappingSuffix;
+  }
+
+  /**
+   * Return the relative file system path to resources when generating mapping files.
+   */
+  public String getPathToResources() {
+    return pathToResources;
+  }
+
+  /**
+   * Set the relative file system path to resources when generating mapping files.
+   */
+  public void setPathToResources(String pathToResources) {
+    this.pathToResources = pathToResources;
+  }
+
+  /**
+   * Return the default behavior for when Insert, Update and Delete events occur on beans that have an associated
+   * Document store.
+   */
+  public DocStoreMode getPersist() {
+    return persist;
+  }
+
+  /**
+   * Set the default behavior for when Insert, Update and Delete events occur on beans that have an associated
+   * Document store.
+   * <ul>
+   * <li>DocStoreEvent.UPDATE - build and send message to Bulk API</li>
+   * <li>DocStoreEvent.QUEUE - add an entry with the index type and id only into a queue for later processing</li>
+   * <li>DocStoreEvent.IGNORE - ignore. Most likely used when some scheduled batch job handles updating the index</li>
+   * </ul>
+   * <p>
+   * You might choose to use QUEUE if that particular index data is updating very frequently or the cost of indexing
+   * is expensive.  Setting it to QUEUE can mean many changes can be batched together potentially coalescing multiple
+   * updates for an index entry into a single update.
+   * </p>
+   * <p>
+   * You might choose to use IGNORE when you have your own external process for updating the indexes. In this case
+   * you don't want Ebean to do anything when the data changes.
+   * </p>
+   */
+  public void setPersist(DocStoreMode persist) {
+    this.persist = persist;
+  }
+
+  /**
+   * Load settings specified in properties files.
+   */
+  public void loadSettings(PropertiesWrapper properties) {
+
+    active = properties.getBoolean("docstore.active", active);
+    url = properties.get("docstore.url", url);
+    persist = properties.getEnum(DocStoreMode.class, "docstore.persist", persist);
+    bulkBatchSize = properties.getInt("docstore.bulkBatchSize", bulkBatchSize);
+    generateMapping = properties.getBoolean("docstore.generateMapping", generateMapping);
+    dropCreate = properties.getBoolean("docstore.dropCreate", dropCreate);
+    create = properties.getBoolean("docstore.create", create);
+    mappingPath = properties.get("docstore.mappingPath", mappingPath);
+    mappingSuffix = properties.get("docstore.mappingSuffix", mappingSuffix);
+    pathToResources = properties.get("docstore.pathToResources", pathToResources);
+  }
+}

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

@@ -31,6 +31,11 @@ public final class PropertyMap implements Serializable {
     return (propertyMap == null) ? new Properties() : propertyMap.asProperties();
   }
 
+  public static boolean loadTestProperties() {
+    String disable = System.getProperty("disableTestProperties");
+    return (disable == null || !disable.equalsIgnoreCase("true"));
+  }
+
   public String toString() {
     return map.toString();
   }

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

@@ -18,6 +18,9 @@ final class PropertyMapLoader {
    * Load the <code>test-ebean.properties</code>.
    */
   public static PropertyMap loadTestProperties() {
+    if (!PropertyMap.loadTestProperties()) {
+      return new PropertyMap();
+    }
     return load(null, "test-ebean.properties");
   }
 
@@ -31,7 +34,7 @@ final class PropertyMapLoader {
     if (fileName == null) {
       fileName = System.getProperty("ebean.props.file");
       if (fileName == null) {
-        loadTestProperties = true;
+        loadTestProperties = PropertyMap.loadTestProperties();
         fileName = "ebean.properties";
       }
     }

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

@@ -22,11 +22,16 @@ import com.avaje.ebean.event.readaudit.ReadAuditLogger;
 import com.avaje.ebean.event.readaudit.ReadAuditPrepare;
 import com.avaje.ebean.meta.MetaInfoManager;
 import com.fasterxml.jackson.core.JsonFactory;
+import org.avaje.datasource.DataSourceConfig;
 
 import javax.sql.DataSource;
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.Properties;
+import java.util.ServiceLoader;
 
 /**
  * The configuration used for creating a EbeanServer.
@@ -79,6 +84,12 @@ public class ServerConfig {
    */
   private String name;
 
+  /**
+   * Typically configuration type objects that are passed by this ServerConfig
+   * to plugins. For example - IgniteConfiguration passed to Ignite plugin.
+   */
+  private Map<String,Object> serviceObject = new HashMap<String, Object>();
+
   private ContainerConfig containerConfig;
 
   /**
@@ -129,6 +140,11 @@ public class ServerConfig {
    */
   private String classPathReaderClassName;
 
+  /**
+   * Configuration for the ElasticSearch integration.
+   */
+  private DocStoreConfig docStoreConfig = new DocStoreConfig();
+
   /**
    * This is used to populate @WhoCreated, @WhoModified and
    * support other audit features (who executed a query etc).
@@ -208,6 +224,11 @@ public class ServerConfig {
 
   private boolean eagerFetchLobs;
 
+  /**
+   * Timezone used to get/set Timestamp values via JDBC.
+   */
+  private String dataTimeZone;
+
   private boolean ddlGenerate;
 
   private boolean ddlRun;
@@ -283,7 +304,7 @@ public class ServerConfig {
   private DbConstraintNaming constraintNaming = new DbConstraintNaming();
 
   /** 
-   * Behaviour of update to include on the change properties. 
+   * Behaviour of update to include on the change properties.
    */
   private boolean updateChangesOnly = true;
 
@@ -387,12 +408,36 @@ public class ServerConfig {
    */
   private boolean expressionEqualsWithNullAsNoop;
 
+  private String jodaLocalTimeMode;
+
+  /**
+   * Set to true to globally disable L2 caching (typically for performance testing).
+   */
+  private boolean disableL2Cache;
+
   /**
    * Construct a Server Configuration for programmatically creating an EbeanServer.
    */
   public ServerConfig() {
 
   }
+
+  /**
+   * Put a service object into configuration such that it can be passed to a plugin.
+   * <p>
+   * For example, put IgniteConfiguration in to be passed to the Ignite plugin.
+   * </p>
+   */
+  public void putServiceObject(String key, Object configObject) {
+    serviceObject.put(key, configObject);
+  }
+
+  /**
+   * Return the service object given the key.
+   */
+  public Object getServiceObject(String key) {
+    return serviceObject.get(key);
+  }
   
   /**
    * Return the Jackson JsonFactory to use.
@@ -801,6 +846,23 @@ public class ServerConfig {
     this.migrationConfig = migrationConfig;
   }
 
+  /**
+   * Return the time zone to use when reading/writing Timestamps via JDBC.
+   * <p>
+   * When set a Calendar object is used in JDBC calls when reading/writing Timestamp objects.
+   * </p>
+   */
+  public String getDataTimeZone() {
+    return System.getProperty("ebean.dataTimeZone", dataTimeZone);
+  }
+
+  /**
+   * Set the time zone to use when reading/writing Timestamps via JDBC.
+   */
+  public void setDataTimeZone(String dataTimeZone) {
+    this.dataTimeZone = dataTimeZone;
+  }
+
   /**
    * Return the suffix appended to the base table to derive the view that contains the union
    * of the base table and the history table in order to support asOf queries.
@@ -1151,6 +1213,20 @@ public class ServerConfig {
     this.namingConvention = namingConvention;
   }
 
+  /**
+   * Return the configuration for the ElasticSearch integration.
+   */
+  public DocStoreConfig getDocStoreConfig() {
+    return docStoreConfig;
+  }
+
+  /**
+   * Set the configuration for the ElasticSearch integration.
+   */
+  public void setDocStoreConfig(DocStoreConfig docStoreConfig) {
+    this.docStoreConfig = docStoreConfig;
+  }
+
   /**
    * Return the constraint naming convention used in DDL generation.
    */
@@ -1368,8 +1444,6 @@ public class ServerConfig {
    * <p>
    * Values are oracle, h2, postgres, mysql, mssqlserver2005.
    * </p>
-   * 
-   * @see DataSourceConfig#setOffline(boolean)
    */
   public void setDatabasePlatformName(String databasePlatformName) {
     this.databasePlatformName = databasePlatformName;
@@ -1640,6 +1714,20 @@ public class ServerConfig {
     this.disableClasspathSearch = disableClasspathSearch;
   }
 
+  /**
+   * Return the mode to use for Joda LocalTime support 'normal' or 'utc'.
+   */
+  public String getJodaLocalTimeMode() {
+    return jodaLocalTimeMode;
+  }
+
+  /**
+   * Set the mode to use for Joda LocalTime support 'normal' or 'utc'.
+   */
+  public void setJodaLocalTimeMode(String jodaLocalTimeMode) {
+    this.jodaLocalTimeMode = jodaLocalTimeMode;
+  }
+
   /**
    * Programmatically add classes (typically entities) that this server should
    * use.
@@ -2118,6 +2206,23 @@ public class ServerConfig {
     this.classLoadConfig = classLoadConfig;
   }
 
+  /**
+   * Return the service loader using the classLoader defined in ClassLoadConfig.
+   */
+  public <T> ServiceLoader<T> serviceLoad(Class<T> spiService) {
+
+    return ServiceLoader.load(spiService, classLoadConfig.getClassLoader());
+  }
+
+  /**
+   * Return the first service using the service loader (or null).
+   */
+  public <T> T service(Class<T> spiService) {
+    ServiceLoader<T> load = serviceLoad(spiService);
+    Iterator<T> serviceInstances = load.iterator();
+    return serviceInstances.hasNext() ? serviceInstances.next() : null;
+  }
+
   /**
    * Load settings from ebean.properties.
    */
@@ -2192,11 +2297,18 @@ public class ServerConfig {
    * @param p - The defined property source passed to load settings
    */
   protected void loadDataSourceSettings(PropertiesWrapper p) {
-    dataSourceConfig.loadSettings(p.withPrefix("datasource"));
+    dataSourceConfig.loadSettings(p.properties, name);
   }
 
   /**
-   * This is broken out for the same reason as above - preserve existing behaviour but let it be overridden.
+   * This is broken out to allow overridden behaviour.
+   */
+  protected void loadDocStoreSettings(PropertiesWrapper p) {
+    docStoreConfig.loadSettings(p);
+  }
+
+  /**
+   * This is broken out to allow overridden behaviour.
    */
   protected void loadAutoTuneSettings(PropertiesWrapper p) {
     autoTuneConfig.loadSettings(p);
@@ -2207,7 +2319,7 @@ public class ServerConfig {
    */
   protected void loadSettings(PropertiesWrapper p) {
 
-    migrationConfig.loadSettings(p);
+    migrationConfig.loadSettings(p, name);
 
     namingConvention = createNamingConvention(p, namingConvention);
     if (namingConvention != null) {
@@ -2223,6 +2335,12 @@ public class ServerConfig {
     }
     loadDataSourceSettings(p);
 
+    if (docStoreConfig == null) {
+      docStoreConfig = new DocStoreConfig();
+    }
+    loadDocStoreSettings(p);
+
+    disableL2Cache = p.getBoolean("disableL2Cache", disableL2Cache);
     explicitTransactionBeginMode = p.getBoolean("explicitTransactionBeginMode", explicitTransactionBeginMode);
     autoCommitMode = p.getBoolean("autoCommitMode", autoCommitMode);
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
@@ -2273,6 +2391,7 @@ public class ServerConfig {
     changeLogIncludeInserts = p.getBoolean("changeLogIncludeInserts", changeLogIncludeInserts);
     expressionEqualsWithNullAsNoop = p.getBoolean("expressionEqualsWithNullAsNoop", expressionEqualsWithNullAsNoop);
 
+    dataTimeZone = p.get("dataTimeZone", dataTimeZone);
     asOfViewSuffix = p.get("asOfViewSuffix", asOfViewSuffix);
     asOfSysPeriod = p.get("asOfSysPeriod", asOfSysPeriod);
     historyTableSuffix = p.get("historyTableSuffix", historyTableSuffix);
@@ -2286,6 +2405,7 @@ public class ServerConfig {
       dbUuid = DbUuid.BINARY;
     }
     localTimeWithNanos = p.getBoolean("localTimeWithNanos", localTimeWithNanos);
+    jodaLocalTimeMode = p.get("jodaLocalTimeMode", jodaLocalTimeMode);
 
     lazyLoadBatchSize = p.getInt("lazyLoadBatchSize", lazyLoadBatchSize);
     queryBatchSize = p.getInt("queryBatchSize", queryBatchSize);
@@ -2410,6 +2530,20 @@ public class ServerConfig {
     this.expressionEqualsWithNullAsNoop = expressionEqualsWithNullAsNoop;
   }
 
+  /**
+   * Return true if L2 cache is disabled.
+   */
+  public boolean isDisableL2Cache() {
+    return disableL2Cache;
+  }
+
+  /**
+   * Set to true to disable L2 caching. Typically useful in performance testing.
+   */
+  public void setDisableL2Cache(boolean disableL2Cache) {
+    this.disableL2Cache = disableL2Cache;
+  }
+
   /**
    * Specify how UUID is stored.
    */

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

@@ -1,5 +1,7 @@
 package com.avaje.ebean.config;
 
+import com.avaje.ebean.util.CamelCaseHelper;
+
 /**
  * Converts between Camel Case and Underscore based names for both table and
  * column names (and is the default naming convention in Ebean).
@@ -141,21 +143,6 @@ public class UnderscoreNamingConvention extends AbstractNamingConvention {
    * Convert and return the from string from underscore to camel case.
    */
   protected String toCamelFromUnderscore(String underscore) {
-
-    StringBuilder result = new StringBuilder(underscore.length());
-    String[] vals = underscore.split("_");
-
-    for (int i = 0; i < vals.length; i++) {
-      String lower = vals[i].toLowerCase();
-      if (i > 0) {
-        char c = Character.toUpperCase(lower.charAt(0));
-        result.append(c);
-        result.append(lower.substring(1));
-      } else {
-        result.append(lower);
-      }
-    }
-
-    return result.toString();
+    return CamelCaseHelper.toCamelFromUnderscore(underscore);
   }
 }

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

@@ -18,7 +18,7 @@ public class DB2Platform extends DatabasePlatform {
     this.maxTableNameLength = 18;
     this.maxConstraintNameLength = 18;
     this.sqlLimiter = new Db2SqlLimiter();
-    this.platformDdl = new DB2Ddl(dbTypeMap, dbIdentity);
+    this.platformDdl = new DB2Ddl(this);
 
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsSequence(true);

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

@@ -9,7 +9,12 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.sql.Types;
+import java.util.Properties;
 
 /**
  * Database platform specific settings.
@@ -18,7 +23,6 @@ public class DatabasePlatform {
 
   private static final Logger logger = LoggerFactory.getLogger(DatabasePlatform.class);
 
-
   /**
    * Behavior used when ending a query only transaction (at read committed isolation level).
    */
@@ -72,6 +76,11 @@ public class DatabasePlatform {
    */
   protected DbTypeMap dbTypeMap = new DbTypeMap();
 
+  /**
+   * Default values for DB columns.
+   */
+  protected DbDefaultValue dbDefaultValue = new DbDefaultValue();
+
   /**
    * Set to true if the DB has native UUID type support.
    */
@@ -167,6 +176,10 @@ public class DatabasePlatform {
   public DatabasePlatform() {
   }
 
+  public void configure(Properties properties) {
+    // by default do nothing
+  }
+
   /**
    * Return the name of the DatabasePlatform.
    * <p>
@@ -291,6 +304,13 @@ public class DatabasePlatform {
     return dbTypeMap;
   }
 
+  /**
+   * Return the mapping for DB column default values.
+   */
+  public DbDefaultValue getDbDefaultValue() {
+    return dbDefaultValue;
+  }
+
   /**
    * Return the column alias prefix.
    */
@@ -425,6 +445,20 @@ public class DatabasePlatform {
     return sqlLimiter;
   }
 
+  /**
+   * Set the DB TRUE literal (from the registered boolean ScalarType)
+   */
+  public void setDbTrueLiteral(String dbTrueLiteral) {
+    this.dbDefaultValue.setTrue(dbTrueLiteral);
+  }
+
+  /**
+   * Set the DB FALSE literal (from the registered boolean ScalarType)
+   */
+  public void setDbFalseLiteral(String dbFalseLiteral) {
+    this.dbDefaultValue.setFalse(dbFalseLiteral);
+  }
+
   /**
    * Convert backticks to the platform specific open quote and close quote
    * <p>
@@ -497,4 +531,28 @@ public class DatabasePlatform {
     return disallowBatchOnCascade;
   }
 
+  /**
+   * Return true if the table exists.
+   */
+  public boolean tableExists(Connection connection, String catalog, String schema, String table) throws SQLException {
+
+    DatabaseMetaData metaData = connection.getMetaData();
+    ResultSet tables = metaData.getTables(catalog, schema, table, null);
+    try {
+      return tables.next();
+    } finally {
+      close(tables);
+    }
+  }
+
+  /**
+   * Close the resultSet.
+   */
+  protected void close(ResultSet resultSet) {
+    try {
+      resultSet.close();
+    } catch (SQLException e) {
+      logger.error("Error closing resultSet", e);
+    }
+  }
 }

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

@@ -0,0 +1,70 @@
+package com.avaje.ebean.config.dbplatform;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * DB Column default values mapping to database platform specific literals.
+ */
+public class DbDefaultValue {
+
+  /**
+   * The key for FALSE.
+   */
+  public static final String FALSE = "false";
+
+  /**
+   * The key for TRUE.
+   */
+  public static final String TRUE = "true";
+
+  /**
+   * The key for the NOW / current timestamp.
+   */
+  public static final String NOW = "now";
+
+  protected Map<String,String> map = new LinkedHashMap<String,String>();
+
+  /**
+   * Set the DB now function.
+   */
+  public void setNow(String dbFunction) {
+    put(NOW, dbFunction);
+  }
+
+  /**
+   * Set the DB false literal.
+   */
+  public void setFalse(String dbFalseLiteral) {
+    put(FALSE, dbFalseLiteral);
+  }
+
+  /**
+   * Set the DB true literal.
+   */
+  public void setTrue(String dbTrueLiteral) {
+    put(TRUE, dbTrueLiteral);
+  }
+
+  /**
+   * Add an translation entry.
+   */
+  public void put(String dbLiteral, String dbTranslated) {
+    map.put(dbLiteral, dbTranslated);
+  }
+
+  /**
+   * Convert the DB default literal to platform specific type or function.
+   * <p>
+   * This is intended for the DB column default clause in DDL.
+   * </p>
+   */
+  public String convert(String dbDefaultLiteral) {
+    if (dbDefaultLiteral == null) {
+      return null;
+    }
+    String val = map.get(dbDefaultLiteral);
+    return val != null ? val : dbDefaultLiteral;
+  }
+
+}

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

@@ -14,9 +14,10 @@ public class H2Platform extends DatabasePlatform {
     super();
     this.name = "h2";
     this.dbEncrypt = new H2DbEncrypt();
-    this.platformDdl = new H2Ddl(this.dbTypeMap, dbIdentity);
+    this.platformDdl = new H2Ddl(this);
     this.historySupport = new H2HistorySupport();
     this.nativeUuidType = true;
+    this.dbDefaultValue.setNow("now()");
 
     // only support getGeneratedKeys with non-batch JDBC
     // so generally use SEQUENCE instead of IDENTITY for H2

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

@@ -15,7 +15,7 @@ public class HsqldbPlatform extends DatabasePlatform {
     super();
     this.name = "hsqldb";
     this.dbEncrypt = new H2DbEncrypt();
-    this.platformDdl = new HsqldbDdl(dbTypeMap, dbIdentity);
+    this.platformDdl = new HsqldbDdl(this);
 
     this.dbIdentity.setIdType(IdType.IDENTITY);
     this.dbIdentity.setSupportsGetGeneratedKeys(true);

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

@@ -25,7 +25,7 @@ public class MsSqlServer2005Platform extends DatabasePlatform {
     this.idInExpandedForm = true;
     this.selectCountWithAlias = true;
     this.sqlLimiter = new MsSqlServer2005SqlLimiter();
-    this.platformDdl = new MsSqlServerDdl(dbTypeMap, dbIdentity);
+    this.platformDdl = new MsSqlServerDdl(this);
     this.dbIdentity.setIdType(IdType.IDENTITY);
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsIdentity(true);

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

@@ -25,7 +25,7 @@ public class MySqlPlatform extends DatabasePlatform {
     this.likeClause = "like ? escape''";
     this.selectCountWithAlias = true;
     this.dbEncrypt = new MySqlDbEncrypt();
-    this.platformDdl = new MySqlDdl(this.dbTypeMap, this.dbIdentity);
+    this.platformDdl = new MySqlDdl(this);
     this.historySupport = new MySqlHistorySupport();
 
     this.dbIdentity.setIdType(IdType.IDENTITY);

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

@@ -16,11 +16,9 @@ public class OraclePlatform extends DatabasePlatform {
     this.name = "oracle";
     this.maxTableNameLength = 30;
     this.maxConstraintNameLength = 30;
-    // OnQueryOnly.CLOSE as a performance optimisation on Oracle
-    this.onQueryOnly = OnQueryOnly.CLOSE;
     this.dbEncrypt = new OracleDbEncrypt();
     this.sqlLimiter = new RownumSqlLimiter();
-    this.platformDdl = new Oracle10Ddl(this.dbTypeMap, this.dbIdentity);
+    this.platformDdl = new Oracle10Ddl(this);
     this.historySupport = new OracleDbHistorySupport();
 
     // Not using getGeneratedKeys as instead we will

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

@@ -7,6 +7,7 @@ import com.avaje.ebean.dbmigration.ddlgeneration.platform.PostgresDdl;
 
 import javax.sql.DataSource;
 import java.sql.Types;
+import java.util.Properties;
 
 /**
  * Postgres v9 specific platform.
@@ -19,9 +20,6 @@ public class PostgresPlatform extends DatabasePlatform {
   public PostgresPlatform() {
     super();
     this.name = "postgres";
-
-    // OnQueryOnly.CLOSE as a performance optimisation on Postgres
-    this.onQueryOnly = OnQueryOnly.CLOSE;
     this.likeClause = "like ? escape''";
     this.selectCountWithAlias = true;
     this.blobDbType = Types.LONGVARBINARY;
@@ -30,7 +28,7 @@ public class PostgresPlatform extends DatabasePlatform {
 
     this.dbEncrypt = new PostgresDbEncrypt();
     this.historySupport = new PostgresHistorySupport();
-    this.platformDdl = new PostgresDdl(this.dbTypeMap, this.dbIdentity);
+    this.platformDdl = new PostgresDdl(this);
 
     // Use Identity and getGeneratedKeys
     this.dbIdentity.setIdType(IdType.IDENTITY);
@@ -53,6 +51,7 @@ public class PostgresPlatform extends DatabasePlatform {
     dbTypeMap.put(Types.DOUBLE, new DbType("float"));
     dbTypeMap.put(Types.TINYINT, new DbType("smallint"));
     dbTypeMap.put(Types.DECIMAL, new DbType("decimal", 38));
+    dbTypeMap.put(Types.TIMESTAMP, new DbType("timestamptz"));
 
     dbTypeMap.put(Types.BINARY, dbBytea);
     dbTypeMap.put(Types.VARBINARY, dbBytea);
@@ -61,7 +60,16 @@ public class PostgresPlatform extends DatabasePlatform {
     dbTypeMap.put(Types.CLOB, dbTypeText);
     dbTypeMap.put(Types.LONGVARBINARY, dbBytea);
     dbTypeMap.put(Types.LONGVARCHAR, dbTypeText);
+  }
 
+  @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));
+    }
   }
 
   /**

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

@@ -9,7 +9,7 @@ public class SQLitePlatform extends DatabasePlatform {
   public SQLitePlatform() {
     super();
     this.name = "sqlite";
-    this.platformDdl = new SQLiteDdl(dbTypeMap, dbIdentity);
+    this.platformDdl = new SQLiteDdl(this);
 
     this.dbIdentity.setIdType(IdType.IDENTITY);
     this.dbIdentity.setSupportsGetGeneratedKeys(false);

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

@@ -3,6 +3,7 @@ package com.avaje.ebean.dbmigration;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.dbmigration.model.CurrentModel;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import com.avaje.ebeaninternal.util.JdbcClose;
 
 import javax.persistence.PersistenceException;
 import java.io.File;
@@ -13,6 +14,7 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.LineNumberReader;
 import java.io.Reader;
+import java.sql.Connection;
 
 /**
  * Controls the generation and execution of "Create All" and "Drop All" DDL scripts.
@@ -81,6 +83,21 @@ public class DdlGenerator {
     }
   }
 
+  /**
+   * Execute all the DDL statements in the script.
+   */
+  public int runScript(boolean expectErrors, String content, String scriptName) {
+
+    DdlRunner runner = new DdlRunner(expectErrors, scriptName);
+    // get a connection without threadLocal
+    Connection connection = server.createTransaction().getConnection();
+    try {
+      return runner.runAll(content, connection);
+    } finally {
+      JdbcClose.close(connection);
+    }
+  }
+
   protected void runDropSql() throws IOException {
     if (!createOnly) {
       if (dropAllContent == null) {
@@ -110,9 +127,8 @@ public class DdlGenerator {
     if (sqlScript != null) {
       InputStream is = getClassLoader().getResourceAsStream(sqlScript);
       if (is != null) {
-        DdlRunner runner = new DdlRunner(false, sqlScript);
         String content = readContent(new InputStreamReader(is));
-        runner.runAll(content, server);
+        runScript(false, content, sqlScript);
       }
     }
   }
@@ -221,13 +237,4 @@ public class DdlGenerator {
     }
   }
 
-  /**
-   * Execute all the DDL statements in the script.
-   */
-  public int runScript(boolean expectErrors, String content, String scriptName) {
-
-    DdlRunner runner = new DdlRunner(expectErrors, scriptName);
-    return runner.runAll(content, server);
-  }
-
 }

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

@@ -1,7 +1,5 @@
 package com.avaje.ebean.dbmigration;
 
-import com.avaje.ebean.Transaction;
-import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -37,29 +35,33 @@ public class DdlRunner {
   /**
    * Parse the content into sql statements and execute them in a transaction.
    */
-  public int runAll(String content, SpiEbeanServer server) {
+  public int runAll(String content, Connection connection) {
 
     List<String> statements = ddlParser.parse(new StringReader(content));
-    return runStatements(statements, server);
+    return runStatements(statements, connection);
   }
 
   /**
    * Execute all the statements in a single transaction.
    */
-  public int runStatements(List<String> statements, SpiEbeanServer server) {
+  public int runStatements(List<String> statements, Connection connection) {
 
-    Transaction t = server.createTransaction();
     try {
-      int statementCount = runStatements(expectErrors, statements, t.getConnection());
-      t.commit();
-
+      int statementCount = runStatements(expectErrors, statements, connection);
+      connection.commit();
       return statementCount;
 
     } catch (Exception e) {
+      rollback(connection);
       throw new PersistenceException("Error: " + e.getMessage(), e);
+    }
+  }
 
-    } finally {
-      t.end();
+  private void rollback(Connection connection) {
+    try {
+      connection.rollback();
+    } catch (SQLException e) {
+      logger.error("Error trying to rollback connection", e);
     }
   }
 

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

@@ -0,0 +1,110 @@
+package com.avaje.ebean.dbmigration;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.config.DbMigrationConfig;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.dbmigration.runner.LocalMigrationResource;
+import com.avaje.ebean.dbmigration.runner.LocalMigrationResources;
+import com.avaje.ebean.dbmigration.runner.MigrationTable;
+import com.avaje.ebeaninternal.util.JdbcClose;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.sql.DataSource;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+
+/**
+ * Runs the DB migration typically on application start.
+ */
+public class MigrationRunner {
+
+  public static final Logger logger = LoggerFactory.getLogger("org.avaje.ebean.DbMigration");
+
+  private final EbeanServer server;
+
+  private final ServerConfig config;
+
+  private final DbMigrationConfig migrationConfig;
+
+  public MigrationRunner(EbeanServer server, DbMigrationConfig migrationConfig) {
+    this.server = server;
+    this.config = server.getPluginApi().getServerConfig();
+    this.migrationConfig = migrationConfig;
+  }
+
+  /**
+   * Run the migrations if there are any that need running.
+   */
+  public void run() {
+
+    LocalMigrationResources resources = new LocalMigrationResources(config, migrationConfig);
+    if (!resources.readResources()) {
+      logger.debug("no migrations to check");
+      return;
+    }
+
+    String migrationUser = migrationConfig.getDbUser();
+    String migrationPwd = migrationConfig.getDbPassword();
+    if (migrationUser == null) {
+      throw new IllegalStateException("No DB migration user specified (to run the db migration) ?");
+    }
+
+    DataSource dataSource = server.getPluginApi().getDataSource();
+    if (dataSource == null) {
+      throw new IllegalStateException("No dataSource when trying to run migration? "
+          +"Maybe trying to generate DBMigration when ebean.migration.run=true is set? "
+          +"Perhaps need to set ebean.migration.run=false in test-ebean.properties?");
+    }
+
+    Connection connection;
+    try {
+      connection = dataSource.getConnection(migrationUser, migrationPwd);
+    } catch (SQLException e) {
+      throw new IllegalArgumentException("Error trying to connect to database using DB Migration user [" + migrationUser + "]", e);
+    }
+
+    try {
+      logger.debug("using db user [{}] to run migrations ...");
+      connection.setAutoCommit(false);
+      runMigrations(resources, connection);
+
+      connection.commit();
+
+    } catch (Exception e) {
+      JdbcClose.rollback(connection);
+      throw new RuntimeException(e);
+
+    } finally {
+      JdbcClose.close(connection);
+    }
+  }
+
+  /**
+   * Run all the migrations as needed.
+   */
+  private void runMigrations(LocalMigrationResources resources, Connection connection) throws SQLException, IOException {
+
+    MigrationTable table = new MigrationTable(server, migrationConfig, connection);
+    table.createIfNeeded();
+
+    // get the migrations in version order
+    List<LocalMigrationResource> localVersions = resources.getVersions();
+
+    logger.info("local migrations:{}  existing migrations:{}", localVersions.size(), table.size());
+
+    LocalMigrationResource priorVersion = null;
+
+    // run migrations in order
+    for (int i = 0; i < localVersions.size(); i++) {
+      LocalMigrationResource localVersion = localVersions.get(i);
+      if (!table.shouldRun(localVersion, priorVersion)) {
+        break;
+      }
+      priorVersion = localVersion;
+    }
+  }
+
+}

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

@@ -123,6 +123,9 @@ public class BaseTableDdl implements TableDdl {
       // defined on the columns
       writePrimaryKeyConstraint(apply, createTable.getPkName(), toColumnNames(pk));
     }
+    if (platformDdl.isInlineForeignKeys()) {
+      writeInlineForeignKeys(writer, createTable);
+    }
 
     apply.newLine().append(")");
     addTableCommentInline(apply, createTable);
@@ -151,8 +154,9 @@ public class BaseTableDdl implements TableDdl {
     apply.end();
     writer.dropAll().end();
 
-    writeAddForeignKeys(writer, createTable);
-
+    if (!platformDdl.isInlineForeignKeys()) {
+      writeAddForeignKeys(writer, createTable);
+    }
   }
 
   /**
@@ -235,6 +239,43 @@ public class BaseTableDdl implements TableDdl {
     platformDdl.createWithHistory(writer, table);
   }
 
+  protected void writeInlineForeignKeys(DdlWrite write, CreateTable createTable) throws IOException {
+
+    for (Column column : createTable.getColumn()) {
+      String references = column.getReferences();
+      if (hasValue(references)) {
+        writeInlineForeignKey(write, column);
+      }
+    }
+    writeInlineCompoundForeignKeys(write, createTable);
+  }
+
+  protected void writeInlineForeignKey(DdlWrite write, Column column) throws IOException {
+
+    String references = column.getReferences();
+    int pos = references.lastIndexOf('.');
+    if (pos == -1) {
+      throw new IllegalStateException("Expecting period '.' character for table.column split but not found in [" + references + "]");
+    }
+    String refTableName = references.substring(0, pos);
+    String refColumnName = references.substring(pos + 1);
+    String fkConstraint = platformDdl.tableInlineForeignKey(new String[]{column.getName()}, refTableName, new String[]{refColumnName});
+    write.apply().append(",").newLine().append("  ").append(fkConstraint);
+  }
+
+  protected void writeInlineCompoundForeignKeys(DdlWrite write, CreateTable createTable) throws IOException {
+
+    List<ForeignKey> foreignKey = createTable.getForeignKey();
+    for (ForeignKey key : foreignKey) {
+      String refTableName = key.getRefTableName();
+      String[] cols = toColumnNamesSplit(key.getColumnNames());
+      String[] refColumns = toColumnNamesSplit(key.getRefColumnNames());
+
+      String fkConstraint = platformDdl.tableInlineForeignKey(cols, refTableName, refColumns);
+      write.apply().append(",").newLine().append("  ").append(fkConstraint);
+    }
+  }
+
   protected void writeAddForeignKeys(DdlWrite write, CreateTable createTable) throws IOException {
 
     String tableName = createTable.getName();
@@ -309,7 +350,10 @@ public class BaseTableDdl implements TableDdl {
 
   protected void alterTableAddForeignKey(DdlBuffer buffer, String fkName, String tableName, String[] columns, String refTable, String[] refColumns) throws IOException {
 
-    buffer.append(platformDdl.alterTableAddForeignKey(tableName, fkName, columns, refTable, refColumns)).endOfStatement();
+    String fkConstraint = platformDdl.alterTableAddForeignKey(tableName, fkName, columns, refTable, refColumns);
+    if (fkConstraint != null && !fkConstraint.isEmpty()) {
+      buffer.append(fkConstraint).endOfStatement();
+    }
   }
 
   protected void appendColumns(String[] columns, DdlBuffer buffer) throws IOException {

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

@@ -1,15 +1,14 @@
 package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 
 /**
  * DB2 platform specific DDL.
  */
 public class DB2Ddl extends PlatformDdl {
 
-  public DB2Ddl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    super(platformTypes, dbIdentity);
+  public DB2Ddl(DatabasePlatform platform) {
+    super(platform);
     this.identitySuffix = " generated by default as identity";
   }
 

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

@@ -1,15 +1,14 @@
 package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 
 /**
  * H2 platform specific DDL.
  */
 public class H2Ddl extends PlatformDdl {
 
-  public H2Ddl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    super(platformTypes, dbIdentity);
+  public H2Ddl(DatabasePlatform platform) {
+    super(platform);
     this.historyDdl = new H2HistoryDdl();
   }
 

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

@@ -1,15 +1,14 @@
 package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 
 /**
  * Hsqldb platform specific DDL.
  */
 public class HsqldbDdl extends PlatformDdl {
 
-  public HsqldbDdl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    super(platformTypes, dbIdentity);
+  public HsqldbDdl(DatabasePlatform platform) {
+    super(platform);
     this.identitySuffix = " generated by default as identity (start with 1) ";
   }
 

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

@@ -1,7 +1,6 @@
 package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
 import com.avaje.ebean.dbmigration.migration.AlterColumn;
 
@@ -12,8 +11,8 @@ import java.io.IOException;
  */
 public class MsSqlServerDdl extends PlatformDdl {
 
-  public MsSqlServerDdl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    super(platformTypes, dbIdentity);
+  public MsSqlServerDdl(DatabasePlatform platform) {
+    super(platform);
     this.identitySuffix = " identity(1,1)";
     this.foreignKeyRestrict = "";
     this.inlineUniqueOneToOne = false;

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

@@ -1,7 +1,6 @@
 package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
 import com.avaje.ebean.dbmigration.migration.AlterColumn;
 import com.avaje.ebean.dbmigration.migration.Column;
@@ -14,8 +13,8 @@ import java.io.IOException;
  */
 public class MySqlDdl extends PlatformDdl {
 
-  public MySqlDdl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    super(platformTypes, dbIdentity);
+  public MySqlDdl(DatabasePlatform platform) {
+    super(platform);
     this.alterColumn =  "modify";
     this.dropUniqueConstraint = "drop index";
     this.historyDdl = new MySqlHistoryDdl();

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

@@ -1,15 +1,14 @@
 package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 
 /**
  * Oracle platform specific DDL.
  */
 public class Oracle10Ddl extends PlatformDdl {
 
-  public Oracle10Ddl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    super(platformTypes, dbIdentity);
+  public Oracle10Ddl(DatabasePlatform platform) {
+    super(platform);
     this.dropTableIfExists = "drop table ";
     this.dropSequenceIfExists = "drop sequence ";
     this.dropTableCascade = " cascade constraints purge";

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

@@ -2,8 +2,9 @@ package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
 import com.avaje.ebean.config.DbConstraintNaming;
 import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
+import com.avaje.ebean.config.dbplatform.DbDefaultValue;
 import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
 import com.avaje.ebean.config.dbplatform.IdType;
 import com.avaje.ebean.dbmigration.ddlgeneration.BaseDdlHandler;
 import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
@@ -85,9 +86,17 @@ public class PlatformDdl {
 
   protected DbConstraintNaming naming;
 
-  public PlatformDdl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    this.dbIdentity = dbIdentity;
-    this.typeConverter = new PlatformTypeConverter(platformTypes);
+  /**
+   * Generally not desired as then they are not named (used with SQLite).
+   */
+  protected boolean inlineForeignKeys;
+
+  protected final DbDefaultValue dbDefaultValue;
+
+  public PlatformDdl(DatabasePlatform platform) {
+    this.dbIdentity = platform.getDbIdentity();
+    this.dbDefaultValue = platform.getDbDefaultValue();
+    this.typeConverter = new PlatformTypeConverter(platform.getDbTypeMap());
   }
 
   /**
@@ -128,6 +137,14 @@ public class PlatformDdl {
     return inlineComments;
   }
 
+  /**
+   * Return true if foreign key reference constraints need to inlined with create table.
+   * Ideally we don't do this as then the constraints are not named. Do this for SQLite.
+   */
+  public boolean isInlineForeignKeys() {
+    return inlineForeignKeys;
+  }
+
   /**
    * Write all the table columns converting to platform types as necessary.
    */
@@ -152,6 +169,12 @@ public class PlatformDdl {
     buffer.append("  ");
     buffer.append(lowerColumnName(column.getName()), 29);
     buffer.append(platformType);
+    if (!typeContainsDefault(platformType)) {
+      String defaultValue = convertDefaultValue(column.getDefaultValue());
+      if (defaultValue != null) {
+        buffer.append(" default ").append(defaultValue);
+      }
+    }
     if (isTrue(column.isNotnull()) || isTrue(column.isPrimaryKey())) {
       buffer.append(" not null");
     }
@@ -160,6 +183,20 @@ public class PlatformDdl {
     // so that the database can potentially provide a nice SQL error
   }
 
+  /**
+   * Return true if the type definition already contains a default value.
+   */
+  private boolean typeContainsDefault(String platformType) {
+    return platformType.toLowerCase().contains(" default");
+  }
+
+  /**
+   * Convert the DB column default literal to platform specific.
+   */
+  private String convertDefaultValue(String dbDefault) {
+    return dbDefaultValue.convert(dbDefault);
+  }
+
   /**
    * Return the drop foreign key clause.
    */
@@ -255,6 +292,20 @@ public class PlatformDdl {
     return buffer.toString();
   }
 
+  /**
+   * Return the foreign key constraint when used inline with create table.
+   */
+  public String tableInlineForeignKey(String[] columns, String refTable, String[] refColumns) {
+
+    StringBuilder buffer = new StringBuilder(90);
+    buffer.append("foreign key");
+    appendColumns(columns, buffer);
+    buffer.append(" references ").append(lowerTableName(refTable));
+    appendColumns(refColumns, buffer);
+    appendWithSpace(foreignKeyRestrict, buffer);
+    return buffer.toString();
+  }
+
   /**
    * Add foreign key.
    */

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

@@ -1,15 +1,14 @@
 package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 
 /**
  * Postgres specific DDL.
  */
 public class PostgresDdl extends PlatformDdl {
 
-  public PostgresDdl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    super(platformTypes, dbIdentity);
+  public PostgresDdl(DatabasePlatform platform) {
+    super(platform);
     this.historyDdl = new PostgresHistoryDdl();
     this.dropTableCascade = " cascade";
     this.columnSetType = "type ";

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

@@ -14,7 +14,7 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
 
 
   public PostgresHistoryDdl() {
-    this.currentTimestamp = "statement_timestamp()";
+    this.currentTimestamp = "current_timestamp";
   }
 
   /**

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

@@ -1,16 +1,34 @@
 package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
+import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
+
+import java.io.IOException;
 
 /**
  * DB2 platform specific DDL.
  */
 public class SQLiteDdl extends PlatformDdl {
 
-  public SQLiteDdl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
-    super(platformTypes, dbIdentity);
-    this.identitySuffix = " autoincrement";
+  public SQLiteDdl(DatabasePlatform platform) {
+    super(platform);
+    this.identitySuffix = "";
+    this.inlineForeignKeys = true;
+  }
+
+  @Override
+  public void addTableComment(DdlBuffer apply, String tableName, String tableComment) throws IOException {
+    // not supported
+  }
+
+  @Override
+  public void addColumnComment(DdlBuffer apply, String table, String column, String comment) throws IOException {
+    // not supported
+  }
+
+  @Override
+  public String alterTableAddForeignKey(String tableName, String fkName, String[] columns, String refTable, String[] refColumns) {
+    // not supported
+    return null;
   }
-  
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/util/PlatformTypeConverter.java

@@ -5,7 +5,7 @@ import com.avaje.ebean.config.dbplatform.DbTypeMap;
 
 /**
  * Converts a logical column definition into platform specific one.
- *
+ * <p>
  * This translates standard sql types into platform specific ones.
  */
 public class PlatformTypeConverter {
@@ -44,20 +44,21 @@ public class PlatformTypeConverter {
       return columnDefinition;
     }
 
-    String type = columnDefinition.substring(0,open);
+    String suffix = close + 1 < columnDefinition.length() ? columnDefinition.substring(close + 1) : "";
+    String type = columnDefinition.substring(0, open);
     try {
       DbType dbType = platformTypes.lookup(type);
-      int comma = columnDefinition.indexOf(',',open);
+      int comma = columnDefinition.indexOf(',', open);
       if (comma > -1) {
         // scale and precision - decimal(10,4)
-        int scale = Integer.parseInt(columnDefinition.substring(open+1, comma));
-        int precision = Integer.parseInt(columnDefinition.substring(comma+1, close));
-        return  dbType.renderType(scale,precision);
+        int scale = Integer.parseInt(columnDefinition.substring(open + 1, comma));
+        int precision = Integer.parseInt(columnDefinition.substring(comma + 1, close));
+        return dbType.renderType(scale, precision) + suffix;
 
       } else {
         // scale - varchar(10)
-        int scale = Integer.parseInt(columnDefinition.substring(open+1, close));
-        return  dbType.renderType(scale,0);
+        int scale = Integer.parseInt(columnDefinition.substring(open + 1, close));
+        return dbType.renderType(scale, 0) + suffix;
       }
 
     } catch (IllegalArgumentException e) {
@@ -73,7 +74,7 @@ public class PlatformTypeConverter {
 
     try {
       DbType dbType = platformTypes.lookup(columnDefinition);
-      return  dbType.renderType(0,0);
+      return dbType.renderType(0, 0);
 
     } catch (IllegalArgumentException e) {
       // assume already platform specific, leave as is

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

@@ -28,6 +28,13 @@ public class MigrationVersion implements Comparable<MigrationVersion> {
     this.comment = comment;
   }
 
+  /**
+   * Return the full version.
+   */
+  public String getFull() {
+    return raw;
+  }
+
   public String toString() {
     return raw;
   }

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

@@ -38,7 +38,7 @@ public class ModelBuildBeanVisitor implements BeanVisitor {
     table.setComment(descriptor.getDbComment());
     if (descriptor.isHistorySupport()) {
       table.setWithHistory(true);
-      BeanProperty whenCreated = descriptor.findWhenCreatedProperty();
+      BeanProperty whenCreated = descriptor.getWhenCreatedProperty();
       if (whenCreated != null) {
         table.setWhenCreatedColumn(whenCreated.getDbColumn());
       }

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

@@ -230,6 +230,7 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
     }
 
     MColumn col = new MColumn(p.getDbColumn(), ctx.getColumnDefn(p));
+    col.setDefaultValue(p.getDbColumnDefault());
     col.setComment(p.getDbComment());
     col.setDraftOnly(p.isDraftOnly());
 

src/main/java/com/avaje/ebean/dbmigration/runner/Checksum.java

@@ -0,0 +1,32 @@
+package com.avaje.ebean.dbmigration.runner;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.zip.CRC32;
+
+/**
+ * Calculates the checksum for the given string content.
+ */
+public class Checksum {
+
+  /**
+   * Returns the checksum of this string.
+   */
+  public static int calculate(String str) {
+
+    final CRC32 crc32 = new CRC32();
+
+    BufferedReader bufferedReader = new BufferedReader(new StringReader(str));
+    try {
+      String line;
+      while ((line = bufferedReader.readLine()) != null) {
+        crc32.update(line.getBytes("UTF-8"));
+      }
+    } catch (IOException e) {
+      throw new RuntimeException("Failed to calculate checksum", e);
+    }
+
+    return (int) crc32.getValue();
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/runner/LocalMigrationResource.java

@@ -0,0 +1,58 @@
+package com.avaje.ebean.dbmigration.runner;
+
+import com.avaje.ebean.dbmigration.model.MigrationVersion;
+import org.avaje.classpath.scanner.Resource;
+
+/**
+ * A DB migration resource (DDL script with version).
+ */
+public class LocalMigrationResource implements Comparable<LocalMigrationResource> {
+
+  private final MigrationVersion version;
+
+  private final String location;
+
+  private final Resource resource;
+
+  /**
+   * Construct with version and resource.
+   */
+  public LocalMigrationResource(MigrationVersion version, String location, Resource resource) {
+    this.version = version;
+    this.location = location;
+    this.resource = resource;
+  }
+
+  public String toString() {
+    return version.toString();
+  }
+
+  /**
+   * Default ordering by version.
+   */
+  @Override
+  public int compareTo(LocalMigrationResource o) {
+    return version.compareTo(o.version);
+  }
+
+  /**
+   * Return the underlying migration version.
+   */
+  public MigrationVersion getVersion() {
+    return version;
+  }
+
+  /**
+   * Return the resource location.
+   */
+  public String getLocation() {
+    return location;
+  }
+
+  /**
+   * Return the content for the migration apply ddl script.
+   */
+  public String getContent() {
+    return resource.loadAsString("UTF-8");
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/runner/LocalMigrationResources.java

@@ -0,0 +1,91 @@
+package com.avaje.ebean.dbmigration.runner;
+
+import com.avaje.ebean.config.DbMigrationConfig;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.dbmigration.model.MigrationVersion;
+import org.avaje.classpath.scanner.Resource;
+import org.avaje.classpath.scanner.ResourceFilter;
+import org.avaje.classpath.scanner.Scanner;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Loads the DB migration resources and sorts them into execution order.
+ */
+public class LocalMigrationResources {
+
+  private static final Logger logger = LoggerFactory.getLogger(LocalMigrationResources.class);
+
+  private final ServerConfig serverConfig;
+
+  private final DbMigrationConfig migrationConfig;
+
+  private final List<LocalMigrationResource> versions = new ArrayList<LocalMigrationResource>();
+
+  /**
+   * Construct with configuration options.
+   */
+  public LocalMigrationResources(ServerConfig serverConfig, DbMigrationConfig migrationConfig) {
+    this.serverConfig = serverConfig;
+    this.migrationConfig = migrationConfig;
+  }
+
+  /**
+   * Read all the migration resources (SQL scripts) returning true if there are versions.
+   */
+  public boolean readResources() {
+
+    String migrationPath = migrationConfig.getMigrationPath();
+
+    ClassLoader classLoader = serverConfig.getClassLoadConfig().getClassLoader();
+
+    Scanner scanner = new Scanner(classLoader);
+    List<Resource> resourceList = scanner.scanForResources(migrationPath, new Match(migrationConfig));
+
+    logger.debug("resources: {}", resourceList);
+
+    for (Resource resource : resourceList) {
+      String filename = resource.getFilename();
+      if (filename.endsWith(migrationConfig.getApplySuffix())) {
+        int pos = filename.lastIndexOf(migrationConfig.getApplySuffix());
+        String mainName = filename.substring(0, pos);
+
+        MigrationVersion migrationVersion = MigrationVersion.parse(mainName);
+        LocalMigrationResource res = new LocalMigrationResource(migrationVersion, resource.getLocation(), resource);
+        versions.add(res);
+      }
+    }
+
+    Collections.sort(versions);
+    return !versions.isEmpty();
+  }
+
+  /**
+   * Return the list of migration resources in version order.
+   */
+  public List<LocalMigrationResource> getVersions() {
+    return versions;
+  }
+
+
+  /**
+   * Filter used to find the migration scripts.
+   */
+  private static class Match implements ResourceFilter {
+
+    private final DbMigrationConfig migrationConfig;
+
+    Match(DbMigrationConfig migrationConfig) {
+      this.migrationConfig = migrationConfig;
+    }
+
+    @Override
+    public boolean isMatch(String name) {
+      return name.endsWith(migrationConfig.getApplySuffix());
+    }
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/runner/MigrationMetaRow.java

@@ -0,0 +1,104 @@
+package com.avaje.ebean.dbmigration.runner;
+
+import com.avaje.ebean.SqlRow;
+import com.avaje.ebean.SqlUpdate;
+
+import java.sql.Timestamp;
+
+/**
+ * Bean holding migration execution details stored in the migration table.
+ */
+class MigrationMetaRow {
+
+  private int id;
+
+  private String status;
+
+  private String runVersion;
+
+  private String depVersion;
+
+  private String comment;
+
+  private int checksum;
+
+  private Timestamp runOn;
+
+  private String runBy;
+
+  /**
+   * Construct for inserting into table.
+   */
+  MigrationMetaRow(int id, String runVersion, String priorVersion, String comment, int checksum, String runBy) {
+    this.id = id;
+    this.runVersion = runVersion;
+    this.depVersion = priorVersion;
+    this.checksum = checksum;
+    this.comment = comment;
+    this.runBy = runBy;
+    this.runOn = new Timestamp(System.currentTimeMillis());
+  }
+
+  /**
+   * Construct from the SqlRow (read from table).
+   */
+  MigrationMetaRow(SqlRow row) {
+    id = row.getInteger("id");
+    status = row.getString("status");
+    runVersion = row.getString("run_version");
+    depVersion = row.getString("dep_version");
+    comment = row.getString("comment");
+    checksum = row.getInteger("checksum");
+    runOn = row.getTimestamp("run_on");
+    runBy = row.getString("run_by");
+  }
+
+  public String toString() {
+    return "id:" + id + " status:" + status + " runVersion:" + runVersion + " comment:" + comment + " runOn:" + runOn + " runBy:" + runBy;
+  }
+
+  /**
+   * Return the id for this migration.
+   */
+  int getId() {
+    return id;
+  }
+
+  /**
+   * Return the normalised version for this migration.
+   */
+  String getRunVersion() {
+    return runVersion;
+  }
+
+  /**
+   * Return the checksum for this migration.
+   */
+  int getChecksum() {
+    return checksum;
+  }
+
+  /**
+   * Bind to the insert statement.
+   */
+  void bindInsert(SqlUpdate insert) {
+    insert.setParameter(1, id);
+    insert.setParameter(2, "success");
+    insert.setParameter(3, runVersion);
+    insert.setParameter(4, depVersion);
+    insert.setParameter(5, comment);
+    insert.setParameter(6, checksum);
+    insert.setParameter(7, runOn);
+    insert.setParameter(8, runBy);
+    insert.setParameter(9, "ip");
+  }
+
+  /**
+   * Return the SQL insert given the table migration meta data is stored in.
+   */
+  static String insertSql(String table) {
+    return "insert into " + table
+        + " (id, status, run_version, dep_version, comment, checksum, run_on, run_by, run_ip)"
+        + " values (?,?,?,?,?,?,?,?,?)";
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/runner/MigrationScriptRunner.java

@@ -0,0 +1,29 @@
+package com.avaje.ebean.dbmigration.runner;
+
+import com.avaje.ebean.dbmigration.DdlRunner;
+
+import java.sql.Connection;
+
+/**
+ * Runs the DDL migration scripts.
+ */
+public class MigrationScriptRunner {
+
+  private final Connection connection;
+
+  /**
+   * Construct with a given connection.
+   */
+  public MigrationScriptRunner(Connection connection) {
+    this.connection = connection;
+  }
+
+  /**
+   * Execute all the DDL statements in the script.
+   */
+  public int runScript(boolean expectErrors, String content, String scriptName) {
+
+    DdlRunner runner = new DdlRunner(expectErrors, scriptName);
+    return runner.runAll(content, connection);
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/runner/MigrationTable.java

@@ -0,0 +1,245 @@
+package com.avaje.ebean.dbmigration.runner;
+
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.SqlQuery;
+import com.avaje.ebean.SqlRow;
+import com.avaje.ebean.SqlUpdate;
+import com.avaje.ebean.config.DbMigrationConfig;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.config.dbplatform.DatabasePlatform;
+import com.avaje.ebean.dbmigration.MigrationRunner;
+import com.avaje.ebean.plugin.SpiServer;
+import com.avaje.ebeaninternal.server.transaction.ExternalJdbcTransaction;
+import com.avaje.ebeaninternal.util.IOUtils;
+import org.slf4j.Logger;
+
+import java.io.IOException;
+import java.net.URL;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Enumeration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Manages the migration table.
+ */
+public class MigrationTable {
+
+  private static final Logger logger = MigrationRunner.logger;
+
+  private final  Connection connection;
+
+  private final EbeanServer server;
+
+  private final DatabasePlatform databasePlatform;
+
+  private final String catalog;
+  private final String schema;
+  private final String table;
+  private final ServerConfig serverConfig;
+  private final String envUserName;
+
+  private final ScriptTransform scriptTransform;
+
+  private final String insertSql;
+
+  private final LinkedHashMap<String,MigrationMetaRow> migrations;
+
+  private MigrationMetaRow lastMigration;
+
+  /**
+   * Construct with server, configuration and jdbc connection (DB admin user).
+   */
+  public MigrationTable(EbeanServer server, DbMigrationConfig migrationConfig, Connection connection) {
+    this.connection = connection;
+    this.server = server;
+    this.migrations = new LinkedHashMap<String, MigrationMetaRow>();
+
+    SpiServer pluginApi = server.getPluginApi();
+    this.serverConfig = pluginApi.getServerConfig();
+    this.databasePlatform = pluginApi.getDatabasePlatform();
+
+    this.catalog = null;
+    this.schema = null;
+    this.table = migrationConfig.getMetaTable();
+    this.insertSql = MigrationMetaRow.insertSql(table);
+
+    this.scriptTransform = createScriptTransform(migrationConfig);
+    this.envUserName = System.getProperty("user.name");
+  }
+
+  /**
+   * Return the number of migrations in the DB migration table.
+   */
+  public int size() {
+    return migrations.size();
+  }
+
+  /**
+   * Create the ScriptTransform for placeholder key/value replacement.
+   */
+  private ScriptTransform createScriptTransform(DbMigrationConfig config) {
+
+    Map<String, String> map = PlaceholderBuilder.build(config.getRunPlaceholders(), config.getRunPlaceholderMap());
+    return new ScriptTransform(map);
+  }
+
+  /**
+   * Create the table is it does not exist.
+   */
+  public void createIfNeeded() throws SQLException, IOException {
+
+    if (!tableExists(connection)) {
+      createTable(connection);
+    }
+
+    ExternalJdbcTransaction t = new ExternalJdbcTransaction(connection);
+    SqlQuery sqlQuery = server.createSqlQuery("select * from "+table+" order by id for update");
+    List<SqlRow> metaRows = server.findList(sqlQuery, t);
+
+    for (SqlRow row : metaRows) {
+      addMigration(new MigrationMetaRow(row));
+    }
+  }
+
+
+  private void createTable(Connection connection) throws IOException {
+
+    String script = ScriptTransform.table(table, getCreateTableScript());
+
+    MigrationScriptRunner run = new MigrationScriptRunner(connection);
+    run.runScript(false, script, "create migration table");
+  }
+
+  /**
+   * Return the create table script.
+   */
+  private String getCreateTableScript() throws IOException {
+    // supply a script to override the default table create script
+    String script = readResource("migration-support/create-table.sql");
+    if (script == null) {
+      // no, just use the default script
+      script = readResource("migration-support/default-create-table.sql");
+    }
+    return script;
+  }
+
+  private String readResource(String location) throws IOException {
+
+    Enumeration<URL> resources = serverConfig.getClassLoadConfig().getResources(location);
+    if (resources.hasMoreElements()) {
+      URL url = resources.nextElement();
+      return IOUtils.readUtf8(url.openStream());
+    }
+    return null;
+  }
+
+  /**
+   * Return true if the table exists.
+   */
+  private boolean tableExists(Connection connection) throws SQLException {
+    return databasePlatform.tableExists(connection, catalog, schema, table);
+  }
+
+  /**
+   * Return true if the migration ran successfully and false if the migration failed.
+   */
+  public boolean shouldRun(LocalMigrationResource localVersion, LocalMigrationResource priorVersion) {
+
+    if (priorVersion != null) {
+      // check priorVersion is installed
+      MigrationMetaRow existing = migrations.get(priorVersion.getVersion().normalised());
+      if (existing == null) {
+        logger.warn("Migration {} requires prior migration {} which has not been run", localVersion.getVersion(), priorVersion.getVersion());
+        return false;
+      }
+    }
+
+    MigrationMetaRow existing = migrations.get(localVersion.getVersion().normalised());
+    if (existing == null) {
+      runMigration(localVersion, priorVersion);
+      return true;
+
+    } else {
+      // check checksum and return ok, or re-run if repeatable script?
+      existing.getChecksum();
+      return true;
+    }
+  }
+
+  /**
+   * Run the migration script.
+   */
+  private void runMigration(LocalMigrationResource localVersion, LocalMigrationResource prior) {
+
+    logger.debug("run migration "+localVersion.getLocation());
+
+    String script = convertScript(localVersion.getContent());
+
+    MigrationScriptRunner run = new MigrationScriptRunner(connection);
+    run.runScript(false, script, "run migration version: "+localVersion.getVersion());
+
+
+    int checksum = Checksum.calculate(script);
+    MigrationMetaRow metaRow = createMetaRow(localVersion, prior, checksum);
+
+    SqlUpdate insert = server.createSqlUpdate(insertSql);
+    metaRow.bindInsert(insert);
+    server.execute(insert, new ExternalJdbcTransaction(connection));
+
+    addMigration(metaRow);
+  }
+
+  /**
+   * Create the MigrationMetaRow for this migration.
+   */
+  private MigrationMetaRow createMetaRow(LocalMigrationResource localVersion, LocalMigrationResource prior, int checksum) {
+
+    int nextId = 1;
+    if (lastMigration != null) {
+      nextId = lastMigration.getId() + 1;
+    }
+
+    String runVersion = localVersion.getVersion().normalised();
+    String comment = getMigrationComment(localVersion);
+    String priorVersion = getMigrationPriorVersion(prior);
+
+    return new MigrationMetaRow(nextId, runVersion, priorVersion, comment, checksum, envUserName);
+  }
+
+  /**
+   * Return the prior migration normalised version.
+   */
+  private String getMigrationPriorVersion(LocalMigrationResource prior) {
+    return prior != null ? prior.getVersion().normalised() : "-";
+  }
+
+  /**
+   * Return the migration comment.
+   */
+  private String getMigrationComment(LocalMigrationResource localVersion) {
+    String comment = localVersion.getVersion().getComment();
+    return comment == null || comment.isEmpty() ? "-" : comment;
+  }
+
+  /**
+   * Apply the placeholder key/value replacement on the script.
+   */
+  private String convertScript(String script) {
+    return scriptTransform.transform(script);
+  }
+
+  /**
+   * Register the successfully executed migration (to allow dependant scripts to run).
+   */
+  private void addMigration(MigrationMetaRow metaRow) {
+    lastMigration = metaRow;
+    String runVersion = metaRow.getRunVersion();
+    if (runVersion == null) {
+      throw new IllegalStateException("No runVersion in db migration table row? " + metaRow);
+    }
+    migrations.put(runVersion, metaRow);
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/runner/PlaceholderBuilder.java

@@ -0,0 +1,53 @@
+package com.avaje.ebean.dbmigration.runner;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Joins placeholder map and comma/equals delimited string.
+ */
+class PlaceholderBuilder {
+
+  private final Map<String,String> map = new HashMap<String,String>();
+
+  /**
+   * Create with raw comma and equals delimited pairs plus map of key value pairs.
+   */
+  public static Map<String,String> build(String commaDelimited, Map<String,String> placeholders) {
+
+    PlaceholderBuilder builder = new PlaceholderBuilder();
+    builder.add(commaDelimited);
+    builder.add(placeholders);
+
+    return builder.map;
+  }
+
+  private PlaceholderBuilder() {
+
+  }
+
+  /**
+   * Add a comma and equals delimited string to parse for key value pairs.
+   */
+  public void add(String commaDelimited) {
+
+    if (commaDelimited != null) {
+      String[] split = commaDelimited.split("[,;]");
+      for (String keyValue : split) {
+        String[] pair = keyValue.split("=");
+        if (pair.length == 2) {
+          map.put(pair[0].trim(), pair[1].trim());
+        }
+      }
+    }
+  }
+
+  /**
+   * Add a map of key value placeholder pairs.
+   */
+  public void add(Map<String,String> placeholders) {
+    if (placeholders != null) {
+      map.putAll(placeholders);
+    }
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/runner/ScriptTransform.java

@@ -0,0 +1,47 @@
+package com.avaje.ebean.dbmigration.runner;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Transforms a SQL script given a map of key/value substitutions.
+ */
+class ScriptTransform {
+
+  /**
+   * Transform just ${table} with the table name.
+   */
+  public static String table(String tableName, String script) {
+    return script.replace("${table}", tableName);
+  }
+
+  private final Map<String,String> placeholders = new HashMap<String, String>();
+
+  ScriptTransform(Map<String,String> map) {
+    for (Map.Entry<String, String> entry : map.entrySet()) {
+      placeholders.put(wrapKey(entry.getKey()), entry.getValue());
+    }
+  }
+
+  private String wrapKey(String key) {
+    return "${"+key+"}";
+  }
+
+  /**
+   * Return true if this contains no placeholders.
+   */
+  boolean isEmpty() {
+    return placeholders.isEmpty();
+  }
+
+  /**
+   * Transform the script replacing placeholders in the form <code>${key}</code> with <code>value</code>.
+   */
+  String transform(String source) {
+
+    for (Map.Entry<String, String> entry : placeholders.entrySet()) {
+      source = source.replace(entry.getKey(), entry.getValue());
+    }
+    return source;
+  }
+}

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

@@ -46,33 +46,4 @@ public abstract class AbstractBeanPersistListener implements BeanPersistListener
     return false;
   }
 
-  /**
-   * Notify that a bean was inserted on another node of the cluster.
-   *
-   * @param id the id value of the inserted bean
-   */
-  @Override
-  public void remoteInsert(Object id) {
-    // do nothing
-  }
-
-  /**
-   * Notify that a bean was updated on another node of the cluster.
-   *
-   * @param id the id value of the updated bean.
-   */
-  @Override
-  public void remoteUpdate(Object id) {
-    // do nothing
-  }
-
-  /**
-   * Notify that a bean was deleted on another node of the cluster.
-   *
-   * @param id the id value of the deleted bean.
-   */
-  @Override
-  public void remoteDelete(Object id) {
-    // do nothing
-  }
 }

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

@@ -74,28 +74,4 @@ public interface BeanPersistListener {
    */
   boolean deleted(Object bean);
 
-  /**
-   * Notify that a bean was inserted on another node of the cluster.
-   * 
-   * @param id
-   *          the id value of the inserted bean
-   */
-  void remoteInsert(Object id);
-
-  /**
-   * Notify that a bean was updated on another node of the cluster.
-   * 
-   * @param id
-   *          the id value of the updated bean.
-   */
-  void remoteUpdate(Object id);
-
-  /**
-   * Notify that a bean was deleted on another node of the cluster.
-   * 
-   * @param id
-   *          the id value of the deleted bean.
-   */
-  void remoteDelete(Object id);
-
 }

src/main/java/com/avaje/ebean/package.html

@@ -3,85 +3,84 @@
 	<TITLE>Ebean core API</TITLE>
 </HEAD>
 <Body BGCOLOR="#ffffff">
-Core API (see <a href="Ebean.html">Ebean</a> and <a href="EbeanServer.html">EbeanServer</a>).
+Core API (see <a href="EbeanServer.html">EbeanServer</a> and <a href="Ebean.html">Ebean</a>).
 
 <h3>Ebean</h3>
 <p>
 Provides the main API for fetching and persisting beans with eBean.
 </p>
 
-<pre class="code">
-	// EXAMPLE 1: Simple fetch
-	//========================
+<pre>{@code
+// EXAMPLE 1: Simple fetch
+//========================
 
-	// fetch order 10
-	Order order = Ebean.find(Order.class, 10);
+// fetch order 10
+Order order = Ebean.find(Order.class, 10);
 
 
 
-	// EXAMPLE 2: Fetch an Object with associations
-	//=============================================
-	
-	// fetch Customer 7 including their billing and shipping addresses
-	Customer customer = 
-		Ebean.find(Customer.class)
-			.setId(7)
-			.fetch("billingAddress")
-			.fetch("shippingAddress")
-			.findUnique();	
-	
-	Address billAddr = customer.getBillingAddress();
-	Address shipAddr = customer.getShippingAddress();
+// EXAMPLE 2: Fetch an Object with associations
+//=============================================
+
+// fetch Customer 7 including their billing and shipping addresses
+Customer customer =
+	Ebean.find(Customer.class)
+		.setId(7)
+		.fetch("billingAddress")
+		.fetch("shippingAddress")
+		.findUnique();
+
+Address billAddr = customer.getBillingAddress();
+Address shipAddr = customer.getShippingAddress();
 
 
 
 
-	// EXAMPLE 3: Create and save an Order
-	//=====================================
-	
-	// get a Customer reference so we don't hit the database
-	Customer custRef = Ebean.getReference(Customer.class, 7);
+// EXAMPLE 3: Create and save an Order
+//=====================================
 
-	// create a new Order object
-	Order newOrder = new Order();
-	newOrder.setStatus(Order.Status.NEW);
-	newOrder.setCustomer(custRef);
-	
-	ArrayList orderLines = new ArrayList();
-	newOrder.setLines(orderLines);
-	...
+// get a Customer reference so we don't hit the database
+Customer custRef = Ebean.getReference(Customer.class, 7);
 
-	// add a line to the order
-	Product prodRef = Ebean.getReference(Product.class, 41);
-	OrderLine line = new OrderLine();
-	line.setProduct(prodRef);
-	line.setQuantity(10);
-	orderLines.add(line);
-	...
+// create a new Order object
+Order newOrder = new Order();
+newOrder.setStatus(Order.Status.NEW);
+newOrder.setCustomer(custRef);
 
-	// save the order and its lines in a single transaction
-	// NB: assumes CascadeType.PERSIST is set on the order lines association
-	Ebean.save(newOrder);
+ArrayList orderLines = new ArrayList();
+newOrder.setLines(orderLines);
+...
+
+// add a line to the order
+Product prodRef = Ebean.getReference(Product.class, 41);
+OrderLine line = new OrderLine();
+line.setProduct(prodRef);
+line.setQuantity(10);
+orderLines.add(line);
+...
+
+// save the order and its lines in a single transaction
+// NB: assumes CascadeType.PERSIST is set on the order lines association
+Ebean.save(newOrder);
 
 
 
-	// EXAMPLE 4: Use another database
-	//=================================
+// EXAMPLE 4: Use another database
+//=================================
 
-	// Get access to the Human Resources EbeanServer/Database
-	EbeanServer hrServer = Ebean.getServer(&quot;HR&quot;);
-                                        
-                                  
-	// fetch contact 3 from the HR database
-	Contact contact = hrServer.find(Contact.class, 3);
-                                        
-	contact.setStatus(Contact.Status.INACTIVE);
-	...
-                                        
-	// save the contact back to the HR database
-	hrServer.save(contact); 
-	
-</pre>
+// Get access to the Human Resources EbeanServer/Database
+EbeanServer hrServer = Ebean.getServer(&quot;HR&quot;);
+
+
+// fetch contact 3 from the HR database
+Contact contact = hrServer.find(Contact.class, 3);
+
+contact.setStatus(Contact.Status.INACTIVE);
+...
+
+// save the contact back to the HR database
+hrServer.save(contact);
+}</pre>
 
 </Body>
 </HTML>

src/main/java/com/avaje/ebean/plugin/BeanDocType.java

@@ -0,0 +1,72 @@
+package com.avaje.ebean.plugin;
+
+import com.avaje.ebean.FetchPath;
+import com.avaje.ebean.Query;
+import com.avaje.ebeanservice.docstore.api.DocStoreUpdateContext;
+
+import java.io.IOException;
+
+/**
+ * Doc store functions for a specific entity bean type.
+ *
+ * @param <T> The type of entity bean
+ */
+public interface BeanDocType<T> {
+
+  /**
+   * Return the doc store index type for this bean type.
+   */
+  String getIndexType();
+
+  /**
+   * Return the doc store index name for this bean type.
+   */
+  String getIndexName();
+
+  /**
+   * Apply the appropriate fetch path to the query such that the query returns beans matching
+   * the document store structure with the expected embedded properties.
+   */
+  void applyPath(Query<T> spiQuery);
+
+  /**
+   * Return the FetchPath for the embedded document.
+   */
+  FetchPath getEmbedded(String path);
+
+  /**
+   * For embedded 'many' properties we need a FetchPath relative to the root which is used to
+   * build and replace the embedded list.
+   */
+  FetchPath getEmbeddedManyRoot(String path);
+
+  /**
+   * Return a 'raw' property mapped for the given property.
+   * If none exists the given property is returned.
+   */
+  String rawProperty(String property);
+
+  /**
+   * Store the bean in the doc store index.
+   * <p>
+   * This somewhat assumes the bean is fetched with appropriate path properties
+   * to match the expected document structure.
+   */
+  void index(Object idValue, T bean, DocStoreUpdateContext txn) throws IOException;
+
+  /**
+   * Add a delete by Id to the doc store.
+   */
+  void deleteById(Object idValue, DocStoreUpdateContext txn) throws IOException;
+
+  /**
+   * Add a embedded document update to the doc store.
+   *
+   * @param idValue            the Id value of the bean holding the embedded document
+   * @param embeddedProperty   the embedded property
+   * @param embeddedRawContent the content of the embedded document in JSON form
+   * @param txn                the doc store transaction to add the update to
+   */
+  void updateEmbedded(Object idValue, String embeddedProperty, String embeddedRawContent, DocStoreUpdateContext txn) throws IOException;
+
+}

src/main/java/com/avaje/ebean/plugin/BeanType.java

@@ -0,0 +1,179 @@
+package com.avaje.ebean.plugin;
+
+import com.avaje.ebean.config.dbplatform.IdType;
+import com.avaje.ebean.event.BeanFindController;
+import com.avaje.ebean.event.BeanPersistController;
+import com.avaje.ebean.event.BeanPersistListener;
+import com.avaje.ebean.event.BeanQueryAdapter;
+import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeanservice.docstore.api.mapping.DocumentMapping;
+
+import java.util.Collection;
+
+/**
+ * Information and methods on BeanDescriptors made available to plugins.
+ */
+public interface BeanType<T> {
+
+  /**
+   * Return the short name of the bean type.
+   */
+  String getName();
+
+  /**
+   * Return the full name of the bean type.
+   */
+  String getFullName();
+
+  /**
+   * Return the class type this BeanDescriptor describes.
+   */
+  Class<T> getBeanType();
+
+  /**
+   * Return the type bean for an OneToMany or ManyToOne or ManyToMany property.
+   */
+  BeanType<?> getBeanTypeAtPath(String propertyName);
+
+  /**
+   * Return all the properties for this bean type.
+   */
+  Collection<? extends Property> allProperties();
+
+  /**
+   * Return the Id property.
+   */
+  Property getIdProperty();
+
+  /**
+   * Return the when modified property if there is one defined.
+   */
+  Property getWhenModifiedProperty();
+
+  /**
+   * Return the when created property if there is one defined.
+   */
+  Property getWhenCreatedProperty();
+
+  /**
+   * Return the Property to read values from a bean.
+   */
+  Property getProperty(String propertyName);
+
+  /**
+   * Return the ExpressionPath for a given property path.
+   * <p>
+   * This can return a property or nested property path.
+   * </p>
+   */
+  ExpressionPath getExpressionPath(String path);
+
+  /**
+   * Return true if the property is a valid known property or path for the given bean type.
+   */
+  boolean isValidExpression(String property);
+
+  /**
+   * Return the base table this bean type maps to.
+   */
+  String getBaseTable();
+
+  /**
+   * Create a new instance of the bean.
+   */
+  T createBean();
+
+  /**
+   * Return the bean id. This is the same as getBeanId() but without the generic type.
+   */
+  Object beanId(Object bean);
+
+  /**
+   * Return the id value for the given bean.
+   */
+  Object getBeanId(T bean);
+
+  /**
+   * Set the id value to the bean.
+   */
+  void setBeanId(T bean, Object idValue);
+
+  /**
+   * Return the bean persist controller.
+   */
+  BeanPersistController getPersistController();
+
+  /**
+   * Return the bean persist listener.
+   */
+  BeanPersistListener getPersistListener();
+
+  /**
+   * Return the beanFinder. Usually null unless overriding the finder.
+   */
+  BeanFindController getFindController();
+
+  /**
+   * Return the BeanQueryAdapter or null if none is defined.
+   */
+  BeanQueryAdapter getQueryAdapter();
+
+  /**
+   * Return the identity generation type.
+   */
+  IdType getIdType();
+
+  /**
+   * Return the sequence name associated to this entity bean type (if there is one).
+   */
+  String getSequenceName();
+
+  /**
+   * Return true if this bean type has doc store backing.
+   */
+  boolean isDocStoreMapped();
+
+  /**
+   * Return the DocumentMapping for this bean type.
+   * <p>
+   * This is the document structure and mapping options for how this bean type is mapped
+   * for the document store.
+   * </p>
+   */
+  DocumentMapping getDocMapping();
+
+  /**
+   * Return the doc store queueId for this bean type.
+   */
+  String getDocStoreQueueId();
+
+  /**
+   * Return the doc store support for this bean type.\
+   */
+  BeanDocType<T> docStore();
+
+  /**
+   * Add the discriminator value to the query if needed.
+   */
+  void addInheritanceWhere(SpiQuery<?> query);
+
+  /**
+   * Return the root bean type for an inheritance hierarchy.
+   */
+  BeanType<?> root();
+
+  /**
+   * Return true if this bean type has an inheritance hierarchy.
+   */
+  boolean hasInheritance();
+
+  /**
+   * Return the discriminator column.
+   */
+  String getDiscColumn();
+
+  /**
+   * Create a bean given the discriminator value.
+   */
+  T createBeanUsingDisc(Object discValue);
+}

src/main/java/com/avaje/ebean/plugin/ExpressionPath.java

@@ -0,0 +1,76 @@
+package com.avaje.ebean.plugin;
+
+import com.avaje.ebean.bean.EntityBean;
+import com.avaje.ebean.text.StringParser;
+
+/**
+ * A dot notation expression path.
+ */
+public interface ExpressionPath {
+
+  /**
+   * Return true if there is a property on the path that is a many property.
+   */
+  boolean containsMany();
+
+  /**
+   * Return the value from a given entity bean.
+   */
+  Object pathGet(Object bean);
+
+  /**
+   * Set a value to the bean for this expression path.
+   *
+   * @param bean  the bean to set the value on
+   * @param value the value to set
+   */
+  void pathSet(Object bean, Object value);
+
+  /**
+   * Convert the value to the expected type.
+   * <p>
+   * Typically useful for converting strings to the appropriate number type etc.
+   * </p>
+   */
+  Object convert(Object value);
+
+  /**
+   * Return the default StringParser for the scalar property.
+   */
+  StringParser getStringParser();
+
+  /**
+   * For DateTime capable scalar types convert the long systemTimeMillis into
+   * an appropriate java time (Date,Timestamp,Time,Calendar, JODA type etc).
+   */
+  Object parseDateTime(long systemTimeMillis);
+
+  /**
+   * Return true if the last type is "DateTime capable" - can support
+   * {@link #parseDateTime(long)}.
+   */
+  boolean isDateTimeCapable();
+
+  /**
+   * Return the underlying JDBC type or 0 if this is not a scalar type.
+   */
+  int getJdbcType();
+
+  /**
+   * Return true if this is an ManyToOne or OneToOne associated bean property.
+   */
+  boolean isAssocId();
+
+  /**
+   * Return the Id expression string.
+   * <p>
+   * Typically used to produce id = ? expression strings.
+   * </p>
+   */
+  String getAssocIdExpression(String propName, String bindOperator);
+
+  /**
+   * Return the Id values for the given bean value.
+   */
+  Object[] getAssocIdValues(EntityBean bean);
+}

src/main/java/com/avaje/ebean/plugin/Plugin.java

@@ -3,7 +3,7 @@ package com.avaje.ebean.plugin;
 /**
  * A 'plugin' that wants to be configured on startup so it can use features of the EbeanServer itself.
  */
-public interface SpiServerPlugin {
+public interface Plugin {
 
   /**
    * Configure the plugin.

src/main/java/com/avaje/ebean/plugin/Property.java

@@ -0,0 +1,22 @@
+package com.avaje.ebean.plugin;
+
+/**
+ * Property of a entity bean that can be read.
+ */
+public interface Property {
+
+  /**
+   * Return the name of the property.
+   */
+  String getName();
+
+  /**
+   * Return the value of the property on the given bean.
+   */
+  Object getVal(Object bean);
+
+  /**
+   * Return true if this is a OneToMany or ManyToMany property.
+   */
+  boolean isMany();
+}

src/main/java/com/avaje/ebean/plugin/SpiBeanType.java

@@ -1,64 +0,0 @@
-package com.avaje.ebean.plugin;
-
-import com.avaje.ebean.config.dbplatform.IdType;
-import com.avaje.ebean.event.BeanFindController;
-import com.avaje.ebean.event.BeanPersistController;
-import com.avaje.ebean.event.BeanPersistListener;
-import com.avaje.ebean.event.BeanQueryAdapter;
-
-/**
- * Information and methods on BeanDescriptors made available to plugins.
- */
-public interface SpiBeanType<T> {
-
-  /**
-   * Return the class type this BeanDescriptor describes.
-   */
-  Class<T> getBeanType();
-
-  /**
-   * Return true if the property is a valid known property or path for the given bean type.
-   */
-  boolean isValidExpression(String property);
-
-    /**
-     * Return the base table this bean type maps to.
-     */
-  String getBaseTable();
-
-  /**
-   * Return the id value for the given bean.
-   */
-  Object getBeanId(T bean);
-
-  /**
-   * Return the bean persist controller.
-   */
-  BeanPersistController getPersistController();
-
-  /**
-   * Return the bean persist listener.
-   */
-  BeanPersistListener getPersistListener();
-
-  /**
-   * Return the beanFinder. Usually null unless overriding the finder.
-   */
-  BeanFindController getFindController();
-
-  /**
-   * Return the BeanQueryAdapter or null if none is defined.
-   */
-  BeanQueryAdapter getQueryAdapter();
-
-  /**
-   * Return the identity generation type.
-   */
-  IdType getIdType();
-
-  /**
-   * Return the sequence name associated to this entity bean type (if there is one).
-   */
-  String getSequenceName();
-
-}

src/main/java/com/avaje/ebean/plugin/SpiServer.java

@@ -4,6 +4,7 @@ import com.avaje.ebean.EbeanServer;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 
+import javax.sql.DataSource;
 import java.util.List;
 
 /**
@@ -24,16 +25,30 @@ public interface SpiServer extends EbeanServer {
   /**
    * Return all the bean types registered on this server instance.
    */
-  List<? extends SpiBeanType<?>> getBeanTypes();
+  List<? extends BeanType<?>> getBeanTypes();
 
   /**
    * Return the bean type for a given entity bean class.
    */
-  <T> SpiBeanType<T> getBeanType(Class<T> beanClass);
+  <T> BeanType<T> getBeanType(Class<T> beanClass);
 
   /**
    * Return the bean types mapped to the given base table.
    */
-  List<? extends SpiBeanType<?>> getBeanTypes(String baseTableName);
+  List<? extends BeanType<?>> getBeanTypes(String baseTableName);
 
+  /**
+   * Return the bean type for a given doc store queueId.
+   */
+  BeanType<?> getBeanTypeForQueueId(String queueId);
+
+  /**
+   * Return the associated DataSource for this EbeanServer instance.
+   */
+  DataSource getDataSource();
+
+  /**
+   * Initialise the query cache for the given bean type.
+   */
+  boolean initQueryCache(String key);
 }

src/main/java/com/avaje/ebean/search/AbstractMatch.java

@@ -0,0 +1,98 @@
+package com.avaje.ebean.search;
+
+/**
+ * Options for the text match and multi match expressions.
+ */
+public abstract class AbstractMatch {
+
+  protected boolean operatorAnd;
+
+  protected String analyzer;
+
+  protected double boost;
+
+  protected String minShouldMatch;
+
+  protected int maxExpansions;
+
+  protected String zeroTerms;
+
+  protected double cutoffFrequency;
+
+  protected String fuzziness;
+
+  protected int prefixLength;
+
+  protected String rewrite;
+
+  /**
+   * Return true if using the AND operator otherwise using the OR operator.
+   */
+  public boolean isOperatorAnd() {
+    return operatorAnd;
+  }
+
+  /**
+   * Return the boost.
+   */
+  public double getBoost() {
+    return boost;
+  }
+
+  /**
+   * Return the minimum should match.
+   */
+  public String getMinShouldMatch() {
+    return minShouldMatch;
+  }
+
+  /**
+   * Return the zero terms option.
+   */
+  public String getZeroTerms() {
+    return zeroTerms;
+  }
+
+  /**
+   * Return the cutoff frequency.
+   */
+  public double getCutoffFrequency() {
+    return cutoffFrequency;
+  }
+
+  /**
+   * Return the max expansions.
+   */
+  public int getMaxExpansions() {
+    return maxExpansions;
+  }
+
+  /**
+   * Return the analyzer.
+   */
+  public String getAnalyzer() {
+    return analyzer;
+  }
+
+  /**
+   * Return the fuzziness.
+   */
+  public String getFuzziness() {
+    return fuzziness;
+  }
+
+  /**
+   * Return the prefix length.
+   */
+  public int getPrefixLength() {
+    return prefixLength;
+  }
+
+  /**
+   * Return the rewrite option.
+   */
+  public String getRewrite() {
+    return rewrite;
+  }
+
+}

src/main/java/com/avaje/ebean/search/Match.java

@@ -0,0 +1,117 @@
+package com.avaje.ebean.search;
+
+/**
+ * Options for the text match expression.
+ */
+public class Match extends AbstractMatch {
+
+  protected boolean phrase;
+
+  protected boolean phrasePrefix;
+
+  public Match() {
+  }
+
+  /**
+   * Set this to be a "Phrase" type expression.
+   */
+  public Match phrase() {
+    phrase = true;
+    return this;
+  }
+
+  /**
+   * Set this to be a "Phrase Prefix" type expression.
+   */
+  public Match phrasePrefix() {
+    phrasePrefix = true;
+    return this;
+  }
+
+  /**
+   * Use the AND operator (rather than OR).
+   */
+  public Match opAnd() {
+    operatorAnd = true;
+    return this;
+  }
+
+  /**
+   * Use the OR operator (rather than AND).
+   */
+  public Match opOr() {
+    operatorAnd = false;
+    return this;
+  }
+
+  /**
+   * Set the zero terms.
+   */
+  public Match zeroTerms(String zeroTerms) {
+    this.zeroTerms = zeroTerms;
+    return this;
+  }
+
+  /**
+   * Set the cutoff frequency.
+   */
+  public Match cutoffFrequency(double cutoffFrequency) {
+    this.cutoffFrequency = cutoffFrequency;
+    return this;
+  }
+
+  /**
+   * Set the max expansions (for phrase prefix only).
+   */
+  public Match maxExpansions(int maxExpansions) {
+    this.maxExpansions = maxExpansions;
+    return this;
+  }
+
+  /**
+   * Set the Analyzer to use for this expression.
+   */
+  public Match analyzer(String analyzer) {
+    this.analyzer = analyzer;
+    return this;
+  }
+
+  /**
+   * Set the boost.
+   */
+  public Match boost(double boost) {
+    this.boost = boost;
+    return this;
+  }
+
+  /**
+   * Set the rewrite to use.
+   */
+  public Match minShouldMatch(String minShouldMatch) {
+    this.minShouldMatch = minShouldMatch;
+    return this;
+  }
+
+  /**
+   * Set the rewrite to use.
+   */
+  public Match rewrite(String rewrite) {
+    this.rewrite = rewrite;
+    return this;
+  }
+
+  /**
+   * Return true if this is a phrase query.
+   */
+  public boolean isPhrase() {
+    return phrase;
+  }
+
+  /**
+   * Return true if this is a phrase prefix query.
+   */
+  public boolean isPhrasePrefix() {
+    return phrasePrefix;
+  }
+
+}

src/main/java/com/avaje/ebean/search/MultiMatch.java

@@ -0,0 +1,148 @@
+package com.avaje.ebean.search;
+
+/**
+ * Options for the text match expression.
+ */
+public class MultiMatch extends AbstractMatch {
+
+  /**
+   * The MultiMatch type.
+   */
+  public enum Type {
+    BEST_FIELDS,
+    MOST_FIELDS,
+    CROSS_FIELDS,
+    PHRASE,
+    PHRASE_PREFIX
+  }
+
+  protected final String[] fields;
+
+  protected Type type = Type.BEST_FIELDS;
+
+  protected double tieBreaker;
+
+  /**
+   * Create with the given fields.
+   */
+  public static MultiMatch fields(String... fields) {
+    return new MultiMatch(fields);
+  }
+
+  /**
+   * Construct with a set of fields.
+   */
+  public MultiMatch(String... fields) {
+    this.fields = fields;
+  }
+
+  /**
+   * Set the type of query.
+   */
+  public MultiMatch type(Type type) {
+    this.type = type;
+    return this;
+  }
+
+  /**
+   * Set the tieBreaker to use.
+   */
+  public MultiMatch tieBreaker(double tieBreaker) {
+    this.tieBreaker = tieBreaker;
+    return this;
+  }
+
+  /**
+   * Use the AND operator (rather than OR).
+   */
+  public MultiMatch opAnd() {
+    operatorAnd = true;
+    return this;
+  }
+
+  /**
+   * Use the OR operator (rather than AND).
+   */
+  public MultiMatch opOr() {
+    operatorAnd = false;
+    return this;
+  }
+
+  /**
+   * Set the minimum should match value.
+   */
+  public MultiMatch minShouldMatch(String minShouldMatch) {
+    this.minShouldMatch = minShouldMatch;
+    return this;
+  }
+
+  /**
+   * Set the boost.
+   */
+  public MultiMatch boost(double boost) {
+    this.boost = boost;
+    return this;
+  }
+
+  /**
+   * Set the zero terms.
+   */
+  public MultiMatch zeroTerms(String zeroTerms) {
+    this.zeroTerms = zeroTerms;
+    return this;
+  }
+
+  /**
+   * Set the cutoff frequency.
+   */
+  public MultiMatch cutoffFrequency(double cutoffFrequency) {
+    this.cutoffFrequency = cutoffFrequency;
+    return this;
+  }
+
+  /**
+   * Set the max expansions (for phrase prefix only).
+   */
+  public MultiMatch maxExpansions(int maxExpansions) {
+    this.maxExpansions = maxExpansions;
+    return this;
+  }
+
+  /**
+   * Set the Analyzer to use for this expression.
+   */
+  public MultiMatch analyzer(String analyzer) {
+    this.analyzer = analyzer;
+    return this;
+  }
+
+  /**
+   * Set the rewrite to use.
+   */
+  public MultiMatch rewrite(String rewrite) {
+    this.rewrite = rewrite;
+    return this;
+  }
+
+  /**
+   * Return the type.
+   */
+  public Type getType() {
+    return type;
+  }
+
+  /**
+   * Return the fields to search.
+   */
+  public String[] getFields() {
+    return fields;
+  }
+
+  /**
+   * Return the tie breaker.
+   */
+  public double getTieBreaker() {
+    return tieBreaker;
+  }
+
+}

src/main/java/com/avaje/ebean/search/TextCommonTerms.java

@@ -0,0 +1,141 @@
+package com.avaje.ebean.search;
+
+/**
+ * Text common terms query.
+ * <p>
+ * This maps to an ElasticSearch "common terms query".
+ * </p>
+
+ * <pre>{@code
+ *
+ *  TextCommonTerms options = new TextCommonTerms()
+ *    .cutoffFrequency(0.001)
+ *    .minShouldMatch("50%")
+ *    .lowFreqOperatorAnd(true)
+ *    .highFreqOperatorAnd(true);
+ *
+ *  List<Customer> customers = server.find(Customer.class)
+ *    .text()
+ *    .textCommonTerms("the brown", options)
+ *    .findList();
+ *
+ * }</pre>
+ *
+ * <pre>{@code
+ *
+ *   // ElasticSearch expression
+ *
+ *   "common": {
+ *     "body": {
+ *       "query": "the brown",
+ *       "cutoff_frequency": 0.001,
+ *       "low_freq_operator": "and",
+ *       "high_freq_operator": "and",
+ *       "minimum_should_match": "50%"
+ *     }
+ *   }
+ *
+ * }</pre>
+ */
+public class TextCommonTerms {
+
+  protected double cutoffFrequency;
+
+  protected boolean lowFreqOperatorAnd;
+  protected boolean highFreqOperatorAnd;
+
+  protected String minShouldMatch;
+  protected String minShouldMatchLowFreq;
+  protected String minShouldMatchHighFreq;
+
+  /**
+   * Set the cutoff frequency.
+   */
+  public TextCommonTerms cutoffFrequency(double cutoffFrequency) {
+    this.cutoffFrequency = cutoffFrequency;
+    return this;
+  }
+
+  /**
+   * Set to true if low frequency terms should use AND operator.
+   */
+  public TextCommonTerms lowFreqOperatorAnd(boolean opAnd) {
+    this.lowFreqOperatorAnd = opAnd;
+    return this;
+  }
+
+  /**
+   * Set to true if high frequency terms should use AND operator.
+   */
+  public TextCommonTerms highFreqOperatorAnd(boolean opAnd) {
+    this.highFreqOperatorAnd = opAnd;
+    return this;
+  }
+
+  /**
+   * Set the minimum should match.
+   */
+  public TextCommonTerms minShouldMatch(String minShouldMatch) {
+    this.minShouldMatch = minShouldMatch;
+    return this;
+  }
+
+  /**
+   * Set the minimum should match for low frequency terms.
+   */
+  public TextCommonTerms minShouldMatchLowFreq(String minShouldMatchLowFreq) {
+    this.minShouldMatchLowFreq = minShouldMatchLowFreq;
+    return this;
+  }
+
+  /**
+   * Set the minimum should match for high frequency terms.
+   */
+  public TextCommonTerms minShouldMatchHighFreq(String minShouldMatchHighFreq) {
+    this.minShouldMatchHighFreq = minShouldMatchHighFreq;
+    return this;
+  }
+
+  /**
+   * Return true if low freq should use the AND operator.
+   */
+  public boolean isLowFreqOperatorAnd() {
+    return lowFreqOperatorAnd;
+  }
+
+  /**
+   * Return true if high freq should use the AND operator.
+   */
+  public boolean isHighFreqOperatorAnd() {
+    return highFreqOperatorAnd;
+  }
+
+  /**
+   * Return the cutoff frequency.
+   */
+  public double getCutoffFrequency() {
+    return cutoffFrequency;
+  }
+
+  /**
+   * Return the minimum to match.
+   */
+  public String getMinShouldMatch() {
+    return minShouldMatch;
+  }
+
+  /**
+   * Return the minimum to match for high frequency.
+   */
+  public String getMinShouldMatchHighFreq() {
+    return minShouldMatchHighFreq;
+  }
+
+  /**
+   * Return the minimum to match for low frequency.
+   */
+  public String getMinShouldMatchLowFreq() {
+    return minShouldMatchLowFreq;
+  }
+
+}