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

#2182 - Tidy javadoc - this may mean JDK 15 is required to generate javadoc
#2181 - Oracle 9,10,11 rownum based limiting for SqlQuery and DtoQuery (rather than Oracle 12g row limiting)
2024-04-21 10:51:47 +00:00 · 2021-03-01 23:45:05 +13:00 · 2021-03-01 23:40:06 +13:00 · 2021-03-01 22:47:34 +13:00 · 2021-03-01 22:08:17 +13:00 · 2021-03-01 21:34:17 +13:00
3760 changed files with 39842 additions and 10059 deletions
@@ -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
@@ -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
@@ -293,6 +293,6 @@ ebean.tenant.schemaProvider
 ebean.updateAllPropertiesInBatch
 ebean.updateChangesOnly
 ebean.updatesDeleteMissingChildren
-ebean.useJavaxValidationNotNull
+ebean.useValidationNotNull
 ebean.useJtaTransactionManager

@@ -0,0 +1,124 @@
+<?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.7.2</version>
+  </parent>
+
+  <name>ebean api</name>
+  <description>ebean api</description>
+  <artifactId>ebean-api</artifactId>
+
+  <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.version}</version>
+      <optional>true</optional>
+    </dependency>
+
+    <!-- provided scope for JsonNode support -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>${jackson.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>
+
+    <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>
@@ -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);
+
+}
@@ -14,7 +14,7 @@ import java.util.Optional;
 *
 * public class CustomerFinder extends BeanFinder<Long,Customer> {
 *
- *   ＠Inject
+ *   @Inject
 *   public CustomerFinder(Database database) {
 *     super(Customer.class, database);
 *   }
@@ -9,10 +9,10 @@ import java.util.Collection;
 * <p>
 * <pre>{@code
 *
- * ＠Repository
+ * @Repository
 * public class CustomerRepository extends BeanRepository<Long,Customer> {
 *
- *   ＠Inject
+ *   @Inject
 *   public CustomerRepository(Database server) {
 *     super(Customer.class, server);
 *   }
@@ -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>
@@ -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.
@@ -881,7 +897,7 @@ public interface Database {
   * <pre>{@code
   *   public class Order { ...
   *
-   *     ＠OneToMany(cascade=CascadeType.ALL, mappedBy="order")
+   *     @OneToMany(cascade=CascadeType.ALL, mappedBy="order")
   * 	   List<OrderDetail> details;
   * 	   ...
   *   }
@@ -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?");
+  }
+}
@@ -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;
+  }
+}
@@ -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);
@@ -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
@@ -149,7 +149,7 @@ public interface DocumentStore {
   *    .setUseDocStore(true)
   *    .where()... // perhaps add predicates
   *    .findEachWhile(new Predicate<Order>() {
-   *      ＠Override
+   *      @Override
   *      public void accept(Order bean) {
   *        // process the bean
   *
@@ -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.
@@ -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);
  }

  /**
@@ -465,7 +346,7 @@ public final class Ebean {
   * <pre>{@code
   *   public class Order { ...
   *
-   *     ＠OneToMany(cascade=CascadeType.ALL, mappedBy="order")
+   *     @OneToMany(cascade=CascadeType.ALL, mappedBy="order")
   * 	   List<OrderDetail> details;
   * 	   ...
   *   }
@@ -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();
  }

 }
@@ -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();
+  }
+
+}
@@ -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)
   */
@@ -199,6 +199,14 @@ public interface ExpressionFactory {
   */
  Expression gtOrNull(String propertyName, Object value);

+  /**
+   * Greater than or Equal to OR Null ({@code >= or null })
+   * <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 })
+   * <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.
   */
@@ -169,6 +169,28 @@ 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.
   */
@@ -886,6 +908,11 @@ public interface ExpressionList<T> {
   */
  ExpressionList<T> gtOrNull(String propertyName, Object value);

+  /**
+   * Greater Than or Equal to OR Null - ({@code >= or null }).
+   */
+  ExpressionList<T> geOrNull(String propertyName, Object value);
+
  /**
   * Greater Than or Equal to - property greater than or equal to the given
   * value.
@@ -902,6 +929,11 @@ public interface ExpressionList<T> {
   */
  ExpressionList<T> ltOrNull(String propertyName, Object value);

+  /**
+   * Less Than or Equal to OR Null - ({@code <= or null }).
+   */
+  ExpressionList<T> leOrNull(String propertyName, Object value);
+
  /**
   * Less Than or Equal to - property less than or equal to the given value.
   */
@@ -0,0 +1,246 @@
+package io.ebean;
+
+import java.io.Serializable;
+
+/**
+ * Defines how a relationship is fetched via either normal SQL join,
+ * a eager secondary query, via lazy loading or via eagerly hitting L2 cache.
+ * <p>
+ * <pre>{@code
+ * // Normal fetch join results in a single SQL query
+ * List<Order> list = DB.find(Order.class).fetch("details").findList();
+ *
+ * }</pre>
+ * <p>
+ * Example: Using a "query join" instead of a "fetch join" we instead use 2 SQL queries
+ * </p>
+ * <p>
+ * <pre>{@code
+ *
+ * // This will use 2 SQL queries to build this object graph
+ * List<Order> list =
+ *     DB.find(Order.class)
+ *         .fetch("details", FetchConfig.ofQuery())
+ *         .findList();
+ *
+ * // query 1) find order
+ * // query 2) find orderDetails where order.id in (?,?...) // first 100 order id's
+ *
+ * }</pre>
+ *
+ * @author mario
+ * @author rbygrave
+ */
+public class FetchConfig implements Serializable {
+
+  private static final long serialVersionUID = 1L;
+
+  private static final int JOIN_MODE = 0;
+  private static final int QUERY_MODE = 1;
+  private static final int LAZY_MODE = 2;
+  private static final int CACHE_MODE = 3;
+
+  private int mode;
+  private int batchSize;
+  private int hashCode;
+
+  /**
+   * Deprecated - migrate to one of the static factory methods like {@link FetchConfig#ofQuery()}
+   *
+   * Construct using default JOIN mode.
+   */
+  @Deprecated
+  public FetchConfig() {
+    //this.mode = JOIN_MODE;
+    this.batchSize = 100;
+    this.hashCode = 1000;
+  }
+
+  private FetchConfig(int mode, int batchSize) {
+    this.mode = mode;
+    this.batchSize = batchSize;
+    this.hashCode = mode + 10 * batchSize;
+  }
+
+  /**
+   * Return FetchConfig to eagerly fetch the relationship using L2 cache.
+   * <p>
+   * Any cache misses will be loaded by secondary query to the database.
+   */
+  public static FetchConfig ofCache() {
+    return new FetchConfig(CACHE_MODE, 100);
+  }
+
+  /**
+   * Return FetchConfig to eagerly fetch the relationship using a secondary query.
+   */
+  public static FetchConfig ofQuery() {
+    return new FetchConfig(QUERY_MODE, 100);
+  }
+
+  /**
+   * Return FetchConfig to eagerly fetch the relationship using a secondary with a given batch size.
+   */
+  public static FetchConfig ofQuery(int batchSize) {
+    return new FetchConfig(QUERY_MODE, batchSize);
+  }
+
+  /**
+   * Return FetchConfig to lazily load the relationship.
+   */
+  public static FetchConfig ofLazy() {
+    return new FetchConfig(LAZY_MODE, 10);
+  }
+
+  /**
+   * Return FetchConfig to lazily load the relationship specifying the batch size.
+   */
+  public static FetchConfig ofLazy(int batchSize) {
+    return new FetchConfig(LAZY_MODE, batchSize);
+  }
+
+  /**
+   * Return FetchConfig to fetch the relationship using SQL join.
+   */
+  public static FetchConfig ofDefault() {
+    return new FetchConfig(JOIN_MODE, 100);
+  }
+
+  /**
+   * We want to migrate away from mutating FetchConfig to a fully immutable FetchConfig.
+   */
+  private FetchConfig mutate(int mode, int batchSize) {
+    if (batchSize < 1) {
+      throw new IllegalArgumentException("batch size "+batchSize+" must be > 0");
+    }
+    this.mode = mode;
+    this.batchSize = batchSize;
+    this.hashCode = mode + 10 * batchSize;
+    return this;
+  }
+
+  /**
+   * Deprecated - migrate to FetchConfig.ofLazy().
+   */
+  @Deprecated
+  public FetchConfig lazy() {
+    return mutate(LAZY_MODE, 10);
+  }
+
+  /**
+   * Deprecated - migrate to FetchConfig.ofLazy(batchSize).
+   */
+  @Deprecated
+  public FetchConfig lazy(int batchSize) {
+    return mutate(LAZY_MODE, batchSize);
+  }
+
+  /**
+   * Deprecated - migrate to FetchConfig.ofQuery().
+   *
+   * Eagerly fetch the beans in this path as a separate query (rather than as
+   * part of the main query).
+   * <p>
+   * This will use the default batch size for separate query which is 100.
+   */
+  @Deprecated
+  public FetchConfig query() {
+    return mutate(QUERY_MODE, 100);
+  }
+
+  /**
+   * Deprecated - migrate to FetchConfig.ofQuery(batchSize).
+   *
+   * Eagerly fetch the beans in this path as a separate query (rather than as
+   * part of the main query).
+   * <p>
+   * The queryBatchSize is the number of parent id's that this separate query
+   * will load per batch.
+   * </p>
+   * <p>
+   * This will load all beans on this path eagerly unless a {@link #lazy(int)}
+   * is also used.
+   * </p>
+   *
+   * @param batchSize the batch size used to load beans on this path
+   */
+  @Deprecated
+  public FetchConfig query(int batchSize) {
+    return mutate(QUERY_MODE, batchSize);
+  }
+
+  /**
+   * Deprecated - migrate to FetchConfig.ofQuery(batchSize).
+   *
+   * Eagerly fetch the first batch of beans on this path.
+   * This is similar to {@link #query(int)} but only fetches the first batch.
+   * <p>
+   * If there are more parent beans than the batch size then they will not be
+   * loaded eagerly but instead use lazy loading.
+   * </p>
+   *
+   * @param batchSize the number of parent beans this path is populated for
+   */
+  @Deprecated
+  public FetchConfig queryFirst(int batchSize) {
+    return query(batchSize);
+  }
+
+  /**
+   * Deprecated - migrate to FetchConfig.ofCache().
+   *
+   * Eagerly fetch the beans fetching the beans from the L2 bean cache
+   * and using the DB for beans not in the cache.
+   */
+  @Deprecated
+  public FetchConfig cache() {
+    return mutate(CACHE_MODE, 100);
+  }
+
+  /**
+   * Return the batch size for fetching.
+   */
+  public int getBatchSize() {
+    return batchSize;
+  }
+
+  /**
+   * Return true if the fetch should use the L2 cache.
+   */
+  public boolean isCache() {
+    return mode == CACHE_MODE;
+  }
+
+  /**
+   * Return true if the fetch should be a eager secondary query.
+   */
+  public boolean isQuery() {
+    return mode == QUERY_MODE;
+  }
+
+  /**
+   * Return true if the fetch should be a lazy query.
+   */
+  public boolean isLazy() {
+    return mode == LAZY_MODE;
+  }
+
+  /**
+   * Return true if the fetch should try to use SQL join.
+   */
+  public boolean isJoin() {
+    return mode == JOIN_MODE;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    return (hashCode == ((FetchConfig) o).hashCode);
+  }
+
+  @Override
+  public int hashCode() {
+    return hashCode;
+  }
+}
@@ -37,7 +37,7 @@ import java.util.List;
 *   }
 * }
 *
- * ＠Entity
+ * @Entity
 * public class Customer extends BaseModel {
 *
 *   public static final CustomerFinder find = new CustomerFinder();
@@ -80,7 +80,7 @@ public class Finder<I, T> {
   *   // ... add extra customer specific finder methods
   * }
   *
-   * ＠Entity
+   * @Entity
   * public class Customer extends BaseModel {
   *
   *   public static final CustomerFinder find = new CustomerFinder();
@@ -32,16 +32,16 @@ import io.ebean.bean.EntityBean;
 *     // Typically there is a common base model that has some
 *     // common properties like the ones below
 *
- *   ＠MappedSuperclass
+ *   @MappedSuperclass
 *   public class BaseModel extends Model {
 *
- *     ＠Id Long id;
+ *     @Id Long id;
 *
- *     ＠Version Long version;
+ *     @Version Long version;
 *
- *     ＠WhenCreated Timestamp whenCreated;
+ *     @WhenCreated Timestamp whenCreated;
 *
- *     ＠WhenUpdated Timestamp whenUpdated;
+ *     @WhenUpdated Timestamp whenUpdated;
 *
 *     ...
 *   }
@@ -52,7 +52,7 @@ import io.ebean.bean.EntityBean;
 *
 *     // Extend the mappedSuperclass
 *
- *     ＠Entity ＠Table(name="o_account")
+ *     @Entity @Table(name="o_account")
 *     public class Customer extends BaseModel {
 *
 *       String name;
@@ -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);

 }
@@ -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);
@@ -18,7 +18,7 @@ import java.util.List;
 *
 *   // where a bean is annotated with a complex
 *   // natural key made of several properties
- *   ＠Cache(naturalKey = {"store","code","sku"})
+ *   @Cache(naturalKey = {"store","code","sku"})
 *
 *
 *   Pairs pairs = new Pairs("sku", "code");
@@ -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 {
@@ -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.
@@ -483,7 +514,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   *  fetch(path, fetchProperties, new FetchConfig().query())
+   *  fetch(path, fetchProperties, FetchConfig.ofQuery())
   *
   * }</pre>
   * <p>
@@ -517,7 +548,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   *  fetch(path, fetchProperties, new FetchConfig().lazy())
+   *  fetch(path, fetchProperties, FetchConfig.ofLazy())
   *
   * }</pre>
   * <p>
@@ -542,7 +573,7 @@ public interface Query<T> {
   * // fetch customers (their id, name and status)
   * List<Customer> customers = DB.find(Customer.class)
   *     .select("name, status")
-   *     .fetch("contacts", "firstName,lastName,email", new FetchConfig().lazy(10))
+   *     .fetch("contacts", "firstName,lastName,email", FetchConfig.ofLazy(10))
   *     .findList();
   *
   * }</pre>
@@ -579,7 +610,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   *  fetch(path, new FetchConfig().query())
+   *  fetch(path, FetchConfig.ofQuery())
   *
   * }</pre>
   * <p>
@@ -608,7 +639,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   *  fetch(path, new FetchConfig().lazy())
+   *  fetch(path, FetchConfig.ofLazy())
   *
   * }</pre>
   * <p>
@@ -631,7 +662,7 @@ public interface Query<T> {
   * // fetch customers (their id, name and status)
   * List<Customer> customers = DB.find(Customer.class)
   *     // lazy fetch contacts with a batch size of 100
-   *     .fetch("contacts", new FetchConfig().lazy(100))
+   *     .fetch("contacts", FetchConfig.ofLazy(100))
   *     .findList();
   *
   * }</pre>
@@ -813,7 +844,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   *  DB.find(Customer.class)
-   *     .fetch("contacts", new FetchConfig().query(2))
+   *     .fetch("contacts", FetchConfig.ofQuery(2))
   *     .where().eq("status", Status.NEW)
   *     .order().asc("id")
   *     .setMaxRows(2000)
@@ -1613,8 +1644,32 @@ 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();

@@ -1622,7 +1677,8 @@ public interface Query<T> {
   * 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();

@@ -1630,7 +1686,8 @@ public interface Query<T> {
   * 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();

@@ -1640,9 +1697,14 @@ public interface Query<T> {
  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.
@@ -41,14 +41,14 @@ package io.ebean;
 * <h3>Example OrderAggregate</h3>
 * <pre>{@code
 *  ...
- *   // ＠Sql indicates to that this bean
+ *   // @Sql indicates to that this bean
 *   // is based on RawSql rather than a table
 *
- *   ＠Entity
- *   ＠Sql
+ *   @Entity
+ *   @Sql
 *   public class OrderAggregate {
 *
- *    ＠OneToOne
+ *    @OneToOne
 *    Order order;
 *
 *    Double totalAmount;
@@ -107,7 +107,7 @@ package io.ebean;
 *
 *   List<OrderAggregate> orders = DB.find(OrderAggregate.class)
 *     .setRawSql(rawSql)
- *     .fetch("order", "status,orderDate", new FetchConfig().query())
+ *     .fetch("order", "status,orderDate", FetchConfig.ofQuery())
 *     .fetch("order.customer", "name")
 *     .where().gt("order.id", 0)
 *     .having().gt("totalAmount", 20)
@@ -22,7 +22,7 @@ import java.sql.SQLException;
 *    //
 *    class CustomerMapper implements RowMapper<CustomerDto> {
 *
- *     ＠Override
+ *     @Override
 *     public CustomerDto map(ResultSet rset, int rowNum) throws SQLException {
 *
 *       long id = rset.getLong(1);
@@ -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);

@@ -519,11 +519,11 @@ public interface Transaction extends AutoCloseable {
  void flush() throws PersistenceException;

  /**
-   * This is a synonym for flush() and will be deprecated.
+   * Deprecated - migrate to flush().
   * <p>
   * flush() is preferred as it matches the JPA flush() method.
-   * </p>
   */
+  @Deprecated
  void flushBatch() throws PersistenceException;

  /**
@@ -13,23 +13,23 @@ package io.ebean;
 * </p>
 * <pre>{@code
 *    ...
- *   ＠NamedUpdates(value = {
- *     ＠NamedUpdate(
+ *   @NamedUpdates(value = {
+ *     @NamedUpdate(
 *       name = "setTitle",
 *       notifyCache = false,
 *       update = "update topic set title = :title, postCount = :count where id = :id"),
- *    ＠NamedUpdate(
+ *    @NamedUpdate(
 *       name = "setPostCount",
 *       notifyCache = false,
 *       update = "update f_topic set post_count = :postCount where id = :id"),
- *    ＠NamedUpdate(
+ *    @NamedUpdate(
 *       name = "incrementPostCount",
 *       notifyCache = false,
 *       update = "update Topic set postCount = postCount + 1 where id = :id")
 *       //update = "update f_topic set post_count = post_count + 1 where id = :id")
 *   })
- *   ＠Entity
- *   ＠Table(name = "f_topic")
+ *   @Entity
+ *   @Table(name = "f_topic")
 *   public class Topic {
 *     ...
 *   }
@@ -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();
+
 }
@@ -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();
    }
  }

@@ -921,10 +931,14 @@ public final class EntityBeanIntercept implements Serializable {
   * OneToMany and ManyToMany only set loaded state.
   */
  public void preSetterMany(boolean interceptField, int propertyIndex, Object oldValue, Object newValue) {
-    if (readOnly) {
-      throw new IllegalStateException("This bean is readOnly");
+    if (state == STATE_NEW) {
+      setLoadedProperty(propertyIndex);
+    } else {
+      if (readOnly) {
+        throw new IllegalStateException("This bean is readOnly");
+      }
+      setChangedProperty(propertyIndex);
    }
-    setLoadedProperty(propertyIndex);
  }

  private void setChangedPropertyValue(int propertyIndex, boolean setDirtyState, Object origValue) {
@@ -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);
+    }
+  }
 }
--- a/Show More
+++ b/Show More