[maven-release-plugin] prepare release ebean-test-12.5.1

* Add failing test case for generic querybeans

Types with generics arguments have not been processed correctly, they
will lose their generics. This is not critical in Java, as the language
has to be backwards compatible with Java 1.4, but will still become
highlighted as a warning in all common IDEs.

In Kotlin however, it's not a warning but a compile error.

* Fix problem with generics in scalar type arg

This fixes the issue introduced with ScalarType aware querybeans.

.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,141 @@
+<?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.5.2-SNAPSHOT</version>
+  </parent>
+
+  <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.25</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.avaje</groupId>
+      <artifactId>avaje-config</artifactId>
+      <version>1.1</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.13</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-types</artifactId>
+      <version>2.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-datasource</artifactId>
+      <version>6.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-migration</artifactId>
+      <version>12.1.4</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

@@ -31,15 +31,18 @@ public interface BackgroundExecutor {
    * Execute a task periodically with a fixed delay between each execution.
    * <p>
    * For example, execute a runnable every minute.
-   * </p>
    * <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)}
-   * </p>
    */
   void executePeriodically(Runnable r, long delay, TimeUnit unit);
 
+  /**
+   * Execute a task periodically additionally with an initial delay different from delay.
+   */
+  void executePeriodically(Runnable r, long initialDelay, long delay, TimeUnit unit);
+
   /**
    * Schedules a Runnable for one-shot action that becomes enabled after the given delay.
    *

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

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

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

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

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.
@@ -72,7 +74,7 @@ public class DB {
    * Return the default database.
    */
   public static Database getDefault() {
-    return Ebean.getDefaultServer();
+    return context.getDefault();
   }
 
   /**
@@ -81,25 +83,24 @@ 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>
+   * Useful to run SQL scripts that are resources. For example a test script
+   * for inserting seed data for a particular test.
+   *
+   * <pre>{@code
+   *
+   *   DB.script().run("/scripts/test-script.sql")
+   *
+   * }</pre>
+   */
+  public static ScriptRunner script() {
+    return getDefault().script();
+  }
 
   /**
    * Return the ExpressionFactory from the default database.

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

@@ -1,5 +1,6 @@
 package io.ebean;
 
+import io.ebean.annotation.Platform;
 import io.ebean.annotation.TxIsolation;
 import io.ebean.cache.ServerCacheManager;
 import io.ebean.config.DatabaseConfig;
@@ -92,6 +93,11 @@ import java.util.concurrent.Callable;
  */
 public interface Database {
 
+  /**
+   * Shutdown the Database instance.
+   */
+  void shutdown();
+
   /**
    * Shutdown the Database instance programmatically.
    * <p>
@@ -132,6 +138,25 @@ public interface Database {
    */
   MetaInfoManager getMetaInfoManager();
 
+  /**
+   * Return the platform used for this database instance.
+   * <p>
+   * Note many platforms have multiple specific platform types so often we want to
+   * get the base platform via {@link Platform#base()}.
+   * </p>
+   * <pre>{@code
+   *
+   *  Platform platform = database.getPlatform().base();
+   *  if (platform == Platform.MYSQL) {
+   *    // do MySql specific function
+   *  }
+   *
+   * }</pre>
+   *
+   * @return platform for this database instance
+   */
+  Platform getPlatform();
+
   /**
    * Return the extended API intended for use by plugins.
    */
@@ -861,7 +886,7 @@ public interface Database {
    * <pre>{@code
    *   public class Order { ...
    *
-   *     @OneToMany(cascade=CascadeType.ALL, mappedBy="order")
+   *     ＠OneToMany(cascade=CascadeType.ALL, mappedBy="order")
    * 	   List<OrderDetail> details;
    * 	   ...
    *   }

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(false);
+  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(false);
+
+  /**
+   * 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(false);
   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,7 +1,7 @@
 package io.ebean;
 
-import io.ebeanservice.docstore.api.DocQueryRequest;
-import io.ebeanservice.docstore.api.RawDoc;
+import io.ebean.docstore.DocQueryContext;
+import io.ebean.docstore.RawDoc;
 import javax.annotation.Nullable;
 
 import java.io.IOException;
@@ -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.

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

@@ -2,29 +2,22 @@ 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;
 
 /**
- * Ebean will be Deprecated - please migrate to use DB.
+ * Deprecated - please migrate to use <code>io.ebean.DB</code>.
  * <p>
  * Ebean is a registry of {@link Database} by name. Ebean has now been renamed to {@link DB}.
  * <p>
@@ -32,124 +25,10 @@ import java.util.concurrent.ConcurrentHashMap;
  * <p>
  * The preference is to use DB and Database rather than Ebean and EbeanServer.
  */
+@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() {
   }
@@ -173,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);
   }
 
   /**
@@ -183,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();
   }
 
   /**
@@ -204,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();
   }
 
   /**
@@ -237,7 +119,7 @@ public final class Ebean {
    * </p>
    */
   public static Object nextId(Class<?> beanType) {
-    return serverMgr.getDefaultServer().nextId(beanType);
+    return getDefault().nextId(beanType);
   }
 
   /**
@@ -283,7 +165,7 @@ public final class Ebean {
    * </p>
    */
   public static Transaction beginTransaction() {
-    return serverMgr.getDefaultServer().beginTransaction();
+    return getDefault().beginTransaction();
   }
 
   /**
@@ -292,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);
   }
 
   /**
@@ -345,7 +227,7 @@ public final class Ebean {
    * }</pre>
    */
   public static Transaction beginTransaction(TxScope scope) {
-    return serverMgr.getDefaultServer().beginTransaction(scope);
+    return getDefault().beginTransaction(scope);
   }
 
   /**
@@ -353,7 +235,7 @@ public final class Ebean {
    * in scope.
    */
   public static Transaction currentTransaction() {
-    return serverMgr.getDefaultServer().currentTransaction();
+    return getDefault().currentTransaction();
   }
 
   /**
@@ -383,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();
   }
 
   /**
@@ -425,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();
   }
 
   /**
@@ -443,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);
   }
 
   /**
@@ -464,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;
    * 	   ...
    *   }
@@ -477,7 +359,7 @@ public final class Ebean {
    * </p>
    */
   public static void save(Object bean) throws OptimisticLockException {
-    serverMgr.getDefaultServer().save(bean);
+    getDefault().save(bean);
   }
 
   /**
@@ -485,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);
   }
 
   /**
@@ -515,7 +397,7 @@ public final class Ebean {
    * }</pre>
    */
   public static void markAsDirty(Object bean) throws OptimisticLockException {
-    serverMgr.getDefaultServer().markAsDirty(bean);
+    getDefault().markAsDirty(bean);
   }
 
   /**
@@ -530,16 +412,6 @@ public final class Ebean {
    * <b>Optimistic Locking: </b> Note that if the version property is not set when update() is
    * called then no optimistic locking is performed (internally ConcurrencyMode.NONE is used).
    * </p>
-   * <p>
-   * <b>{@link ServerConfig#setUpdatesDeleteMissingChildren(boolean)}: </b> When cascade saving to a
-   * OneToMany or ManyToMany the updatesDeleteMissingChildren setting controls if any other children
-   * that are in the database but are not in the collection are deleted.
-   * </p>
-   * <p>
-   * <b>{@link ServerConfig#setUpdateChangesOnly(boolean)}: </b> The updateChangesOnly setting
-   * controls if only the changed properties are included in the update or if all the loaded
-   * properties are included instead.
-   * </p>
    * <pre>{@code
    *
    *   // A 'stateless update' example
@@ -552,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);
   }
 
   /**
@@ -568,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);
   }
 
   /**
@@ -578,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);
   }
 
   /**
@@ -636,7 +508,7 @@ public final class Ebean {
    */
   @Nonnull
   public static Set<Property> checkUniqueness(Object bean) {
-    return serverMgr.getDefaultServer().checkUniqueness(bean);
+    return getDefault().checkUniqueness(bean);
   }
 
   /**
@@ -644,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);
   }
 
   /**
@@ -667,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);
   }
 
   /**
@@ -727,7 +599,7 @@ public final class Ebean {
    * </p>
    */
   public static void refresh(Object bean) {
-    serverMgr.getDefaultServer().refresh(bean);
+    getDefault().refresh(bean);
   }
 
   /**
@@ -745,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);
   }
 
   /**
@@ -770,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);
   }
 
   /**
@@ -813,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);
   }
 
   /**
@@ -863,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);
   }
 
   /**
@@ -878,7 +750,7 @@ public final class Ebean {
    */
   @Deprecated
   public static SqlQuery createSqlQuery(String sql) {
-    return serverMgr.getDefaultServer().sqlQuery(sql);
+    return getDefault().sqlQuery(sql);
   }
 
   /**
@@ -893,7 +765,7 @@ public final class Ebean {
    */
   @Deprecated
   public static SqlUpdate createSqlUpdate(String sql) {
-    return serverMgr.getDefaultServer().sqlUpdate(sql);
+    return getDefault().sqlUpdate(sql);
   }
 
   /**
@@ -902,7 +774,7 @@ public final class Ebean {
    * @see CallableSql
    */
   public static CallableSql createCallableSql(String sql) {
-    return serverMgr.getDefaultServer().createCallableSql(sql);
+    return getDefault().createCallableSql(sql);
   }
 
   /**
@@ -934,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);
   }
 
   /**
@@ -958,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);
   }
 
   /**
@@ -981,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);
   }
 
   /**
@@ -1019,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);
   }
 
   /**
@@ -1035,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);
   }
 
   /**
@@ -1059,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);
   }
 
   /**
@@ -1074,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);
   }
 
   /**
@@ -1096,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);
   }
 
   /**
@@ -1110,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);
   }
 
   /**
@@ -1153,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);
   }
 
   /**
@@ -1181,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);
   }
 
   /**
@@ -1205,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);
   }
 
   /**
@@ -1232,7 +1099,7 @@ public final class Ebean {
    * }</pre>
    */
   public static void execute(Runnable r) {
-    serverMgr.getDefaultServer().execute(r);
+    getDefault().execute(r);
   }
 
   /**
@@ -1257,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);
   }
 
   /**
@@ -1290,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);
   }
 
   /**
@@ -1324,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);
   }
 
   /**
@@ -1335,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();
   }
 
   /**
@@ -1350,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/EbeanServer.java

@@ -1,6 +1,7 @@
 package io.ebean;
 
 /**
+ * Deprecated - please migrate to <code>io.ebean.Database</code>.
  * Provides the API for fetching and saving beans to a particular Database.
  * <p>
  * Effectively this is an alias for {@link Database} which is now the new
@@ -8,6 +9,7 @@ package io.ebean;
  * <p>
  * The preference is to use DB and Database rather than Ebean and EbeanServer.
  */
+@Deprecated
 public interface EbeanServer extends Database {
 
 }

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

@@ -0,0 +1,77 @@
+package io.ebean;
+
+import io.ebean.config.ContainerConfig;
+import io.ebean.config.ServerConfig;
+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;
+
+/**
+ * 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/Expr.java

@@ -53,7 +53,7 @@ public class Expr {
   }
 
   /**
-   * In Range - property >= value1 and property < value2.
+   * In Range - {@code property >= value1 and property < value2}.
    * <p>
    * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
    * </p>

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

@@ -155,7 +155,7 @@ public interface ExpressionFactory {
   Expression ineObject(String propertyName, Object value);
 
   /**
-   * In Range - property >= value1 and property < value2.
+   * In Range - {@code property >= value1 and property < value2}.
    * <p>
    * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
    * </p>
@@ -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

@@ -70,30 +70,40 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> order(String orderByClause);
 
+  /**
+   * Set the order by clause replacing the existing order by clause if there is
+   * one.
+   * <p>
+   * This follows SQL syntax using commas between each property with the
+   * optional asc and desc keywords representing ascending and descending order
+   * respectively.
+   */
+  ExpressionList<T> orderBy(String orderBy);
+
   /**
    * Return the OrderBy so that you can append an ascending or descending
    * property to the order by clause.
    * <p>
    * This will never return a null. If no order by clause exists then an 'empty'
    * OrderBy object is returned.
-   * </p>
+   * <p>
+   * This is the same as <code>orderBy()</code>
    */
   OrderBy<T> order();
 
   /**
-   * Deprecated migrate to order().
+   * Return the OrderBy so that you can append an ascending or descending
+   * property to the order by clause.
+   * <p>
+   * This will never return a null. If no order by clause exists then an 'empty'
+   * OrderBy object is returned.
+   * <p>
+   * This is the same as <code>order()</code>
    */
-  @Deprecated
   OrderBy<T> orderBy();
 
   /**
-   * Deprecated migrate to {@link #order(String)}
-   */
-  @Deprecated
-  Query<T> orderBy(String orderBy);
-
-  /**
-   * Deprecated migrate to {@link #order(String)}
+   * Deprecated migrate to {@link #orderBy(String)}
    */
   @Deprecated
   Query<T> setOrderBy(String orderBy);
@@ -849,7 +859,7 @@ public interface ExpressionList<T> {
   ExpressionList<T> inRangeWith(String lowProperty, String highProperty, Object value);
 
   /**
-   * In Range - property >= value1 and property < value2.
+   * In Range - {@code property >= value1 and property < value2}.
    * <p>
    * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
    * </p>
@@ -876,6 +886,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.
@@ -892,6 +907,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.
    */
@@ -1241,26 +1261,35 @@ public interface ExpressionList<T> {
   /**
    * Add raw expression with a single parameter.
    * <p>
-   * The raw expression should contain a single ? at the location of the
-   * parameter.
-   * </p>
+   * The raw expression should contain a single ? or ?1
+   * at the location of the parameter.  We use ?1 when binding a
+   * collection for an IN expression.
    * <p>
    * When properties in the clause are fully qualified as table-column names
    * then they are not translated. logical property name names (not fully
    * qualified) will still be translated to their physical name.
-   * </p>
    * <p>
-   * <h4>Example:</h4>
+   * <h4>Examples:</h4>
    * <pre>{@code
    *
    *   // use a database function
    *   raw("add_days(orderDate, 10) < ?", someDate)
    *
+   *   raw("name like ?", "Rob%")
+   *
+   *   raw("name in (?1)", asList("Rob", "Fiona", "Jack"))
+   *
+   *   raw("name = any(?)", asList("Rob", "Fiona", "Jack"))
+   *
    * }</pre>
    *
-   * <h4>Subquery example:</h4>
+   * <h4>Subquery examples:</h4>
    * <pre>{@code
    *
+   *   // Bind collection using ?1
+   *   .raw("id in (select c.id from o_customer c where c.name in (?1))", asList("Rob", "Fiona", "Jack"))
+   *
+   *   // Using Postgres ANY expression
    *   .raw("t0.customer_id in (select customer_id from customer_group where group_id = any(?::uuid[]))", groupIds)
    *
    * }</pre>
@@ -1270,14 +1299,25 @@ public interface ExpressionList<T> {
   /**
    * Add raw expression with an array of parameters.
    * <p>
-   * The raw expression should contain the same number of ? as there are
-   * parameters.
-   * </p>
+   * The raw expression should contain the same number of ? or ?1, ?2 ... bind parameters
+   * as there are values. We use ?1, ?2 etc when binding a collection for an IN expression.
    * <p>
    * When properties in the clause are fully qualified as table-column names
    * then they are not translated. logical property name names (not fully
    * qualified) will still be translated to their physical name.
    * </p>
+   *
+   * <h4>Examples:</h4>
+   * <pre>{@code
+   *
+   *   raw("unitPrice > ? and product.id > ?", 2, 3)
+   *
+   *   raw("(status = ? or (orderDate < ? and shipDate is null) or customer.name like ?)",
+   *         Order.Status.APPROVED,
+   *         new Timestamp(System.currentTimeMillis()),
+   *         "Rob")
+   *
+   * }</pre></pre>
    */
   ExpressionList<T> raw(String raw, Object... values);
 

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

@@ -92,11 +92,9 @@ public interface ExtendedServer {
    * {@link #findEachWhile(Query, Predicate, Transaction)} is preferred
    * to findIterate(). The reason is that those methods automatically take care of
    * closing the queryIterator (and the underlying jdbc statement and resultSet).
-   * </p>
    * <p>
    * This is similar to findEach in that not all the result beans need to be held
    * in memory at the same time and as such is good for processing large queries.
-   * </p>
    *
    * @see Query#findIterate()
    * @see Query#findEach(Consumer)
@@ -106,7 +104,10 @@ public interface ExtendedServer {
   <T> QueryIterator<T> findIterate(Query<T> query, Transaction transaction);
 
   /**
-   * Return the query result as a Stream using a single persistence context.
+   * Execute the query returning the result as a Stream.
+   * <p>
+   * Note that this can support very large queries iterating any number of results.
+   * To do so internally it can use multiple persistence contexts.
    * <p>
    * Note that the stream needs to be closed so use with try with resources.
    * </p>
@@ -115,12 +116,17 @@ public interface ExtendedServer {
   <T> Stream<T> findStream(Query<T> query, Transaction transaction);
 
   /**
-   * Return the query result as a Stream (with multiple persistence contexts).
+   * Deprecated - migrate to findStream().
+   * <p>
+   * Execute the query returning the result as a Stream.
+   * <p>
+   * Note that this can support very large queries iterating any number of results.
+   * To do so internally it can use multiple persistence contexts.
    * <p>
    * Note that the stream needs to be closed so use with try with resources.
-   * </p>
    */
   @Nonnull
+  @Deprecated
   <T> Stream<T> findLargeStream(Query<T> query, Transaction transaction);
 
   /**

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

@@ -37,12 +37,13 @@ import java.util.List;
  *   }
  * }
  *
- * @Entity
+ * ＠Entity
  * public class Customer extends BaseModel {
  *
  *   public static final CustomerFinder find = new CustomerFinder();
  *   ...
  *
+ * }
  * }</pre>
  * <p>
  *  When the Finder is registered as a field on Customer it can then be used like:
@@ -79,12 +80,13 @@ 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();
    *   ...
    *
+   * }
    * }</pre>
    */
   public Finder(Class<T> type) {

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

@@ -32,19 +32,19 @@ import io.ebean.bean.EntityBean;
  *     // Typically there is a common base model that has some
  *     // common properties like the ones below
  *
- *     @MappedSuperclass
- *     public class BaseModel extends Model {
+ *   ＠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;
  *
+ *     ...
+ *   }
  * }</pre>
  * <p>
  * <h3>Extend the Model</h3>
@@ -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;

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

@@ -94,8 +94,8 @@ public interface PagedList<T> {
    * Return the Future row count. You might get this if you wish to cancel the total row count query
    * or specify a timeout for the row count query.
    * <p>
-   * The loadRowCount() & getTotalRowCount() methods internally make use of this getFutureRowCount() method.
-   * Generally I expect people to prefer loadRowCount() & getTotalRowCount() over getFutureRowCount().
+   * The loadRowCount() and getTotalRowCount() methods internally make use of this getFutureRowCount() method.
+   * Generally I expect people to prefer loadRowCount() and getTotalRowCount() over getFutureRowCount().
    * </p>
    * <pre>{@code
    *

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

@@ -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");

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

@@ -283,7 +283,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.
@@ -711,9 +711,9 @@ public interface Query<T> {
   /**
    * Execute the query returning the result as a Stream.
    * <p>
-   * Note that this will hold all resulting beans in memory using a single
-   * persistence context. Use findLargeStream() for queries that expect to
-   * return a large number of results.
+   * Note that this can support very large queries iterating
+   * any number of results. To do so internally it can use
+   * multiple persistence contexts.
    * </p>
    * <pre>{@code
    *
@@ -731,6 +731,8 @@ public interface Query<T> {
   Stream<T> findStream();
 
   /**
+   * Deprecated - migrate to findStream.
+   * <p>
    * Execute the query returning the result as a Stream.
    * <p>
    * Note that this uses multiple persistence contexts such that we can use
@@ -749,6 +751,7 @@ public interface Query<T> {
    * }</pre>
    */
   @Nonnull
+  @Deprecated
   Stream<T> findLargeStream();
 
   /**
@@ -1352,9 +1355,13 @@ public interface Query<T> {
   Query<T> having(Expression addExpressionToHaving);
 
   /**
-   * Deprecated migrate to {@link #order(String)}
+   * Set the order by clause replacing the existing order by clause if there is
+   * one.
+   * <p>
+   * This follows SQL syntax using commas between each property with the
+   * optional asc and desc keywords representing ascending and descending order
+   * respectively.
    */
-  @Deprecated
   Query<T> orderBy(String orderByClause);
 
   /**
@@ -1373,13 +1380,20 @@ public interface Query<T> {
    * <p>
    * This will never return a null. If no order by clause exists then an 'empty'
    * OrderBy object is returned.
+   * <p>
+   * This is the same as <code>orderBy()</code>
    */
   OrderBy<T> order();
 
   /**
-   * Deprecated migrate to order().
+   * Return the OrderBy so that you can append an ascending or descending
+   * property to the order by clause.
+   * <p>
+   * This will never return a null. If no order by clause exists then an 'empty'
+   * OrderBy object is returned.
+   * <p>
+   * This is the same as <code>order()</code>
    */
-  @Deprecated
   OrderBy<T> orderBy();
 
   /**
@@ -1388,9 +1402,8 @@ public interface Query<T> {
   Query<T> setOrder(OrderBy<T> orderBy);
 
   /**
-   * Deprecated migrate to {@link #setOrder(OrderBy)}
+   * Set an OrderBy object to replace any existing OrderBy clause.
    */
-  @Deprecated
   Query<T> setOrderBy(OrderBy<T> orderBy);
 
   /**

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

@@ -6,17 +6,13 @@ package io.ebean;
  * <p>
  * If you don't want to build object graphs you can use {@link SqlQuery} instead
  * which returns {@link SqlRow} objects rather than entity beans.
- * </p>
  * <p>
  * <b>Unparsed RawSql:</b>
- * </p>
  * <p>
  * When RawSql is created via {@link RawSqlBuilder#unparsed(String)} then Ebean can not
  * modify the SQL at all. It can't add any extra expressions into the SQL.
- * </p>
  * <p>
  * <b>Parsed RawSql:</b>
- * </p>
  * <p>
  * When RawSql is created via {@link RawSqlBuilder#parse(String)} then Ebean will parse the
  * SQL and find places in the SQL where it can add extra where expressions, add
@@ -24,16 +20,13 @@ package io.ebean;
  * explicitly tell Ebean where these insertion points are you can place special
  * strings into your SQL ({@code ${where}} or {@code ${andWhere}} and {@code ${having}} or
  * {@code ${andHaving})}.
- * </p>
  * <p>
  * If the SQL already includes a WHERE clause put in {@code ${andWhere}} in the location
  * you want Ebean to add any extra where expressions. If the SQL doesn't have a
  * WHERE clause put {@code ${where}} in instead. Similarly you can put in {@code ${having}} or
  * {@code ${andHaving}} where you want Ebean put add extra having expressions.
- * </p>
  * <p>
  * <b>Aggregates:</b>
- * </p>
  * <p>
  * Often RawSql will be used with Aggregate functions (sum, avg, max etc). The
  * follow example shows an example based on Total Order Amount -
@@ -44,38 +37,37 @@ package io.ebean;
  * on RawSql and not based on a real DB Table or DB View. It has some properties
  * to hold the values for the aggregate functions (sum etc) and a &#064;OneToOne
  * to Order.
- * </p>
  * <p>
  * <h3>Example OrderAggregate</h3>
  * <pre>{@code
  *  ...
- *  // @Sql indicates to that this bean
- *  // is based on RawSql rather than a table
+ *   // ＠Sql indicates to that this bean
+ *   // is based on RawSql rather than a table
  *
- * @Entity
- * @Sql
- * public class OrderAggregate {
+ *   ＠Entity
+ *   ＠Sql
+ *   public class OrderAggregate {
  *
- *  @OneToOne
- *  Order order;
+ *    ＠OneToOne
+ *    Order order;
  *
- *  Double totalAmount;
+ *    Double totalAmount;
  *
- *  Double totalItems;
- *
- *  // getters and setters
- *  ...
+ *    Double totalItems;
  *
+ *    // getters and setters
+ *    ...
+ *   }
  * }</pre>
- * <p>
+ *
  * <h3>Example 1:</h3>
- * <p>
+ *
  * <pre>{@code
  *
- *   String sql = " select order_id, o.status, c.id, c.name, sum(d.order_qty*d.unit_price) as totalAmount"
- *     + " from o_order o"
- *     + " join o_customer c on c.id = o.kcustomer_id "
- *     + " join o_order_detail d on d.order_id = o.id " + " group by order_id, o.status ";
+ *   String sql = " select order_id, o.status, c.id, c.name, sum(l.order_qty*l.unit_price) as totalAmount"
+ *     + " from order o"
+ *     + " join customer c on c.id = o.customer_id "
+ *     + " join order_line l on l.order_id = o.id " + " group by order_id, o.status ";
  *
  *   RawSql rawSql = RawSqlBuilder.parse(sql)
  *     // map the sql result columns to bean properties
@@ -95,18 +87,17 @@ package io.ebean;
  *
  *
  * }</pre>
- * <p>
+ *
  * <h3>Example 2:</h3>
  * <p>
  * The following example uses a FetchConfig().query() so that after the initial
  * RawSql query is executed Ebean executes a secondary query to fetch the
  * associated order status, orderDate along with the customer name.
- * </p>
- * <p>
+ *
  * <pre>{@code
  *
- *  String sql = " select order_id, 'ignoreMe', sum(d.order_qty*d.unit_price) as totalAmount "
- *     + " from o_order_detail d"
+ *  String sql = " select order_id, 'ignoreMe', sum(l.order_qty*l.unit_price) as totalAmount "
+ *     + " from order_line l"
  *     + " group by order_id ";
  *
  *   RawSql rawSql = RawSqlBuilder.parse(sql)
@@ -125,25 +116,23 @@ package io.ebean;
  *     .findList();
  *
  * }</pre>
- * <p>
  * <h3>Example 3: tableAliasMapping</h3>
  * <p>
  * Instead of mapping each column you can map each table alias to a path using tableAliasMapping().
- * </p>
  * <pre>{@code
  *
  *   String rs = "select o.id, o.status, c.id, c.name, "+
- *               " d.id, d.order_qty, p.id, p.name " +
- *               "from o_order o join o_customer c on c.id = o.kcustomer_id " +
- *               "join o_order_detail d on d.order_id = o.id  " +
- *               "join o_product p on p.id = d.product_id  " +
+ *               " l.id, l.order_qty, p.id, p.name " +
+ *               "from orders o join o_customer c on c.id = o.customer_id " +
+ *               "join order_line l on l.order_id = o.id  " +
+ *               "join product p on p.id = l.product_id  " +
  *               "where o.id <= :maxOrderId  and p.id = :productId "+
- *               "order by o.id, d.id asc";
+ *               "order by o.id, l.id asc";
  *
  *  RawSql rawSql = RawSqlBuilder.parse(rs)
  *       .tableAliasMapping("c", "customer")
- *       .tableAliasMapping("d", "details")
- *       .tableAliasMapping("p", "details.product")
+ *       .tableAliasMapping("l", "lines")
+ *       .tableAliasMapping("p", "lines.product")
  *       .create();
  *
  *  List<Order> ordersFromRaw = DB.find(Order.class)
@@ -154,9 +143,7 @@ package io.ebean;
  *
  * }</pre>
  * <p>
- * <p>
  * Note that lazy loading also works with object graphs built with RawSql.
- * </p>
  */
 public interface RawSql {
 

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

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

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

@@ -224,12 +224,49 @@ public interface SqlQuery extends Serializable {
    *
    * }</pre>
    *
+   * <p>
+   * When binding a collection of values into a IN expression we should use
+   * indexed parameters like ?1, ?2, ?3 etc rather than just ?.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *   String sql = "select c.id, c.name from customer c where c.name in (?1)";
+   *
+   *   List<SqlRow> rows = DB.sqlQuery(sql)
+   *       .setParameter(asList("Rob", "Fiona", "Jack"))
+   *       .findList();
+   *
+   *
+   *   List<SqlRow> rows = DB.sqlQuery(sql)
+   *       .setParameter(1, asList("Rob", "Fiona", "Jack"))
+   *       .findList();
+   * }</pre>
+   *
    * @param value The value to bind
    */
   SqlQuery setParameter(Object value);
 
   /**
    * Bind the parameter by its index position (1 based like JDBC).
+   * <p>
+   * When binding a collection of values into a IN expression we should use
+   * indexed parameters like ?1, ?2, ?3 etc rather than just ?.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *   String sql = "select c.id, c.name from customer c where c.name in (?1)";
+   *
+   *   List<SqlRow> rows = DB.sqlQuery(sql)
+   *       .setParameter(asList("Rob", "Fiona", "Jack"))
+   *       .findList();
+   *
+   *
+   *   List<SqlRow> rows = DB.sqlQuery(sql)
+   *       .setParameter(1, asList("Rob", "Fiona", "Jack"))
+   *       .findList();
+   * }</pre>
    */
   SqlQuery setParameter(int position, Object value);
 

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

@@ -5,18 +5,16 @@ package io.ebean;
  * <p>
  * Provides a simple way to execute raw SQL insert update or delete statements
  * without having to resort to JDBC.
- * </p>
  * <p>
  * Supports the use of positioned or named parameters and can automatically
  * notify Ebean of the table modified so that Ebean can maintain its cache.
- * </p>
  * <p>
  * Note that {@link #setAutoTableMod(boolean)} and
  * Ebean#externalModification(String, boolean, boolean, boolean)} can be to
  * notify Ebean of external changes and enable Ebean to maintain it's "L2"
  * server cache.
- * </p>
  *
+ * <h2>Positioned parameter example</h2>
  * <pre>{@code
  *
  *   // example using 'positioned' parameters
@@ -30,6 +28,7 @@ package io.ebean;
  *
  * }</pre>
  *
+ * <h2>Named parameter example</h2>
  * <pre>{@code
  *
  *   // example using 'named' parameters
@@ -45,8 +44,31 @@ package io.ebean;
  *   String msg = "There were " + rows + " rows updated";
  *
  * }</pre>
+ *
+ * <h2>Index parameter examples (e.g. ?1, ?2, ?3 ...)</h2>
  * <p>
- * <h3>Example: Using setNextParameter()</h3>
+ * We can use index parameters like ?1, ?2, ?3 etc when binding arrays/collections
+ * of values into an IN expression.
+ * </p>
+ * <pre>{@code
+ *
+ *   // Binding a list of 3 values (9991, 9992, 9993) into an IN expression
+ *
+ *   DB.sqlUpdate("delete from o_customer where name = ? and id in (?2)")
+ *     .setParameter(1, "Foo")
+ *     .setParameter(2, asList(9991, 9992, 9993))
+ *     .execute();
+ *
+ *   // note this effectively is the same as
+ *
+ *   DB.sqlUpdate("delete from o_customer where name = ? and id in (?2)")
+ *     .setParameter("Foo")
+ *     .setParameter(asList(9991, 9992, 9993))
+ *     .execute();
+ *
+ * }</pre>
+ *
+ * <h3>Example: Using setParameter()</h3>
  * <pre>{@code
  *
  *  String sql = "insert into audit_log (id, description, modified_description) values (?,?,?)";
@@ -56,19 +78,19 @@ package io.ebean;
  *  try (Transaction txn = DB.beginTransaction()) {
  *    txn.setBatchMode(true);
  *
- *    insert.setNextParameter(10000);
- *    insert.setNextParameter("hello");
- *    insert.setNextParameter("rob");
+ *    insert.setParameter(10000);
+ *    insert.setParameter("hello");
+ *    insert.setParameter("rob");
  *    insert.execute();
  *
- *    insert.setNextParameter(10001);
- *    insert.setNextParameter("goodbye");
- *    insert.setNextParameter("rob");
+ *    insert.setParameter(10001);
+ *    insert.setParameter("goodbye");
+ *    insert.setParameter("rob");
  *    insert.execute();
  *
- *    insert.setNextParameter(10002);
- *    insert.setNextParameter("chow");
- *    insert.setNextParameter("bob");
+ *    insert.setParameter(10002);
+ *    insert.setParameter("chow");
+ *    insert.setParameter("bob");
  *    insert.execute();
  *
  *    txn.commit();
@@ -81,19 +103,19 @@ package io.ebean;
  *
  *   try (Transaction txn = DB.beginTransaction()) {
  *
- *     insert.setNextParameter(10000);
- *     insert.setNextParameter("hello");
- *     insert.setNextParameter("rob");
+ *     insert.setParameter(10000);
+ *     insert.setParameter("hello");
+ *     insert.setParameter("rob");
  *     insert.addBatch();
  *
- *     insert.setNextParameter(10001);
- *     insert.setNextParameter("goodbye");
- *     insert.setNextParameter("rob");
+ *     insert.setParameter(10001);
+ *     insert.setParameter("goodbye");
+ *     insert.setParameter("rob");
  *     insert.addBatch();
  *
- *     insert.setNextParameter(10002);
- *     insert.setNextParameter("chow");
- *     insert.setNextParameter("bob");
+ *     insert.setParameter(10002);
+ *     insert.setParameter("chow");
+ *     insert.setParameter("bob");
  *     insert.addBatch();
  *
  *     int[] rows = insert.executeBatch();

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

@@ -3,7 +3,7 @@ package io.ebean;
 import io.ebean.annotation.DocStoreMode;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.config.DocStoreConfig;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.DatabaseConfig;
 
 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);
 
@@ -313,7 +313,7 @@ public interface Transaction extends AutoCloseable {
    * <h3>getGeneratedKeys</h3>
    * <p>
    * Often with large batch inserts we want to turn off getGeneratedKeys. We do
-   * this via {@link #setBatchGetGeneratedKeys(boolean)}.
+   * this via {@link #setGetGeneratedKeys(boolean)}.
    * Also note that some JDBC drivers do not support getGeneratedKeys in JDBC batch mode.
    * </p>
    * <pre>{@code
@@ -342,7 +342,7 @@ public interface Transaction extends AutoCloseable {
    * </p>
    * <p>
    * We use {@link #flush()} to explicitly flush the batch and we can use
-   * {@link #setBatchFlushOnQuery(boolean)} and {@link #setBatchFlushOnMixed(boolean)}
+   * {@link #setFlushOnQuery(boolean)} and {@link #setFlushOnMixed(boolean)}
    * to control the automatic flushing behaviour.
    * </p>
    * <p>
@@ -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);
 
@@ -432,7 +432,15 @@ public interface Transaction extends AutoCloseable {
    * number of objects and you don't care about getting back the ids.
    * </p>
    */
-  void setBatchGetGeneratedKeys(boolean getGeneratedKeys);
+  void setGetGeneratedKeys(boolean getGeneratedKeys);
+
+  /**
+   * Deprecated renamed to setGetGeneratedKeys().
+   */
+  @Deprecated
+  default void setBatchGetGeneratedKeys(boolean getGeneratedKeys) {
+    setGetGeneratedKeys(getGeneratedKeys);
+  }
 
   /**
    * By default when mixing UpdateSql (or CallableSql) with Beans the batch is
@@ -449,7 +457,15 @@ public interface Transaction extends AutoCloseable {
    * have a 2 step process (delayed binding).
    * </p>
    */
-  void setBatchFlushOnMixed(boolean batchFlushOnMixed);
+  void setFlushOnMixed(boolean batchFlushOnMixed);
+
+  /**
+   * Deprecated renamed to setFlushOnMixed().
+   */
+  @Deprecated
+  default void setBatchFlushOnMixed(boolean batchFlushOnMixed) {
+    setFlushOnMixed(batchFlushOnMixed);
+  }
 
   /**
    * By default executing a query will automatically flush any batched
@@ -459,7 +475,15 @@ public interface Transaction extends AutoCloseable {
    * execute a query and the batch will not be automatically flushed.
    * </p>
    */
-  void setBatchFlushOnQuery(boolean batchFlushOnQuery);
+  void setFlushOnQuery(boolean batchFlushOnQuery);
+
+  /**
+   * Deprecated renamed to setFlushOnQuery().
+   */
+  @Deprecated
+  default void setBatchFlushOnQuery(boolean batchFlushOnQuery) {
+    setFlushOnQuery(batchFlushOnQuery);
+  }
 
   /**
    * Return true if the batch (of persisted beans or executed UpdateSql etc)
@@ -468,7 +492,15 @@ public interface Transaction extends AutoCloseable {
    * The default is for this to be true.
    * </p>
    */
-  boolean isBatchFlushOnQuery();
+  boolean isFlushOnQuery();
+
+  /**
+   * Deprecated renamed to isFlushOnQuery().
+   */
+  @Deprecated
+  default boolean isBatchFlushOnQuery() {
+    return isFlushOnQuery();
+  }
 
   /**
    * The batch will be flushing automatically but you can use this to explicitly

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

@@ -12,26 +12,27 @@ package io.ebean;
  * The following is an example of named updates on an entity bean.
  * </p>
  * <pre>{@code
- *  ...
- * @NamedUpdates(value = {
- *   @NamedUpdate(
- *      name = "setTitle",
- *      notifyCache = false,
- *      update = "update topic set title = :title, postCount = :count where id = :id"),
- *  @NamedUpdate(
- *      name = "setPostCount",
- *      notifyCache = false,
- *      update = "update f_topic set post_count = :postCount where id = :id"),
- *  @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")
- * public class Topic {
- *  ...
+ *    ...
+ *   ＠NamedUpdates(value = {
+ *     ＠NamedUpdate(
+ *       name = "setTitle",
+ *       notifyCache = false,
+ *       update = "update topic set title = :title, postCount = :count where id = :id"),
+ *    ＠NamedUpdate(
+ *       name = "setPostCount",
+ *       notifyCache = false,
+ *       update = "update f_topic set post_count = :postCount where id = :id"),
+ *    ＠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")
+ *   public class Topic {
+ *     ...
+ *   }
  * }</pre>
  *
  * <p>

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(false);
+
   private transient NodeUsageCollector nodeUsageCollector;
 
   private transient PersistenceContext persistenceContext;
@@ -40,6 +44,8 @@ public final class EntityBeanIntercept implements Serializable {
 
   private String ebeanServerName;
 
+  private boolean deletedFromCollection;
+
   /**
    * The actual entity bean that 'owns' this intercept.
    */
@@ -80,14 +86,14 @@ public final class EntityBeanIntercept implements Serializable {
   private static final byte FLAG_CHANGED_PROP = 2;
 
   /**
-   * Flags indicating if a property is a dirty embedded bean. Used to distingush
+   * Flags indicating if a property is a dirty embedded bean. Used to distinguish
    * between an embedded bean being completely overwritten and one of its
    * embedded properties being made dirty.
    */
   private static final byte FLAG_EMBEDDED_DIRTY = 4;
 
   /**
-   * Flags indicating if a property is a dirty embedded bean. Used to distingush
+   * Flags indicating if a property is a dirty embedded bean. Used to distinguish
    * between an embedded bean being completely overwritten and one of its
    * embedded properties being made dirty.
    */
@@ -369,13 +375,11 @@ public final class EntityBeanIntercept implements Serializable {
   /**
    * Set the loaded state to true.
    * <p>
-   * Calls to setter methods after the bean is loaded can result in 'Old Values'
-   * being created to support ConcurrencyMode.ALL
-   * </p>
+   * Calls to setter methods after the bean is loaded can result in
+   * 'Old Values' being created.
    * <p>
    * Worth noting that this is also set after a insert/update. By doing so it
    * 'resets' the bean for making further changes and saving again.
-   * </p>
    */
   public void setLoaded() {
     this.state = STATE_LOADED;
@@ -389,8 +393,7 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * When finished loading for lazy or refresh on an already partially populated
-   * bean.
+   * When finished loading for lazy or refresh on an already partially populated bean.
    */
   public void setLoadedLazy() {
     this.state = STATE_LOADED;
@@ -421,9 +424,6 @@ public final class EntityBeanIntercept implements Serializable {
 
   /**
    * Set true to turn off lazy loading.
-   * <p>
-   * Typically used to disable lazy loading on SQL based report beans.
-   * </p>
    */
   public void setDisableLazyLoad(boolean disableLazyLoad) {
     this.disableLazyLoad = disableLazyLoad;
@@ -443,7 +443,6 @@ public final class EntityBeanIntercept implements Serializable {
    * Return true if the embedded bean is new or dirty and hence needs saving.
    */
   public boolean isEmbeddedNewOrDirty(Object embeddedBean) {
-
     if (embeddedBean == null) {
       // if it was previously set then the owning bean would
       // have oldValues containing the previous embedded bean
@@ -451,7 +450,6 @@ public final class EntityBeanIntercept implements Serializable {
     }
     if (embeddedBean instanceof EntityBean) {
       return ((EntityBean) embeddedBean)._ebean_getIntercept().isNewOrDirty();
-
     } else {
       // non-enhanced so must assume it is new and needs to be saved
       return true;
@@ -469,8 +467,8 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Finds the index position of a given property. Returns -1 if the property
-   * can not be found.
+   * Finds the index position of a given property. Returns -1 if the
+   * property can not be found.
    */
   public int findProperty(String propertyName) {
     String[] names = owner._ebean_getPropertyNames();
@@ -493,7 +491,7 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Return the number of properties.s
+   * Return the number of properties.
    */
   public int getPropertyLength() {
     return owner._ebean_getPropertyNames().length;
@@ -515,8 +513,7 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Set the property to be treated as unloaded. Used for properties initialised in default
-   * constructor.
+   * Set the property to be treated as unloaded. Used for properties initialised in default constructor.
    */
   public void setPropertyUnloaded(int propertyIndex) {
     flags[propertyIndex] &= ~FLAG_LOADED_PROP;
@@ -603,7 +600,6 @@ public final class EntityBeanIntercept implements Serializable {
    * For forced update on a 'New' bean set all the loaded properties to changed.
    */
   public void setNewBeanForUpdate() {
-
     for (int i = 0; i < flags.length; i++) {
       if ((flags[i] & FLAG_LOADED_PROP) != 0) {
         flags[i] |= FLAG_CHANGED_PROP;
@@ -658,8 +654,7 @@ public final class EntityBeanIntercept implements Serializable {
     for (int i = 0; i < len; i++) {
       if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
         // the property has been changed on this bean
-        String propName = (prefix == null ? getProperty(i) : prefix + getProperty(i));
-        props.add(propName);
+        props.add((prefix == null ? getProperty(i) : prefix + getProperty(i)));
       } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         // an embedded property has been changed - recurse
         EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
@@ -672,12 +667,10 @@ public final class EntityBeanIntercept implements Serializable {
    * Return true if any of the given property names are dirty.
    */
   public boolean hasDirtyProperty(Set<String> propertyNames) {
-
     String[] names = owner._ebean_getPropertyNames();
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
       if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
-        // the property has been changed on this bean
         if (propertyNames.contains(names[i])) {
           return true;
         }
@@ -710,10 +703,9 @@ public final class EntityBeanIntercept implements Serializable {
         String propName = (prefix == null ? getProperty(i) : prefix + getProperty(i));
         Object newVal = owner._ebean_getField(i);
         Object oldVal = getOrigValue(i);
-        if (!areEqual(oldVal, newVal)) {
+        if (notEqual(oldVal, newVal)) {
           dirtyValues.put(propName, new ValuePair(newVal, oldVal));
         }
-
       } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         // an embedded property has been changed - recurse
         EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
@@ -732,10 +724,9 @@ public final class EntityBeanIntercept implements Serializable {
         // the property has been changed on this bean
         Object newVal = owner._ebean_getField(i);
         Object oldVal = getOrigValue(i);
-        if (!areEqual(oldVal, newVal)) {
+        if (notEqual(oldVal, newVal)) {
           visitor.visit(i, newVal, oldVal);
         }
-
       } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         // an embedded property has been changed - recurse
         EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
@@ -756,7 +747,7 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Add and return a dirty property hash recursing into embedded beans.
+   * Add and return a dirty property hash.
    */
   private void addDirtyPropertyKey(StringBuilder sb) {
     if (sortOrder > 0) {
@@ -816,25 +807,28 @@ 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) {
           throw new PersistenceException("Database [" + ebeanServerName + "] was not found?");
         }
-
         // 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();
     }
   }
 
@@ -842,32 +836,24 @@ public final class EntityBeanIntercept implements Serializable {
    * Invoke the lazy loading. This method is synchronised externally.
    */
   private void loadBeanInternal(int loadProperty, BeanLoader loader) {
-
     if ((flags[loadProperty] & FLAG_LOADED_PROP) != 0) {
       // race condition where multiple threads calling preGetter concurrently
       return;
     }
-
     if (lazyLoadFailure) {
       // failed when batch lazy loaded by another bean in the batch
       throw new EntityNotFoundException("(Lazy) loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted");
     }
-
     if (lazyLoadProperty == -1) {
-
       lazyLoadProperty = loadProperty;
-
       if (nodeUsageCollector != null) {
         nodeUsageCollector.setLoadProperty(getProperty(lazyLoadProperty));
       }
-
       loader.loadBean(this);
-
       if (lazyLoadFailure) {
         // failed when lazy loading this bean
         throw new EntityNotFoundException("Lazy loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted.");
       }
-
       // bean should be loaded and intercepting now. setLoaded() has
       // been called by the lazy loading mechanism
     }
@@ -877,32 +863,31 @@ public final class EntityBeanIntercept implements Serializable {
    * Helper method to check if two objects are equal.
    */
   @SuppressWarnings({"unchecked", "rawtypes"})
-  protected boolean areEqual(Object obj1, Object obj2) {
+  protected static boolean notEqual(Object obj1, Object obj2) {
     if (obj1 == null) {
-      return (obj2 == null);
+      return (obj2 != null);
     }
     if (obj2 == null) {
-      return false;
+      return true;
     }
     if (obj1 == obj2) {
-      return true;
+      return false;
     }
     if (obj1 instanceof BigDecimal) {
       // Use comparable for BigDecimal as equals
       // uses scale in comparison...
       if (obj2 instanceof BigDecimal) {
         Comparable com1 = (Comparable) obj1;
-        return (com1.compareTo(obj2) == 0);
-
+        return (com1.compareTo(obj2) != 0);
       } else {
-        return false;
+        return true;
       }
     }
     if (obj1 instanceof URL) {
       // use the string format to determine if dirty
-      return obj1.toString().equals(obj2.toString());
+      return !obj1.toString().equals(obj2.toString());
     }
-    return obj1.equals(obj2);
+    return !obj1.equals(obj2);
   }
 
   /**
@@ -913,6 +898,7 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   private void preGetterCallback(int propertyIndex) {
+    PreGetterCallback preGetterCallback = this.preGetterCallback;
     if (preGetterCallback != null) {
       preGetterCallback.preGetterTrigger(propertyIndex);
     }
@@ -942,25 +928,20 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * OneToMany and ManyToMany don't have any interception so just check for
-   * PropertyChangeSupport.
+   * 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");
     }
-
     setLoadedProperty(propertyIndex);
   }
 
   private void setChangedPropertyValue(int propertyIndex, boolean setDirtyState, Object origValue) {
-
     if (readOnly) {
       throw new IllegalStateException("This bean is readOnly");
     }
     setChangedProperty(propertyIndex);
-
     if (setDirtyState) {
       setOriginalValue(propertyIndex, origValue);
       setDirtyStatus();
@@ -985,10 +966,9 @@ public final class EntityBeanIntercept implements Serializable {
    * the old values for use with ConcurrencyMode.ALL.
    */
   public void preSetter(boolean intercept, int propertyIndex, Object oldValue, Object newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
-    } else if (!areEqual(oldValue, newValue)) {
+    } else if (notEqual(oldValue, newValue)) {
       setChangedPropertyValue(propertyIndex, intercept, oldValue);
     }
   }
@@ -998,7 +978,6 @@ public final class EntityBeanIntercept implements Serializable {
    * Check for primitive boolean.
    */
   public void preSetter(boolean intercept, int propertyIndex, boolean oldValue, boolean newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (oldValue != newValue) {
@@ -1010,7 +989,6 @@ public final class EntityBeanIntercept implements Serializable {
    * Check for primitive int.
    */
   public void preSetter(boolean intercept, int propertyIndex, int oldValue, int newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (oldValue != newValue) {
@@ -1022,7 +1000,6 @@ public final class EntityBeanIntercept implements Serializable {
    * long.
    */
   public void preSetter(boolean intercept, int propertyIndex, long oldValue, long newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (oldValue != newValue) {
@@ -1034,7 +1011,6 @@ public final class EntityBeanIntercept implements Serializable {
    * double.
    */
   public void preSetter(boolean intercept, int propertyIndex, double oldValue, double newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (Double.compare(oldValue, newValue) != 0) {
@@ -1046,7 +1022,6 @@ public final class EntityBeanIntercept implements Serializable {
    * float.
    */
   public void preSetter(boolean intercept, int propertyIndex, float oldValue, float newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (Float.compare(oldValue, newValue) != 0) {
@@ -1058,7 +1033,6 @@ public final class EntityBeanIntercept implements Serializable {
    * short.
    */
   public void preSetter(boolean intercept, int propertyIndex, short oldValue, short newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (oldValue != newValue) {
@@ -1070,7 +1044,6 @@ public final class EntityBeanIntercept implements Serializable {
    * char.
    */
   public void preSetter(boolean intercept, int propertyIndex, char oldValue, char newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (oldValue != newValue) {
@@ -1082,7 +1055,6 @@ public final class EntityBeanIntercept implements Serializable {
    * byte.
    */
   public void preSetter(boolean intercept, int propertyIndex, byte oldValue, byte newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (oldValue != newValue) {
@@ -1094,7 +1066,6 @@ public final class EntityBeanIntercept implements Serializable {
    * char[].
    */
   public void preSetter(boolean intercept, int propertyIndex, char[] oldValue, char[] newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (!Arrays.equals(oldValue, newValue)) {
@@ -1106,7 +1077,6 @@ public final class EntityBeanIntercept implements Serializable {
    * byte[].
    */
   public void preSetter(boolean intercept, int propertyIndex, byte[] oldValue, byte[] newValue) {
-
     if (state == STATE_NEW) {
       setLoadedProperty(propertyIndex);
     } else if (!Arrays.equals(oldValue, newValue)) {
@@ -1137,6 +1107,17 @@ public final class EntityBeanIntercept implements Serializable {
     this.sortOrder = sortOrder;
   }
 
+  /**
+   * Set if the entity was deleted from a BeanCollection.
+   */
+  public void setDeletedFromCollection(final boolean deletedFromCollection) {
+    this.deletedFromCollection = deletedFromCollection;
+  }
+
+  public boolean isOrphanDelete() {
+    return deletedFromCollection && !isNew();
+  }
+
   /**
    * Set the load error that happened on this property.
    */

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

@@ -61,6 +61,22 @@ public interface PersistenceContext {
    */
   int size(Class<?> rootType);
 
+  /**
+   * Return a copy of the Persistence context to use for large query iteration.
+   */
+  PersistenceContext forIterate();
+
+  /**
+   * Return a new Persistence context during iteration of large query result.
+   */
+  PersistenceContext forIterateReset();
+
+  /**
+   * Return true if the persistence context has grown and hit the 'reset limit'
+   * during large query iteration.
+   */
+  boolean resetLimit();
+
   /**
    * Wrapper on a bean to also indicate if a bean has been deleted.
    * <p>

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