[maven-release-plugin] prepare release ebean-parent-12.6.3

Add ebean-redis as module

.gitignore

@@ -1,6 +1,4 @@
 *.autofetch
-*create-all.sql
-*drop-all.sql
 *.orig
 .classpath
 .project
@@ -12,7 +10,6 @@ ebean-autotune.xml
 ebean-profiling*.xml
 /db
 /mydb.db
-!src/test/ddl-review/*.sql
 profiling/
 
 # Intellij project files
@@ -20,4 +17,4 @@ profiling/
 *.ipr
 *.iws
 .idea/
-*uuid.state
+*uuid.state

.travis/print_surefire_reports

@@ -7,4 +7,11 @@ do
     echo ${file}
     cat ${file}
     echo
-done
+done
+
+for file in ebean-autotune/target/surefire-reports/*.txt
+do
+    echo ${file}
+    cat ${file}
+    echo
+done

ebean-api/pom.xml

@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <artifactId>ebean-parent</artifactId>
+    <groupId>io.ebean</groupId>
+    <version>12.6.3</version>
+  </parent>
+
+  <name>ebean api</name>
+  <description>ebean api</description>
+  <artifactId>ebean-api</artifactId>
+
+  <properties>
+    <jackson-core.version>2.11.3</jackson-core.version>
+    <jackson-databind.version>2.11.3</jackson-databind.version>
+  </properties>
+
+  <dependencies>
+
+    <!--
+    Projects are expected to explicit depend on version
+    of slf4j that they want to use
+    -->
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.30</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>avaje-config</artifactId>
+      <version>1.3</version>
+    </dependency>
+
+    <!--
+    Class retention Nonnull and Nullable annotations
+    to assist with IDE auto-completion with Ebean API
+    -->
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>avaje-jsr305</artifactId>
+      <version>1.0</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>persistence-api</artifactId>
+      <version>2.2.4</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-annotation</artifactId>
+      <version>6.15</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-types</artifactId>
+      <version>2.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-datasource-api</artifactId>
+      <version>${ebean-datasource.version}</version>
+    </dependency>
+
+    <!-- Jackson core used internally by Ebean -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-core</artifactId>
+      <version>${jackson-core.version}</version>
+      <optional>true</optional>
+    </dependency>
+
+    <!-- provided scope for JsonNode support -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>${jackson-databind.version}</version>
+      <optional>true</optional>
+    </dependency>
+
+    <!-- Provided scope so that the H2HistoryTrigger can live in Ebean core
+     and not require a separate module for it -->
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <version>1.4.199</version>
+      <optional>true</optional>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.transaction</groupId>
+      <artifactId>jta</artifactId>
+      <version>1.1</version>
+      <optional>true</optional>
+    </dependency>
+
+    <!-- provided scope to read validation annotations Size etc -->
+    <dependency>
+      <groupId>javax.validation</groupId>
+      <artifactId>validation-api</artifactId>
+      <version>1.1.0.Final</version>
+      <optional>true</optional>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.servlet</groupId>
+      <artifactId>javax.servlet-api</artifactId>
+      <version>3.1.0</version>
+      <optional>true</optional>
+    </dependency>
+
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.5</version>
+        <configuration>
+          <archive>
+            <manifestFile>src/main/resources/META-INF/MANIFEST.MF</manifestFile>
+          </archive>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+</project>

ebean-api/src/main/java/io/ebean/BackgroundExecutor.java

@@ -0,0 +1,109 @@
+package io.ebean;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Background executor service for executing of tasks asynchronously.
+ * <p>
+ * This service can be used to execute tasks in the background.
+ * <p>
+ * This service is managed by Ebean and will perform a clean shutdown
+ * waiting for background tasks to complete with a default 30 second
+ * timeout. Shutdown occurs prior to DataSource shutdown.
+ * <p>
+ * This also propagates MDC context from the current thread to the
+ * background task if defined.
+ */
+public interface BackgroundExecutor {
+
+  /**
+   * Execute a callable task in the background returning the Future.
+   */
+  <T> Future<T> submit(Callable<T> task);
+
+  /**
+   * Execute a runnable task in the background returning the Future.
+   */
+  Future<?> submit(Runnable task);
+
+  /**
+   * Execute a task in the background. Effectively the same as
+   * {@link BackgroundExecutor#submit(Runnable)} but returns void.
+   */
+  void execute(Runnable task);
+
+  /**
+   * Deprecated - migrate to scheduleWithFixedDelay().
+   * Execute a task periodically with a fixed delay between each execution.
+   * <p>
+   * For example, execute a runnable every minute.
+   * <p>
+   * The delay is the time between executions no matter how long the task took.
+   * That is, this method has the same behaviour characteristics as
+   * {@link ScheduledExecutorService#scheduleWithFixedDelay(Runnable, long, long, TimeUnit)}
+   */
+  @Deprecated
+  void executePeriodically(Runnable task, long delay, TimeUnit unit);
+
+  /**
+   * Deprecated - migrate to scheduleWithFixedDelay().
+   * Execute a task periodically additionally with an initial delay different from delay.
+   */
+  @Deprecated
+  void executePeriodically(Runnable task, long initialDelay, long delay, TimeUnit unit);
+
+  /**
+   * Execute a task periodically with a given delay.
+   *
+   * @param task         the task to execute
+   * @param initialDelay the time to delay first execution
+   * @param delay        the delay between the termination of one
+   *                     execution and the commencement of the next
+   * @param unit         the time unit of the initialDelay and delay parameters
+   * @return a ScheduledFuture representing pending completion of
+   * the series of repeated tasks.  The future's {@link
+   * Future#get() get()} method will never return normally,
+   * and will throw an exception upon task cancellation or
+   * abnormal termination of a task execution.
+   */
+  ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit);
+
+  /**
+   * Execute a task periodically with a given period.
+   *
+   * <p>If any execution of this task takes longer than its period, then
+   * subsequent executions may start late, but will not concurrently
+   * execute.
+   *
+   * @param task         the task to execute
+   * @param initialDelay the time to delay first execution
+   * @param period       the period between successive executions
+   * @param unit         the time unit of the initialDelay and period parameters
+   * @return a ScheduledFuture representing pending completion of
+   * the series of repeated tasks.  The future's {@link
+   * Future#get() get()} method will never return normally,
+   * and will throw an exception upon task cancellation or
+   * abnormal termination of a task execution.
+   */
+  ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit);
+
+  /**
+   * Schedules a Runnable for one-shot action that becomes enabled after the given delay.
+   *
+   * @return a ScheduledFuture representing pending completion of the task and
+   * whose get() method will return null upon completion
+   */
+  ScheduledFuture<?> schedule(Runnable task, long delay, TimeUnit unit);
+
+  /**
+   * Schedules a Callable for one-shot action that becomes enabled after the given delay.
+   *
+   * @return a ScheduledFuture that can be used to extract result or cancel
+   */
+  <V> ScheduledFuture<V> schedule(Callable<V> task, long delay, TimeUnit unit);
+
+}

ebean-api/src/main/java/io/ebean/DB.java

@@ -60,7 +60,9 @@ import java.util.concurrent.Callable;
  *
  * }</pre>
  */
-public class DB {
+public final class DB {
+
+  private static final DbContext context = DbContext.getInstance();
 
   /**
    * Hide constructor.
@@ -68,11 +70,18 @@ public class DB {
   private DB() {
   }
 
+  /**
+   * Backdoor for registering a mock implementation of Database as the default database.
+   */
+  protected static Database mock(String name, Database server, boolean defaultServer) {
+    return context.mock(name, server, defaultServer);
+  }
+
   /**
    * Return the default database.
    */
   public static Database getDefault() {
-    return Ebean.getDefaultServer();
+    return context.getDefault();
   }
 
   /**
@@ -81,26 +90,9 @@ public class DB {
    * @param name The name of the database
    */
   public static Database byName(String name) {
-    return Ebean.getServer(name);
+    return context.get(name);
   }
 
-//  /**
-//   * Register the server with this Ebean singleton. Specify if the registered
-//   * server is the primary/default database.
-//   */
-//  public static void register(EbeanServer server, boolean defaultServer) {
-//    serverMgr.register(server, defaultServer);
-//  }
-//
-//  /**
-//   * Backdoor for registering a mock implementation of EbeanServer as the default database.
-//   */
-//  protected static EbeanServer mock(String name, EbeanServer server, boolean defaultServer) {
-//    EbeanServer originalPrimaryServer = serverMgr.defaultServer;
-//    serverMgr.registerWithName(name, server, defaultServer);
-//    return originalPrimaryServer;
-//  }
-
   /**
    * Return the ScriptRunner for the default database.
    * <p>

ebean-api/src/main/java/io/ebean/Database.java

@@ -14,6 +14,7 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
+import javax.sql.DataSource;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -93,6 +94,11 @@ import java.util.concurrent.Callable;
  */
 public interface Database {
 
+  /**
+   * Shutdown the Database instance.
+   */
+  void shutdown();
+
   /**
    * Shutdown the Database instance programmatically.
    * <p>
@@ -116,6 +122,16 @@ public interface Database {
    */
   AutoTune getAutoTune();
 
+  /**
+   * Return the associated DataSource for this Database instance.
+   */
+  DataSource getDataSource();
+
+  /**
+   * Return the associated read only DataSource for this Database instance (can be null).
+   */
+  DataSource getReadOnlyDataSource();
+
   /**
    * Return the name. This is used with {@link DB#byName(String)} to get a
    * Database that was registered with the DB singleton.

ebean-api/src/main/java/io/ebean/DatabaseFactory.java

@@ -0,0 +1,157 @@
+package io.ebean;
+
+import io.ebean.config.ContainerConfig;
+import io.ebean.config.DatabaseConfig;
+import io.ebean.service.SpiContainer;
+import io.ebean.service.SpiContainerFactory;
+
+import javax.persistence.PersistenceException;
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.ServiceLoader;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Creates Database instances.
+ * <p>
+ * This uses either DatabaseConfig or properties in the application.properties file to
+ * configure and create a Database instance.
+ * </p>
+ * <p>
+ * The Database instance can either be registered with the DB singleton or
+ * not. The DB singleton effectively holds a map of Database by a name.
+ * If the Database is registered with the DB singleton you can retrieve it
+ * later via {@link DB#byName(String)}.
+ * </p>
+ * <p>
+ * One Database can be nominated as the 'default/primary' Database. Many
+ * methods on the DB singleton such as {@link DB#find(Class)} are just a
+ * convenient way of using the 'default/primary' Database.
+ * </p>
+ */
+public class DatabaseFactory {
+
+  private static final ReentrantLock lock = new ReentrantLock();
+  private static SpiContainer container;
+
+  static {
+    EbeanVersion.getVersion();
+  }
+
+  /**
+   * Initialise the container with clustering configuration.
+   * <p>
+   * Call this prior to creating any Database instances or alternatively set the
+   * ContainerConfig on the DatabaseConfig when creating the first Database instance.
+   */
+  public static void initialiseContainer(ContainerConfig containerConfig) {
+    lock.lock();
+    try {
+      getContainer(containerConfig);
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  /**
+   * Create using properties to configure the database.
+   */
+  public static Database create(String name) {
+    lock.lock();
+    try {
+      return getContainer(null).createServer(name);
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  /**
+   * Create using the DatabaseConfig object to configure the database.
+   */
+  public static Database create(DatabaseConfig config) {
+    lock.lock();
+    try {
+      if (config.getName() == null) {
+        throw new PersistenceException("The name is null (it is required)");
+      }
+      Database server = createInternal(config);
+      if (config.isRegister()) {
+        DbPrimary.setSkip(true);
+        DbContext.getInstance().register(server, config.isDefaultServer());
+      }
+      return server;
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  /**
+   * Create using the DatabaseConfig additionally specifying a classLoader to use as the context class loader.
+   */
+  public static Database createWithContextClassLoader(DatabaseConfig config, ClassLoader classLoader) {
+    lock.lock();
+    try {
+      ClassLoader currentContextLoader = Thread.currentThread().getContextClassLoader();
+      Thread.currentThread().setContextClassLoader(classLoader);
+      try {
+        return DatabaseFactory.create(config);
+      } finally {
+        // set the currentContextLoader back
+        Thread.currentThread().setContextClassLoader(currentContextLoader);
+      }
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  /**
+   * Shutdown gracefully all Database instances cleaning up any resources as required.
+   * <p>
+   * This is typically invoked via JVM shutdown hook and not explicitly called.
+   * </p>
+   */
+  public static void shutdown() {
+    lock.lock();
+    try {
+      container.shutdown();
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  private static Database createInternal(DatabaseConfig config) {
+    return getContainer(config.getContainerConfig()).createServer(config);
+  }
+
+  /**
+   * Get the EbeanContainer initialising it if necessary.
+   *
+   * @param containerConfig the configuration controlling clustering communication
+   */
+  private static SpiContainer getContainer(ContainerConfig containerConfig) {
+    // thread safe in that all calling methods hold lock
+    if (container != null) {
+      return container;
+    }
+
+    if (containerConfig == null) {
+      // effectively load configuration from ebean.properties
+      Properties properties = DbPrimary.getProperties();
+      containerConfig = new ContainerConfig();
+      containerConfig.loadFromProperties(properties);
+    }
+    container = createContainer(containerConfig);
+    return container;
+  }
+
+  /**
+   * Create the container instance using the configuration.
+   */
+  protected static SpiContainer createContainer(ContainerConfig containerConfig) {
+    Iterator<SpiContainerFactory> factories = ServiceLoader.load(SpiContainerFactory.class).iterator();
+    if (factories.hasNext()) {
+      return factories.next().create(containerConfig);
+    }
+    throw new IllegalStateException("Service loader didn't find a SpiContainerFactory?");
+  }
+}

ebean-api/src/main/java/io/ebean/DbContext.java

@@ -0,0 +1,139 @@
+package io.ebean;
+
+import io.ebean.config.BeanNotEnhancedException;
+import io.ebean.datasource.DataSourceConfigurationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.persistence.PersistenceException;
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Holds Database instances.
+ */
+final class DbContext {
+
+  private static final Logger logger = LoggerFactory.getLogger(DbContext.class);
+
+  static {
+    EbeanVersion.getVersion();
+  }
+
+  private static final DbContext INSTANCE = new DbContext();
+
+  private final ConcurrentHashMap<String, Database> concMap = new ConcurrentHashMap<>();
+
+  private final HashMap<String, Database> syncMap = new HashMap<>();
+
+  private final ReentrantLock lock = new ReentrantLock();
+
+  /**
+   * The 'default' Database.
+   */
+  private Database defaultDatabase;
+
+  private DbContext() {
+    try {
+      if (!DbPrimary.isSkip()) {
+        // look to see if there is a default server defined
+        String defaultName = DbPrimary.getDefaultServerName();
+        logger.debug("defaultName:{}", defaultName);
+        if (defaultName != null && !defaultName.trim().isEmpty()) {
+          defaultDatabase = getWithCreate(defaultName.trim());
+        }
+      }
+    } catch (BeanNotEnhancedException e) {
+      throw e;
+
+    } catch (DataSourceConfigurationException e) {
+      String msg = "Configuration error creating DataSource for the default Database." +
+        " This typically means a missing application-test.yaml or missing ebean-test dependency." +
+        " See https://ebean.io/docs/trouble-shooting#datasource";
+      throw new DataSourceConfigurationException(msg, e);
+
+    } catch (Throwable e) {
+      logger.error("Error trying to create the default Database", e);
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Return the shared singleton instance.
+   */
+  static DbContext getInstance() {
+    return INSTANCE;
+  }
+
+  /**
+   * Return the default database.
+   */
+  Database getDefault() {
+    if (defaultDatabase == null) {
+      String msg = "The default Database has not been defined?";
+      msg += " This is normally set via the ebean.datasource.default property.";
+      msg += " Otherwise it should be registered programmatically via registerServer()";
+      throw new PersistenceException(msg);
+    }
+    return defaultDatabase;
+  }
+
+  /**
+   * Return the database by name.
+   */
+  Database get(String name) {
+    if (name == null || name.isEmpty()) {
+      return defaultDatabase;
+    }
+    Database server = concMap.get(name);
+    if (server != null) {
+      return server;
+    }
+    return getWithCreate(name);
+  }
+
+  /**
+   * Read, create and put of Databases.
+   */
+  private Database getWithCreate(String name) {
+    lock.lock();
+    try {
+      Database server = syncMap.get(name);
+      if (server == null) {
+        // register when creating server this way
+        server = DatabaseFactory.create(name);
+        register(server, false);
+      }
+      return server;
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  /**
+   * Register a server so we can get it by its name.
+   */
+  void register(Database server, boolean isDefault) {
+    registerWithName(server.getName(), server, isDefault);
+  }
+
+  private void registerWithName(String name, Database server, boolean isDefault) {
+    lock.lock();
+    try {
+      concMap.put(name, server);
+      syncMap.put(name, server);
+      if (isDefault) {
+        defaultDatabase = server;
+      }
+    } finally {
+      lock.unlock();
+    }
+  }
+
+  Database mock(String name, Database server, boolean defaultServer) {
+    Database originalPrimaryServer = this.defaultDatabase;
+    registerWithName(name, server, defaultServer);
+    return originalPrimaryServer;
+  }
+}

ebean-api/src/main/java/io/ebean/DbPrimary.java

@@ -3,55 +3,75 @@ package io.ebean;
 import io.avaje.config.Config;
 
 import java.util.Properties;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Provides singleton state for the default database.
  * <p/>
  * Intended for internal use as part of bootup, construction, registration of the default database.
  */
-class PrimaryServer {
+class DbPrimary {
 
+  private static final ReentrantLock lock = new ReentrantLock();
   private static String defaultServerName;
-
   private static boolean skip;
 
   /**
    * Set whether to skip automatically creating the primary database.
    */
-  static synchronized void setSkip(boolean skip) {
-    PrimaryServer.skip = skip;
+  static void setSkip(boolean skip) {
+    lock.lock();
+    try {
+      DbPrimary.skip = skip;
+    } finally {
+      lock.unlock();
+    }
   }
 
   /**
    * Return true to skip automatically creating the primary database.
    */
-  static synchronized boolean isSkip() {
-    return skip;
+  static boolean isSkip() {
+    lock.lock();
+    try {
+      return skip;
+    } finally {
+      lock.unlock();
+    }
   }
 
   /**
    * Return the default database name.
    */
-  static synchronized String getDefaultServerName() {
-    getProperties();
-    return defaultServerName;
+  static String getDefaultServerName() {
+    lock.lock();
+    try {
+      getProperties();
+      return defaultServerName;
+    } finally {
+      lock.unlock();
+    }
   }
 
   /**
    * Return the default configuration Properties.
    */
-  static synchronized Properties getProperties() {
-    if (defaultServerName == null) {
-      defaultServerName = determineDefaultServerName();
+  static Properties getProperties() {
+    lock.lock();
+    try {
+      if (defaultServerName == null) {
+        defaultServerName = determineDefaultServerName();
+      }
+      return Config.asProperties();
+    } finally {
+      lock.unlock();
     }
-    return Config.asProperties();
   }
 
   /**
    * Determine and return the default server name checking system environment variables and then global properties.
    */
   private static String determineDefaultServerName() {
-
     String defaultServerName = System.getenv("EBEAN_DB");
     defaultServerName = System.getProperty("db", defaultServerName);
     defaultServerName = System.getProperty("ebean_db", defaultServerName);

ebean-api/src/main/java/io/ebean/DocumentStore.java

@@ -1,9 +1,9 @@
 package io.ebean;
 
-import io.ebeanservice.docstore.api.DocQueryRequest;
-import io.ebeanservice.docstore.api.RawDoc;
-import javax.annotation.Nullable;
+import io.ebean.docstore.DocQueryContext;
+import io.ebean.docstore.RawDoc;
 
+import javax.annotation.Nullable;
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
@@ -69,7 +69,7 @@ public interface DocumentStore {
    * }</pre>
    */
   @Nullable
-  <T> T find(DocQueryRequest<T> request);
+  <T> T find(DocQueryContext<T> request);
 
   /**
    * Execute the find list query. This request is prepared to execute secondary queries.
@@ -86,7 +86,7 @@ public interface DocumentStore {
    *
    * }</pre>
    */
-  <T> List<T> findList(DocQueryRequest<T> request);
+  <T> List<T> findList(DocQueryContext<T> request);
 
   /**
    * Execute the query against the document store returning the paged list.
@@ -107,7 +107,7 @@ public interface DocumentStore {
    *
    * }</pre>
    */
-  <T> PagedList<T> findPagedList(DocQueryRequest<T> request);
+  <T> PagedList<T> findPagedList(DocQueryContext<T> request);
 
   /**
    * Execute the query against the document store with the expectation of a large set of results
@@ -129,7 +129,7 @@ public interface DocumentStore {
    *
    * }</pre>
    */
-  <T> void findEach(DocQueryRequest<T> query, Consumer<T> consumer);
+  <T> void findEach(DocQueryContext<T> query, Consumer<T> consumer);
 
   /**
    * Execute the query against the document store with the expectation of a large set of results
@@ -161,7 +161,7 @@ public interface DocumentStore {
    *
    * }</pre>
    */
-  <T> void findEachWhile(DocQueryRequest<T> query, Predicate<T> consumer);
+  <T> void findEachWhile(DocQueryContext<T> query, Predicate<T> consumer);
 
   /**
    * Find each processing raw documents.

ebean-api/src/main/java/io/ebean/Ebean.java

@@ -2,26 +2,19 @@ package io.ebean;
 
 import io.ebean.annotation.TxIsolation;
 import io.ebean.cache.ServerCacheManager;
-import io.ebean.config.BeanNotEnhancedException;
-import io.ebean.config.ServerConfig;
-import io.ebean.datasource.DataSourceConfigurationException;
 import io.ebean.plugin.Property;
 import io.ebean.text.csv.CsvReader;
 import io.ebean.text.json.JsonContext;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 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.Set;
 import java.util.concurrent.Callable;
-import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Deprecated - please migrate to use <code>io.ebean.DB</code>.
@@ -34,123 +27,8 @@ import java.util.concurrent.ConcurrentHashMap;
  */
 @Deprecated
 public final class Ebean {
-  private static final Logger logger = LoggerFactory.getLogger(Ebean.class);
 
-  static {
-    EbeanVersion.getVersion(); // initialises the version class and logs the version.
-  }
-
-  /**
-   * Manages creation and cache of Databases.
-   */
-  private static final Ebean.ServerManager serverMgr = new Ebean.ServerManager();
-
-  /**
-   * Helper class for managing fast and safe access and creation of Databases.
-   */
-  private static final class ServerManager {
-
-    /**
-     * Cache for fast concurrent read access.
-     */
-    private final ConcurrentHashMap<String, EbeanServer> concMap = new ConcurrentHashMap<>();
-
-    /**
-     * Cache for synchronized read, creation and put. Protected by the monitor object.
-     */
-    private final HashMap<String, EbeanServer> syncMap = new HashMap<>();
-
-    private final Object monitor = new Object();
-
-    /**
-     * The 'default' Database.
-     */
-    private EbeanServer defaultServer;
-
-    private ServerManager() {
-
-      try {
-        if (!PrimaryServer.isSkip()) {
-          // look to see if there is a default server defined
-          String defaultName = PrimaryServer.getDefaultServerName();
-          logger.debug("defaultName:{}", defaultName);
-          if (defaultName != null && !defaultName.trim().isEmpty()) {
-            defaultServer = getWithCreate(defaultName.trim());
-          }
-        }
-      } catch (BeanNotEnhancedException e) {
-        throw e;
-
-      } catch (DataSourceConfigurationException e) {
-        String msg = "Configuration error creating DataSource for the default Database." +
-          " This typically means a missing application-test.yaml or missing ebean-test dependency." +
-          " See https://ebean.io/docs/trouble-shooting#datasource";
-        throw new DataSourceConfigurationException(msg, e);
-
-      } catch (Throwable e) {
-        logger.error("Error trying to create the default Database", e);
-        throw new RuntimeException(e);
-      }
-    }
-
-    private EbeanServer getDefaultServer() {
-      if (defaultServer == null) {
-        String msg = "The default Database has not been defined?";
-        msg += " This is normally set via the ebean.datasource.default property.";
-        msg += " Otherwise it should be registered programmatically via registerServer()";
-        throw new PersistenceException(msg);
-      }
-      return defaultServer;
-    }
-
-    private EbeanServer get(String name) {
-      if (name == null || name.isEmpty()) {
-        return defaultServer;
-      }
-      // non-synchronized read
-      EbeanServer server = concMap.get(name);
-      if (server != null) {
-        return server;
-      }
-      // synchronized read, create and put
-      return getWithCreate(name);
-    }
-
-    /**
-     * Synchronized read, create and put of Databases.
-     */
-    private EbeanServer getWithCreate(String name) {
-
-      synchronized (monitor) {
-
-        EbeanServer server = syncMap.get(name);
-        if (server == null) {
-          // register when creating server this way
-          server = EbeanServerFactory.create(name);
-          register(server, false);
-        }
-        return server;
-      }
-    }
-
-    /**
-     * Register a server so we can get it by its name.
-     */
-    private void register(EbeanServer server, boolean isDefaultServer) {
-      registerWithName(server.getName(), server, isDefaultServer);
-    }
-
-    private void registerWithName(String name, EbeanServer server, boolean isDefaultServer) {
-      synchronized (monitor) {
-        concMap.put(name, server);
-        syncMap.put(name, server);
-        if (isDefaultServer) {
-          defaultServer = server;
-        }
-      }
-    }
-
-  }
+  private static final DbContext context = DbContext.getInstance();
 
   private Ebean() {
   }
@@ -174,7 +52,7 @@ public final class Ebean {
    * @param name the name of the server, can use null for the 'default server'
    */
   public static EbeanServer getServer(String name) {
-    return serverMgr.get(name);
+    return (EbeanServer)context.get(name);
   }
 
   /**
@@ -184,7 +62,27 @@ public final class Ebean {
    * </p>
    */
   public static EbeanServer getDefaultServer() {
-    return serverMgr.getDefaultServer();
+    return (EbeanServer)context.getDefault();
+  }
+
+  /**
+   * Register the server with this Ebean singleton. Specify if the registered
+   * server is the primary/default database.
+   */
+  @Deprecated
+  public static void register(EbeanServer server, boolean defaultServer) {
+    context.register(server, defaultServer);
+  }
+
+  /**
+   * Backdoor for registering a mock implementation of EbeanServer as the default database.
+   */
+  protected static EbeanServer mock(String name, EbeanServer server, boolean defaultServer) {
+    return (EbeanServer)context.mock(name, server, defaultServer);
+  }
+
+  private static Database getDefault() {
+    return context.getDefault();
   }
 
   /**
@@ -205,24 +103,7 @@ public final class Ebean {
    * </p>
    */
   public static ExpressionFactory getExpressionFactory() {
-    return serverMgr.getDefaultServer().getExpressionFactory();
-  }
-
-  /**
-   * Register the server with this Ebean singleton. Specify if the registered
-   * server is the primary/default database.
-   */
-  public static void register(EbeanServer server, boolean defaultServer) {
-    serverMgr.register(server, defaultServer);
-  }
-
-  /**
-   * Backdoor for registering a mock implementation of EbeanServer as the default database.
-   */
-  protected static EbeanServer mock(String name, EbeanServer server, boolean defaultServer) {
-    EbeanServer originalPrimaryServer = serverMgr.defaultServer;
-    serverMgr.registerWithName(name, server, defaultServer);
-    return originalPrimaryServer;
+    return getDefault().getExpressionFactory();
   }
 
   /**
@@ -238,7 +119,7 @@ public final class Ebean {
    * </p>
    */
   public static Object nextId(Class<?> beanType) {
-    return serverMgr.getDefaultServer().nextId(beanType);
+    return getDefault().nextId(beanType);
   }
 
   /**
@@ -284,7 +165,7 @@ public final class Ebean {
    * </p>
    */
   public static Transaction beginTransaction() {
-    return serverMgr.getDefaultServer().beginTransaction();
+    return getDefault().beginTransaction();
   }
 
   /**
@@ -293,7 +174,7 @@ public final class Ebean {
    * @param isolation the Transaction isolation level
    */
   public static Transaction beginTransaction(TxIsolation isolation) {
-    return serverMgr.getDefaultServer().beginTransaction(isolation);
+    return getDefault().beginTransaction(isolation);
   }
 
   /**
@@ -346,7 +227,7 @@ public final class Ebean {
    * }</pre>
    */
   public static Transaction beginTransaction(TxScope scope) {
-    return serverMgr.getDefaultServer().beginTransaction(scope);
+    return getDefault().beginTransaction(scope);
   }
 
   /**
@@ -354,7 +235,7 @@ public final class Ebean {
    * in scope.
    */
   public static Transaction currentTransaction() {
-    return serverMgr.getDefaultServer().currentTransaction();
+    return getDefault().currentTransaction();
   }
 
   /**
@@ -384,21 +265,21 @@ public final class Ebean {
    * @throws PersistenceException if there is no currently active transaction
    */
   public static void register(TransactionCallback transactionCallback) throws PersistenceException {
-    serverMgr.getDefaultServer().register(transactionCallback);
+    getDefault().register(transactionCallback);
   }
 
   /**
    * Commit the current transaction.
    */
   public static void commitTransaction() {
-    serverMgr.getDefaultServer().commitTransaction();
+    getDefault().commitTransaction();
   }
 
   /**
    * Rollback the current transaction.
    */
   public static void rollbackTransaction() {
-    serverMgr.getDefaultServer().rollbackTransaction();
+    getDefault().rollbackTransaction();
   }
 
   /**
@@ -426,14 +307,14 @@ public final class Ebean {
    * }</pre>
    */
   public static void endTransaction() {
-    serverMgr.getDefaultServer().endTransaction();
+    getDefault().endTransaction();
   }
 
   /**
    * Mark the current transaction as rollback only.
    */
   public static void setRollbackOnly() {
-    serverMgr.getDefaultServer().currentTransaction().setRollbackOnly();
+    getDefault().currentTransaction().setRollbackOnly();
   }
 
   /**
@@ -444,7 +325,7 @@ public final class Ebean {
    * </p>
    */
   public static Map<String, ValuePair> diff(Object a, Object b) {
-    return serverMgr.getDefaultServer().diff(a, b);
+    return getDefault().diff(a, b);
   }
 
   /**
@@ -478,7 +359,7 @@ public final class Ebean {
    * </p>
    */
   public static void save(Object bean) throws OptimisticLockException {
-    serverMgr.getDefaultServer().save(bean);
+    getDefault().save(bean);
   }
 
   /**
@@ -486,14 +367,14 @@ public final class Ebean {
    * want to explicitly insert it.
    */
   public static void insert(Object bean) {
-    serverMgr.getDefaultServer().insert(bean);
+    getDefault().insert(bean);
   }
 
   /**
    * Insert a collection of beans.
    */
   public static void insertAll(Collection<?> beans) {
-    serverMgr.getDefaultServer().insertAll(beans);
+    getDefault().insertAll(beans);
   }
 
   /**
@@ -516,7 +397,7 @@ public final class Ebean {
    * }</pre>
    */
   public static void markAsDirty(Object bean) throws OptimisticLockException {
-    serverMgr.getDefaultServer().markAsDirty(bean);
+    getDefault().markAsDirty(bean);
   }
 
   /**
@@ -543,14 +424,14 @@ public final class Ebean {
    * }</pre>
    */
   public static void update(Object bean) throws OptimisticLockException {
-    serverMgr.getDefaultServer().update(bean);
+    getDefault().update(bean);
   }
 
   /**
    * Update the beans in the collection.
    */
   public static void updateAll(Collection<?> beans) throws OptimisticLockException {
-    serverMgr.getDefaultServer().updateAll(beans);
+    getDefault().updateAll(beans);
   }
 
   /**
@@ -559,7 +440,7 @@ public final class Ebean {
    * @param bean The bean to merge
    */
   public static void merge(Object bean) {
-    serverMgr.getDefaultServer().merge(bean);
+    getDefault().merge(bean);
   }
 
   /**
@@ -569,14 +450,14 @@ public final class Ebean {
    * @param options The options to control the merge
    */
   public static void merge(Object bean, MergeOptions options) {
-    serverMgr.getDefaultServer().merge(bean, options);
+    getDefault().merge(bean, options);
   }
 
   /**
    * Save all the beans from a Collection.
    */
   public static int saveAll(Collection<?> beans) throws OptimisticLockException {
-    return serverMgr.getDefaultServer().saveAll(beans);
+    return getDefault().saveAll(beans);
   }
 
   /**
@@ -627,7 +508,7 @@ public final class Ebean {
    */
   @Nonnull
   public static Set<Property> checkUniqueness(Object bean) {
-    return serverMgr.getDefaultServer().checkUniqueness(bean);
+    return getDefault().checkUniqueness(bean);
   }
 
   /**
@@ -635,7 +516,7 @@ public final class Ebean {
    */
   @Nonnull
   public static Set<Property> checkUniqueness(Object bean, Transaction transaction) {
-    return serverMgr.getDefaultServer().checkUniqueness(bean, transaction);
+    return getDefault().checkUniqueness(bean, transaction);
   }
 
   /**
@@ -658,56 +539,56 @@ public final class Ebean {
    * </p>
    */
   public static boolean delete(Object bean) throws OptimisticLockException {
-    return serverMgr.getDefaultServer().delete(bean);
+    return getDefault().delete(bean);
   }
 
   /**
    * Delete the bean in permanent fashion (will not use soft delete).
    */
   public static boolean deletePermanent(Object bean) throws OptimisticLockException {
-    return serverMgr.getDefaultServer().deletePermanent(bean);
+    return getDefault().deletePermanent(bean);
   }
 
   /**
    * Delete the bean given its type and id.
    */
   public static int delete(Class<?> beanType, Object id) {
-    return serverMgr.getDefaultServer().delete(beanType, id);
+    return getDefault().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);
+    return getDefault().deletePermanent(beanType, id);
   }
 
   /**
    * Delete several beans given their type and id values.
    */
   public static int deleteAll(Class<?> beanType, Collection<?> ids) {
-    return serverMgr.getDefaultServer().deleteAll(beanType, ids);
+    return getDefault().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);
+    return getDefault().deleteAllPermanent(beanType, ids);
   }
 
   /**
    * Delete all the beans in the Collection.
    */
   public static int deleteAll(Collection<?> beans) throws OptimisticLockException {
-    return serverMgr.getDefaultServer().deleteAll(beans);
+    return getDefault().deleteAll(beans);
   }
 
   /**
    * Delete permanent all the beans in the Collection (will not use soft delete).
    */
   public static int deleteAllPermanent(Collection<?> beans) throws OptimisticLockException {
-    return serverMgr.getDefaultServer().deleteAllPermanent(beans);
+    return getDefault().deleteAllPermanent(beans);
   }
 
   /**
@@ -718,7 +599,7 @@ public final class Ebean {
    * </p>
    */
   public static void refresh(Object bean) {
-    serverMgr.getDefaultServer().refresh(bean);
+    getDefault().refresh(bean);
   }
 
   /**
@@ -736,7 +617,7 @@ public final class Ebean {
    * @param manyPropertyName the property name of the List Set or Map to refresh.
    */
   public static void refreshMany(Object bean, String manyPropertyName) {
-    serverMgr.getDefaultServer().refreshMany(bean, manyPropertyName);
+    getDefault().refreshMany(bean, manyPropertyName);
   }
 
   /**
@@ -761,7 +642,7 @@ public final class Ebean {
    * @param id       the id value
    */
   public static <T> T getReference(Class<T> beanType, Object id) {
-    return serverMgr.getDefaultServer().getReference(beanType, id);
+    return getDefault().getReference(beanType, id);
   }
 
   /**
@@ -804,7 +685,7 @@ public final class Ebean {
    * @param sortByClause the properties to sort the list by
    */
   public static <T> void sort(List<T> list, String sortByClause) {
-    serverMgr.getDefaultServer().sort(list, sortByClause);
+    getDefault().sort(list, sortByClause);
   }
 
   /**
@@ -854,7 +735,7 @@ public final class Ebean {
    */
   @Nullable
   public static <T> T find(Class<T> beanType, Object id) {
-    return serverMgr.getDefaultServer().find(beanType, id);
+    return getDefault().find(beanType, id);
   }
 
   /**
@@ -869,7 +750,7 @@ public final class Ebean {
    */
   @Deprecated
   public static SqlQuery createSqlQuery(String sql) {
-    return serverMgr.getDefaultServer().sqlQuery(sql);
+    return getDefault().sqlQuery(sql);
   }
 
   /**
@@ -884,7 +765,7 @@ public final class Ebean {
    */
   @Deprecated
   public static SqlUpdate createSqlUpdate(String sql) {
-    return serverMgr.getDefaultServer().sqlUpdate(sql);
+    return getDefault().sqlUpdate(sql);
   }
 
   /**
@@ -893,7 +774,7 @@ public final class Ebean {
    * @see CallableSql
    */
   public static CallableSql createCallableSql(String sql) {
-    return serverMgr.getDefaultServer().createCallableSql(sql);
+    return getDefault().createCallableSql(sql);
   }
 
   /**
@@ -925,16 +806,14 @@ public final class Ebean {
    * }</pre>
    */
   public static <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) {
-
-    return serverMgr.getDefaultServer().createUpdate(beanType, ormUpdate);
+    return getDefault().createUpdate(beanType, ormUpdate);
   }
 
   /**
    * Create a CsvReader for a given beanType.
    */
   public static <T> CsvReader<T> createCsvReader(Class<T> beanType) {
-
-    return serverMgr.getDefaultServer().createCsvReader(beanType);
+    return getDefault().createCsvReader(beanType);
   }
 
   /**
@@ -949,7 +828,7 @@ public final class Ebean {
    * @return The query
    */
   public static <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
-    return serverMgr.getDefaultServer().createNamedQuery(beanType, namedQuery);
+    return getDefault().createNamedQuery(beanType, namedQuery);
   }
 
   /**
@@ -972,8 +851,7 @@ public final class Ebean {
    * @return A ORM Query object for this beanType
    */
   public static <T> Query<T> createQuery(Class<T> beanType) {
-
-    return serverMgr.getDefaultServer().createQuery(beanType);
+    return getDefault().createQuery(beanType);
   }
 
   /**
@@ -1010,8 +888,7 @@ public final class Ebean {
    * @return The query with expressions defined as per the parsed query statement
    */
   public static <T> Query<T> createQuery(Class<T> beanType, String eql) {
-
-    return serverMgr.getDefaultServer().createQuery(beanType, eql);
+    return getDefault().createQuery(beanType, eql);
   }
 
   /**
@@ -1026,8 +903,7 @@ public final class Ebean {
    * @return A ORM Query object for this beanType
    */
   public static <T> Query<T> find(Class<T> beanType) {
-
-    return serverMgr.getDefaultServer().find(beanType);
+    return getDefault().find(beanType);
   }
 
   /**
@@ -1050,7 +926,7 @@ public final class Ebean {
    * @return The query to set parameters and execute
    */
   public static <T> Query<T> findNative(Class<T> beanType, String nativeSql) {
-    return serverMgr.getDefaultServer().findNative(beanType, nativeSql);
+    return getDefault().findNative(beanType, nativeSql);
   }
 
   /**
@@ -1065,7 +941,7 @@ public final class Ebean {
    * @param <T>     The type of the DTO bean.
    */
   public static <T> DtoQuery<T> findDto(Class<T> dtoType, String sql) {
-    return serverMgr.getDefaultServer().findDto(dtoType, sql);
+    return getDefault().findDto(dtoType, sql);
   }
 
   /**
@@ -1087,7 +963,7 @@ public final class Ebean {
    * @return The update query to use
    */
   public static <T> UpdateQuery<T> update(Class<T> beanType) {
-    return serverMgr.getDefaultServer().update(beanType);
+    return getDefault().update(beanType);
   }
 
   /**
@@ -1101,7 +977,7 @@ public final class Ebean {
    * </p>
    */
   public static <T> Filter<T> filter(Class<T> beanType) {
-    return serverMgr.getDefaultServer().filter(beanType);
+    return getDefault().filter(beanType);
   }
 
   /**
@@ -1144,7 +1020,7 @@ public final class Ebean {
    * @see Ebean#execute(CallableSql)
    */
   public static int execute(SqlUpdate sqlUpdate) {
-    return serverMgr.getDefaultServer().execute(sqlUpdate);
+    return getDefault().execute(sqlUpdate);
   }
 
   /**
@@ -1172,7 +1048,7 @@ public final class Ebean {
    * @see Ebean#execute(SqlUpdate)
    */
   public static int execute(CallableSql callableSql) {
-    return serverMgr.getDefaultServer().execute(callableSql);
+    return getDefault().execute(callableSql);
   }
 
   /**
@@ -1196,7 +1072,7 @@ public final class Ebean {
    * }</pre>
    */
   public static void execute(TxScope scope, Runnable r) {
-    serverMgr.getDefaultServer().execute(scope, r);
+    getDefault().execute(scope, r);
   }
 
   /**
@@ -1223,7 +1099,7 @@ public final class Ebean {
    * }</pre>
    */
   public static void execute(Runnable r) {
-    serverMgr.getDefaultServer().execute(r);
+    getDefault().execute(r);
   }
 
   /**
@@ -1248,7 +1124,7 @@ public final class Ebean {
    * }</pre>
    */
   public static <T> T executeCall(TxScope scope, Callable<T> c) {
-    return serverMgr.getDefaultServer().executeCall(scope, c);
+    return getDefault().executeCall(scope, c);
   }
 
   /**
@@ -1281,7 +1157,7 @@ public final class Ebean {
    * }</pre>
    */
   public static <T> T executeCall(Callable<T> c) {
-    return serverMgr.getDefaultServer().executeCall(c);
+    return getDefault().executeCall(c);
   }
 
   /**
@@ -1315,8 +1191,7 @@ public final class Ebean {
    * @param deletes   true if rows on the table where deleted
    */
   public static void externalModification(String tableName, boolean inserts, boolean updates, boolean deletes) {
-
-    serverMgr.getDefaultServer().externalModification(tableName, inserts, updates, deletes);
+    getDefault().externalModification(tableName, inserts, updates, deletes);
   }
 
   /**
@@ -1326,14 +1201,14 @@ public final class Ebean {
    * </p>
    */
   public static BeanState getBeanState(Object bean) {
-    return serverMgr.getDefaultServer().getBeanState(bean);
+    return getDefault().getBeanState(bean);
   }
 
   /**
    * Return the manager of the server cache ("L2" cache).
    */
   public static ServerCacheManager getServerCacheManager() {
-    return serverMgr.getDefaultServer().getServerCacheManager();
+    return getDefault().getServerCacheManager();
   }
 
   /**
@@ -1341,14 +1216,14 @@ public final class Ebean {
    * queries.
    */
   public static BackgroundExecutor getBackgroundExecutor() {
-    return serverMgr.getDefaultServer().getBackgroundExecutor();
+    return getDefault().getBackgroundExecutor();
   }
 
   /**
    * Return the JsonContext for reading/writing JSON.
    */
   public static JsonContext json() {
-    return serverMgr.getDefaultServer().json();
+    return getDefault().json();
   }
 
 }

ebean-api/src/main/java/io/ebean/EbeanServerFactory.java

@@ -0,0 +1,70 @@
+package io.ebean;
+
+import io.ebean.config.ContainerConfig;
+import io.ebean.config.ServerConfig;
+
+/**
+ * Deprecated - please migrate to DatabaseFactory.
+ * <p>
+ * Creates EbeanServer instances.
+ * <p>
+ * This uses either a ServerConfig or properties in the ebean.properties file to
+ * configure and create a EbeanServer instance.
+ * </p>
+ * <p>
+ * The EbeanServer instance can either be registered with the Ebean singleton or
+ * not. The Ebean singleton effectively holds a map of EbeanServers by a name.
+ * If the EbeanServer is registered with the Ebean singleton you can retrieve it
+ * later via {@link Ebean#getServer(String)}.
+ * </p>
+ * <p>
+ * One EbeanServer can be nominated as the 'default/primary' EbeanServer. Many
+ * methods on the Ebean singleton such as {@link Ebean#find(Class)} are just a
+ * convenient way of using the 'default/primary' EbeanServer.
+ * </p>
+ */
+@Deprecated
+public class EbeanServerFactory {
+
+  /**
+   * Initialise the container with clustering configuration.
+   * <p>
+   * Call this prior to creating any EbeanServer instances or alternatively set the
+   * ContainerConfig on the ServerConfig when creating the first EbeanServer instance.
+   */
+  public static void initialiseContainer(ContainerConfig containerConfig) {
+    DatabaseFactory.initialiseContainer(containerConfig);
+  }
+
+  /**
+   * Create using ebean.properties to configure the database.
+   */
+  public static EbeanServer create(String name) {
+    return (EbeanServer)DatabaseFactory.create(name);
+  }
+
+  /**
+   * Create using the ServerConfig object to configure the database.
+   */
+  public static EbeanServer create(ServerConfig config) {
+    return (EbeanServer)DatabaseFactory.create(config);
+  }
+
+  /**
+   * Create using the ServerConfig additionally specifying a classLoader to use as the context class loader.
+   */
+  public static EbeanServer createWithContextClassLoader(ServerConfig config, ClassLoader classLoader) {
+    return (EbeanServer)DatabaseFactory.createWithContextClassLoader(config, classLoader);
+  }
+
+  /**
+   * Shutdown gracefully all EbeanServers cleaning up any resources as required.
+   * <p>
+   * This is typically invoked via JVM shutdown hook and not explicitly called.
+   * </p>
+   */
+  public static void shutdown() {
+    DatabaseFactory.shutdown();
+  }
+
+}

ebean-api/src/main/java/io/ebean/EbeanVersion.java

@@ -6,18 +6,18 @@ import org.slf4j.LoggerFactory;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Properties;
+
 /**
- * Class to determine the ebean version. (
- * @author Roland Praml, FOCONIS AG
+ * Class to determine the ebean version.
  *
+ * @author Roland Praml, FOCONIS AG
  */
 public class EbeanVersion {
-  private EbeanVersion() {
 
-  }
   private static final Logger logger = LoggerFactory.getLogger(EbeanVersion.class);
 
   private static String version = "unknown";
+
   static {
     try {
       Properties prop = new Properties();
@@ -34,6 +34,10 @@ public class EbeanVersion {
     }
   }
 
+  private EbeanVersion() {
+    // hide
+  }
+
   /**
    * Returns the ebean version (read from /META-INF/maven/io.ebean/ebean/pom.properties)
    */

ebean-api/src/main/java/io/ebean/ExpressionFactory.java

@@ -199,6 +199,14 @@ public interface ExpressionFactory {
    */
   Expression gtOrNull(String propertyName, Object value);
 
+  /**
+   * Greater than or Equal to OR Null <code> >= or null </code>
+   * <p>
+   * A convenient expression combining GE and Is Null.  Most often useful for range
+   * expressions where the top range value is nullable.
+   */
+  Expression geOrNull(String propertyName, Object value);
+
   /**
    * Greater Than - property greater than the given value.
    */
@@ -218,6 +226,14 @@ public interface ExpressionFactory {
    */
   Expression ltOrNull(String propertyName, Object value);
 
+  /**
+   * Less Than or Equal to OR Null <code> <= or null </code>
+   * <p>
+   * A convenient expression combining LE and Is Null.  Most often useful for range
+   * expressions where the bottom range value is nullable.
+   */
+  Expression leOrNull(String propertyName, Object value);
+
   /**
    * Less Than - property less than the given value.
    */

ebean-api/src/main/java/io/ebean/ExpressionList.java

@@ -169,11 +169,40 @@ public interface ExpressionList<T> {
    */
   UpdateQuery<T> asUpdate();
 
+  /**
+   * Execute the query with the given lock type and WAIT.
+   * <p>
+   * Note that <code>forUpdate()</code> is the same as
+   * <code>withLock(LockType.UPDATE)</code>.
+   * <p>
+   * Provides us with the ability to explicitly use Postgres
+   * SHARE, KEY SHARE, NO KEY UPDATE and UPDATE row locks.
+   */
+  Query<T> withLock(Query.LockType lockType);
+
+  /**
+   * Execute the query with the given lock type and lock wait.
+   * <p>
+   * Note that <code>forUpdateNoWait()</code> is the same as
+   * <code>withLock(LockType.UPDATE, LockWait.NOWAIT)</code>.
+   * <p>
+   * Provides us with the ability to explicitly use Postgres
+   * SHARE, KEY SHARE, NO KEY UPDATE and UPDATE row locks.
+   */
+  Query<T> withLock(Query.LockType lockType, Query.LockWait lockWait);
+
   /**
    * Execute using "for update" clause which results in the DB locking the record.
    */
   Query<T> forUpdate();
 
+  /**
+   * Deprecated - migrate to withLock().
+   * Execute using "for update" with given lock type (currently Postgres only).
+   */
+  @Deprecated
+  Query<T> forUpdate(Query.LockType lockType);
+
   /**
    * Execute using "for update" clause with No Wait option.
    * <p>
@@ -182,6 +211,13 @@ public interface ExpressionList<T> {
    */
   Query<T> forUpdateNoWait();
 
+  /**
+   * Deprecated - migrate to withLock().
+   * Execute using "for update nowait" with given lock type (currently Postgres only).
+   */
+  @Deprecated
+  Query<T> forUpdateNoWait(Query.LockType lockType);
+
   /**
    * Execute using "for update" clause with Skip Locked option.
    * <p>
@@ -190,6 +226,13 @@ public interface ExpressionList<T> {
    */
   Query<T> forUpdateSkipLocked();
 
+  /**
+   * Deprecated - migrate to withLock().
+   * Execute using "for update skip locked" with given lock type (currently Postgres only).
+   */
+  @Deprecated
+  Query<T> forUpdateSkipLocked(Query.LockType lockType);
+
   /**
    * Execute the query including soft deleted rows.
    */
@@ -886,6 +929,11 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> gtOrNull(String propertyName, Object value);
 
+  /**
+   * Greater Than or Equal to OR Null - <code> >= or null </code>.
+   */
+  ExpressionList<T> geOrNull(String propertyName, Object value);
+
   /**
    * Greater Than or Equal to - property greater than or equal to the given
    * value.
@@ -902,6 +950,11 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> ltOrNull(String propertyName, Object value);
 
+  /**
+   * Less Than or Equal to OR Null - <code> <= or null </code>.
+   */
+  ExpressionList<T> leOrNull(String propertyName, Object value);
+
   /**
    * Less Than or Equal to - property less than or equal to the given value.
    */

ebean-api/src/main/java/io/ebean/ModifyAwareType.java

@@ -1,11 +1,9 @@
-package io.ebeaninternal.json;
-
-import java.io.Serializable;
+package io.ebean;
 
 /**
  * Owner object notified when a modification is detected.
  */
-public interface ModifyAwareOwner extends Serializable {
+public interface ModifyAwareType {
 
   /**
    * Return true if the value is considered dirty.
@@ -16,11 +14,6 @@ public interface ModifyAwareOwner extends Serializable {
   /**
    * Marks the object as modified.
    */
-  void markAsModified();
-
-  /**
-   * Reset the dirty state to clean.
-   */
-  void resetMarkedDirty();
+  void setMarkedDirty(boolean markedDirty);
 
 }

ebean-api/src/main/java/io/ebean/OrderBy.java

@@ -1,7 +1,5 @@
 package io.ebean;
 
-import io.ebean.util.StringHelper;
-
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
@@ -341,7 +339,7 @@ public final class OrderBy<T> implements Serializable {
         if (collation != null)  {
           if (collation.contains("${}")) {
             // this is a complex collation, e.g. DB2 - we must replace the property
-            sb.append(StringHelper.replaceString(collation, "${}", property));
+            sb.append(collation.replace("${}", property));
           } else {
             sb.append(property);
             sb.append(" collate ").append(collation);

ebean-api/src/main/java/io/ebean/PersistenceContextScope.java

@@ -6,7 +6,7 @@ package io.ebean;
  * Ebean has traditionally used Transaction scope for the PersistenceContext. This is used to change the scope to
  * use (by default) and explicitly set the scope to use for an individual query.
  *
- * @see io.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)
+ * @see io.ebean.config.DatabaseConfig#setPersistenceContextScope(PersistenceContextScope)
  * @see Query#setPersistenceContextScope(PersistenceContextScope)
  */
 public enum PersistenceContextScope {

ebean-api/src/main/java/io/ebean/Query.java

@@ -180,13 +180,44 @@ import java.util.stream.Stream;
 public interface Query<T> {
 
   /**
-   * For update mode.
+   * The lock type (strength) to use with query FOR UPDATE row locking.
    */
-  enum ForUpdate {
+  enum LockType {
+    /**
+     * The default lock type being either UPDATE or NO_KEY_UPDATE based on
+     * PlatformConfig.forUpdateNoKey configuration (Postgres option).
+     */
+    DEFAULT,
+
+    /**
+     * FOR UPDATE.
+     */
+    UPDATE,
+
+    /**
+     * FOR NO KEY UPDATE (Postgres only).
+     */
+    NO_KEY_UPDATE,
+
+    /**
+     * FOR SHARE (Postgres only).
+     */
+    SHARE,
+
+    /**
+     * FOR KEY SHARE (Postgres only).
+     */
+    KEY_SHARE
+  }
+
+  /**
+   * FOR UPDATE wait mode.
+   */
+  enum LockWait {
     /**
      * Standard For update clause.
      */
-    BASE,
+    WAIT,
 
     /**
      * For update with No Wait option.
@@ -283,7 +314,7 @@ public interface Query<T> {
   /**
    * Specify the PersistenceContextScope to use for this query.
    * <p/>
-   * When this is not set the 'default' configured on {@link io.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)}
+   * When this is not set the 'default' configured on {@link io.ebean.config.DatabaseConfig#setPersistenceContextScope(PersistenceContextScope)}
    * is used - this value defaults to {@link PersistenceContextScope#TRANSACTION}.
    * <p/>
    * Note that the same persistence Context is used for subsequent lazy loading and query join queries.
@@ -1613,36 +1644,85 @@ public interface Query<T> {
    */
   String getGeneratedSql();
 
+  /**
+   * Execute the query with the given lock type and WAIT.
+   * <p>
+   * Note that <code>forUpdate()</code> is the same as
+   * <code>withLock(LockType.UPDATE)</code>.
+   * <p>
+   * Provides us with the ability to explicitly use Postgres
+   * SHARE, KEY SHARE, NO KEY UPDATE and UPDATE row locks.
+   */
+  Query<T> withLock(LockType lockType);
+
+  /**
+   * Execute the query with the given lock type and lock wait.
+   * <p>
+   * Note that <code>forUpdateNoWait()</code> is the same as
+   * <code>withLock(LockType.UPDATE, LockWait.NOWAIT)</code>.
+   * <p>
+   * Provides us with the ability to explicitly use Postgres
+   * SHARE, KEY SHARE, NO KEY UPDATE and UPDATE row locks.
+   */
+  Query<T> withLock(LockType lockType, LockWait lockWait);
+
   /**
    * Execute using "for update" clause which results in the DB locking the record.
+   * <p>
+   * The same as <code>withLock(LockType.UPDATE, LockWait.WAIT)</code>.
    */
   Query<T> forUpdate();
 
+  /**
+   * Execute using "for update" with given lock type (currently Postgres only).
+   */
+  @Deprecated
+  Query<T> forUpdate(LockType lockType);
+
   /**
    * Execute using "for update" clause with "no wait" option.
    * <p>
    * This is typically a Postgres and Oracle only option at this stage.
-   * </p>
+   * <p>
+   * The same as <code>withLock(LockType.UPDATE, LockWait.NOWAIT)</code>.
    */
   Query<T> forUpdateNoWait();
 
+  /**
+   * Execute using "for update nowait" with given lock type (currently Postgres only).
+   */
+  @Deprecated
+  Query<T> forUpdateNoWait(LockType lockType);
+
   /**
    * Execute using "for update" clause with "skip locked" option.
    * <p>
    * This is typically a Postgres and Oracle only option at this stage.
-   * </p>
+   * <p>
+   * The same as <code>withLock(LockType.UPDATE, LockWait.SKIPLOCKED)</code>.
    */
   Query<T> forUpdateSkipLocked();
 
+  /**
+   * Execute using "for update skip locked" with given lock type (currently Postgres only).
+   */
+  @Deprecated
+  Query<T> forUpdateSkipLocked(LockType lockType);
+
   /**
    * Return true if this query has forUpdate set.
    */
   boolean isForUpdate();
 
   /**
-   * Return the "for update" mode to use.
+   * Return the "for update" wait mode to use.
    */
-  ForUpdate getForUpdateMode();
+  LockWait getForUpdateLockWait();
+
+  /**
+   * Return the lock type (strength) to use with "for update".
+   */
+  LockType getForUpdateLockType();
 
   /**
    * Set root table alias.

ebean-api/src/main/java/io/ebean/Transaction.java

@@ -2,8 +2,8 @@ package io.ebean;
 
 import io.ebean.annotation.DocStoreMode;
 import io.ebean.annotation.PersistBatch;
+import io.ebean.config.DatabaseConfig;
 import io.ebean.config.DocStoreConfig;
-import io.ebean.config.ServerConfig;
 
 import javax.persistence.PersistenceException;
 import java.sql.Connection;
@@ -226,7 +226,7 @@ public interface Transaction extends AutoCloseable {
   /**
    * Set if the L2 cache should be skipped for "find by id" and "find by natural key" queries.
    * <p>
-   * By default {@link ServerConfig#isSkipCacheAfterWrite()} is true and that means that for
+   * By default {@link DatabaseConfig#isSkipCacheAfterWrite()} is true and that means that for
    * "find by id" and "find by natural key" queries which normally hit L2 bean cache automatically
    * - will not do so after a persist/write on the transaction.
    * </p>
@@ -235,7 +235,7 @@ public interface Transaction extends AutoCloseable {
    * will skip the L2 bean cache or not (regardless of whether the transaction is considered "read only").
    * </p>
    * <p>
-   * Refer to {@link ServerConfig#setSkipCacheAfterWrite(boolean)} for configuring the default behavior
+   * Refer to {@link DatabaseConfig#setSkipCacheAfterWrite(boolean)} for configuring the default behavior
    * for using the L2 bean cache in transactions spanning multiple query/persist requests.
    * </p>
    *
@@ -276,7 +276,7 @@ public interface Transaction extends AutoCloseable {
    *
    * }</pre>
    *
-   * @see ServerConfig#isSkipCacheAfterWrite()
+   * @see DatabaseConfig#isSkipCacheAfterWrite()
    */
   void setSkipCache(boolean skipCache);
 
@@ -402,7 +402,7 @@ public interface Transaction extends AutoCloseable {
    * </p>
    *
    * @param batchMode the batch mode to use per save(), insert(), update() or delete()
-   * @see io.ebean.config.ServerConfig#setPersistBatchOnCascade(PersistBatch)
+   * @see io.ebean.config.DatabaseConfig#setPersistBatchOnCascade(PersistBatch)
    */
   void setBatchOnCascade(boolean batchMode);
 

ebean-api/src/main/java/io/ebean/bean/BeanLoader.java

@@ -1,5 +1,7 @@
 package io.ebean.bean;
 
+import java.util.concurrent.locks.Lock;
+
 /**
  * Loads a entity bean.
  * <p>
@@ -18,4 +20,9 @@ public interface BeanLoader {
    */
   void loadBean(EntityBeanIntercept ebi);
 
+  /**
+   * Obtain a lock on the loader.
+   */
+  Lock lock();
+
 }

ebean-api/src/main/java/io/ebean/bean/EntityBeanIntercept.java

@@ -14,6 +14,8 @@ import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * This is the object added to every entity bean using byte code enhancement.
@@ -30,6 +32,8 @@ public final class EntityBeanIntercept implements Serializable {
   private static final int STATE_REFERENCE = 1;
   private static final int STATE_LOADED = 2;
 
+  private transient final ReentrantLock lock = new ReentrantLock();
+
   private transient NodeUsageCollector nodeUsageCollector;
 
   private transient PersistenceContext persistenceContext;
@@ -803,7 +807,8 @@ public final class EntityBeanIntercept implements Serializable {
    * Load the bean when it is a reference.
    */
   protected void loadBean(int loadProperty) {
-    synchronized (this) {
+    lock.lock();
+    try {
       if (beanLoader == null) {
         final Database database = DB.byName(ebeanServerName);
         if (database == null) {
@@ -811,14 +816,19 @@ public final class EntityBeanIntercept implements Serializable {
         }
         // For stand alone reference bean or after deserialisation lazy load
         // using the ebeanServer. Synchronise only on the bean.
-        loadBeanInternal(loadProperty, database.getPluginApi());
+        loadBeanInternal(loadProperty, database.getPluginApi().beanLoader());
         return;
       }
+    } finally {
+      lock.unlock();
     }
-    synchronized (beanLoader) {
+    final Lock lock = beanLoader.lock();
+    try {
       // Lazy loading using LoadBeanContext which supports batch loading
       // Synchronise on the beanLoader (a 'node' of the LoadBeanContext 'tree')
       loadBeanInternal(loadProperty, beanLoader);
+    } finally {
+      lock.unlock();
     }
   }
 

ebean-api/src/main/java/io/ebean/bean/SingleBeanLoader.java

@@ -2,11 +2,16 @@ package io.ebean.bean;
 
 import io.ebean.Database;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 /**
  * BeanLoader used when single beans are loaded (which is usually not ideal / N+1).
  */
 public abstract class SingleBeanLoader implements BeanLoader {
 
+  private final ReentrantLock lock = new ReentrantLock();
+
   protected final Database database;
 
   SingleBeanLoader(Database database) {
@@ -18,6 +23,12 @@ public abstract class SingleBeanLoader implements BeanLoader {
     return database.getName();
   }
 
+  @Override
+  public Lock lock() {
+    lock.lock();
+    return lock;
+  }
+
   /**
    * Single bean lazy loaded when bean from L2 cache.
    */
@@ -45,4 +56,18 @@ public abstract class SingleBeanLoader implements BeanLoader {
       database.getPluginApi().loadBeanRef(ebi);
     }
   }
+
+  /**
+   * Single bean lazy loaded when a reference bean.
+   */
+  public static class Dflt extends SingleBeanLoader {
+    public Dflt(Database database) {
+      super(database);
+    }
+
+    @Override
+    public void loadBean(EntityBeanIntercept ebi) {
+      database.getPluginApi().loadBean(ebi);
+    }
+  }
 }