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

#2335 -  L2 cache be triggered by in ?

.github/ISSUE_TEMPLATE.md

@@ -1,9 +1,3 @@
-
-GITHUB ISSUES ARE STRICTLY CONTROLLED FOR THIS PROJECT.
-
-Refer to http://ebean-orm.github.io/support for the policies controlling the use of github issues.
-Please post issues to the Ebean group https://groups.google.com/forum/#!forum/ebean first.
-
 ## Expected behavior
 
 ## Actual behavior

ebean-api/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.9.2</version>
+    <version>12.11.3</version>
   </parent>
 
   <name>ebean api</name>
@@ -50,7 +50,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>7.0</version>
+      <version>7.2</version>
     </dependency>
 
     <dependency>

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

@@ -79,11 +79,11 @@ public abstract class BeanFinder<I,T> {
   /**
    * Creates an entity reference for this ID.
    * <p>
-   * Equivalent to {@link Database#getReference(Class, Object)}
+   * Equivalent to {@link Database#reference(Class, Object)}
    */
   @Nonnull
   public T ref(I id) {
-    return db().getReference(type, id);
+    return db().reference(type, id);
   }
 
   /**

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

@@ -118,4 +118,9 @@ public interface BeanState {
    */
   @Nullable
   Map<String, Exception> getLoadErrors();
+
+  /**
+   * Return the sort order value for an order column.
+   */
+  int getSortOrder();
 }

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

@@ -0,0 +1,19 @@
+package io.ebean;
+
+/**
+ * Defines a cancelable query.
+ * <p>
+ * Typically holds a representation of the PreparedStatement to perform the
+ * actual cancel.
+ * </p>
+ */
+public interface CancelableQuery {
+
+  /**
+   * Cancel the query.
+   * <p>
+   * For JDBC this translates to calling cancel on the PreparedStatement.
+   * </p>
+   */
+  void cancel();
+}

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

@@ -126,8 +126,16 @@ public final class DB {
    * an expression that uses OR like Expression e = Expr.or(..., ...);
    * </p>
    */
+  public static ExpressionFactory expressionFactory() {
+    return getDefault().expressionFactory();
+  }
+
+  /**
+   * Deprecated migrate to expressionFactory().
+   */
+  @Deprecated
   public static ExpressionFactory getExpressionFactory() {
-    return getDefault().getExpressionFactory();
+    return expressionFactory();
   }
 
   /**
@@ -650,8 +658,16 @@ public final class DB {
    * @param beanType the type of entity bean
    * @param id       the id value
    */
+  public static <T> T reference(Class<T> beanType, Object id) {
+    return getDefault().reference(beanType, id);
+  }
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
   public static <T> T getReference(Class<T> beanType, Object id) {
-    return getDefault().getReference(beanType, id);
+    return reference(beanType, id);
   }
 
   /**
@@ -660,14 +676,12 @@ public final class DB {
    * <ul>
    * <li>asc - ascending order (which is the default)</li>
    * <li>desc - Descending order</li>
-   * <li>nullsHigh - Treat null values as high/large values (which is the
-   * default)</li>
+   * <li>nullsHigh - Treat null values as high/large values (which is the default)</li>
    * <li>nullsLow- Treat null values as low/very small values</li>
    * </ul>
    * <p>
    * If you leave off any keywords the defaults are ascending order and treating
    * nulls as high values.
-   * </p>
    * <p>
    * Note that the sorting uses a Comparator and Collections.sort(); and does
    * not invoke a DB query.
@@ -1231,30 +1245,54 @@ public final class DB {
    * This will return null if the bean is not an enhanced entity bean.
    * </p>
    */
+  public static BeanState beanState(Object bean) {
+    return getDefault().beanState(bean);
+  }
+
+  /**
+   * Deprecated migrate to beanState().
+   */
+  @Deprecated
   public static BeanState getBeanState(Object bean) {
-    return getDefault().getBeanState(bean);
+    return beanState(bean);
   }
 
   /**
    * Return the value of the Id property for a given bean.
    */
+  public static Object beanId(Object bean) {
+    return getDefault().beanId(bean);
+  }
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
   public static Object getBeanId(Object bean) {
-    return getDefault().getBeanId(bean);
+    return beanId(bean);
   }
 
   /**
    * Return the manager of the level 2 cache ("L2" cache).
    */
   public static ServerCacheManager getServerCacheManager() {
-    return getDefault().getServerCacheManager();
+    return getDefault().cacheManager();
   }
 
   /**
    * Return the BackgroundExecutor service for asynchronous processing of
    * queries.
    */
+  public static BackgroundExecutor backgroundExecutor() {
+    return getDefault().backgroundExecutor();
+  }
+
+  /**
+   * Deprecated migrate to backgroundExecutor().
+   */
+  @Deprecated
   public static BackgroundExecutor getBackgroundExecutor() {
-    return getDefault().getBackgroundExecutor();
+    return backgroundExecutor();
   }
 
   /**

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

@@ -120,34 +120,82 @@ public interface Database {
   /**
    * Return AutoTune which is used to control the AutoTune service at runtime.
    */
-  AutoTune getAutoTune();
+  AutoTune autoTune();
+
+  /**
+   * Deprecated migrate to autoTune().
+   */
+  @Deprecated
+  default AutoTune getAutoTune() {
+    return autoTune();
+  }
 
   /**
    * Return the associated DataSource for this Database instance.
    */
-  DataSource getDataSource();
+  DataSource dataSource();
+
+  /**
+   * Deprecated migrate to dataSource().
+   */
+  @Deprecated
+  default DataSource getDataSource() {
+    return dataSource();
+  }
 
   /**
    * Return the associated read only DataSource for this Database instance (can be null).
    */
-  DataSource getReadOnlyDataSource();
+  DataSource readOnlyDataSource();
+
+  /**
+   * Deprecated migrate to readOnlyDataSource().
+   */
+  @Deprecated
+  default DataSource getReadOnlyDataSource() {
+    return readOnlyDataSource();
+  }
 
   /**
    * Return the name. This is used with {@link DB#byName(String)} to get a
    * Database that was registered with the DB singleton.
    */
-  String getName();
+  String name();
+
+  /**
+   * Deprecated migrate to name().
+   */
+  @Deprecated
+  default String getName() {
+    return name();
+  }
 
   /**
    * Return the ExpressionFactory for this database.
    */
-  ExpressionFactory getExpressionFactory();
+  ExpressionFactory expressionFactory();
+
+  /**
+   * Deprecated migrate to expressionFactory().
+   */
+  @Deprecated
+  default ExpressionFactory getExpressionFactory() {
+    return expressionFactory();
+  }
 
   /**
    * Return the MetaInfoManager which is used to get meta data from the Database
    * such as query execution statistics.
    */
-  MetaInfoManager getMetaInfoManager();
+  MetaInfoManager metaInfo();
+
+  /**
+   * Deprecated migrate to metaInfo().
+   */
+  @Deprecated
+  default MetaInfoManager getMetaInfoManager() {
+    return metaInfo();
+  }
 
   /**
    * Return the platform used for this database instance.
@@ -166,12 +214,28 @@ public interface Database {
    *
    * @return platform for this database instance
    */
-  Platform getPlatform();
+  Platform platform();
+
+  /**
+   * Deprecated migrate to platform().
+   */
+  @Deprecated
+  default Platform getPlatform() {
+    return platform();
+  }
 
   /**
    * Return the extended API intended for use by plugins.
    */
-  SpiServer getPluginApi();
+  SpiServer pluginApi();
+
+  /**
+   * Deprecated migrate to pluginApi().
+   */
+  @Deprecated
+  default SpiServer getPluginApi() {
+    return pluginApi();
+  }
 
   /**
    * Return the BeanState for a given entity bean.
@@ -179,12 +243,28 @@ public interface Database {
    * This will return null if the bean is not an enhanced entity bean.
    * </p>
    */
-  BeanState getBeanState(Object bean);
+  BeanState beanState(Object bean);
+
+  /**
+   * Deprecated migrate to beanState().
+   */
+  @Deprecated
+  default BeanState getBeanState(Object bean) {
+    return beanState(bean);
+  }
 
   /**
    * Return the value of the Id property for a given bean.
    */
-  Object getBeanId(Object bean);
+  Object beanId(Object bean);
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
+  default Object getBeanId(Object bean) {
+    return beanId(bean);
+  }
 
   /**
    * Set the Id value onto the bean converting the type of the id value if necessary.
@@ -196,7 +276,15 @@ public interface Database {
    * @param bean The entity bean to set the id value on.
    * @param id   The id value to set.
    */
-  Object setBeanId(Object bean, Object id);
+  Object beanId(Object bean, Object id);
+
+  /**
+   * Deprecated migrate to beanId().
+   */
+  @Deprecated
+  default Object setBeanId(Object bean, Object id) {
+    return beanId(bean, id);
+  }
 
   /**
    * Return a map of the differences between two objects of the same type.
@@ -862,7 +950,15 @@ public interface Database {
    * @param id       the id value
    */
   @Nonnull
-  <T> T getReference(Class<T> beanType, Object id);
+  <T> T reference(Class<T> beanType, Object id);
+
+  /**
+   * Deprecated migrate to reference().
+   */
+  @Deprecated
+  default <T> T getReference(Class<T> beanType, Object id) {
+    return reference(beanType, id);
+  }
 
   /**
    * Return the extended API for Database.
@@ -1431,13 +1527,29 @@ public interface Database {
   /**
    * Return the manager of the server cache ("L2" cache).
    */
-  ServerCacheManager getServerCacheManager();
+  ServerCacheManager cacheManager();
+
+  /**
+   * Deprecated migrate to cacheManager().
+   */
+  @Deprecated
+  default ServerCacheManager getServerCacheManager() {
+    return cacheManager();
+  }
 
   /**
    * Return the BackgroundExecutor service for asynchronous processing of
    * queries.
    */
-  BackgroundExecutor getBackgroundExecutor();
+  BackgroundExecutor backgroundExecutor();
+
+  /**
+   * Deprecated migrate to backgroundExecutor().
+   */
+  @Deprecated
+  default BackgroundExecutor getBackgroundExecutor() {
+    return backgroundExecutor();
+  }
 
   /**
    * Return the JsonContext for reading/writing JSON.

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

@@ -16,18 +16,15 @@ import java.util.concurrent.locks.ReentrantLock;
  * <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 {
 
@@ -48,7 +45,7 @@ public class DatabaseFactory {
   public static void initialiseContainer(ContainerConfig containerConfig) {
     lock.lock();
     try {
-      getContainer(containerConfig);
+      container(containerConfig);
     } finally {
       lock.unlock();
     }
@@ -60,7 +57,7 @@ public class DatabaseFactory {
   public static Database create(String name) {
     lock.lock();
     try {
-      return getContainer(null).createServer(name);
+      return container(null).createServer(name);
     } finally {
       lock.unlock();
     }
@@ -68,6 +65,16 @@ public class DatabaseFactory {
 
   /**
    * Create using the DatabaseConfig object to configure the database.
+   *
+   * <pre>{@code
+   *
+   *   DatabaseConfig config = new DatabaseConfig();
+   *   config.setName("db");
+   *   config.loadProperties();
+   *
+   *   Database database = DatabaseFactory.create(config);
+   *
+   * }</pre>
    */
   public static Database create(DatabaseConfig config) {
     lock.lock();
@@ -115,7 +122,6 @@ public class DatabaseFactory {
    * 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();
@@ -127,15 +133,15 @@ public class DatabaseFactory {
   }
 
   private static Database createInternal(DatabaseConfig config) {
-    return getContainer(config.getContainerConfig()).createServer(config);
+    return container(config.getContainerConfig()).createServer(config);
   }
 
   /**
-   * Get the EbeanContainer initialising it if necessary.
+   * Return the SpiContainer initialising it if necessary.
    *
    * @param containerConfig the configuration controlling clustering communication
    */
-  private static SpiContainer getContainer(ContainerConfig containerConfig) {
+  private static SpiContainer container(ContainerConfig containerConfig) {
     // thread safe in that all calling methods hold lock
     if (container != null) {
       return container;

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

@@ -115,7 +115,7 @@ final class DbContext {
    * Register a server so we can get it by its name.
    */
   void register(Database server, boolean isDefault) {
-    registerWithName(server.getName(), server, isDefault);
+    registerWithName(server.name(), server, isDefault);
   }
 
   private void registerWithName(String name, Database server, boolean isDefault) {

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

@@ -38,7 +38,7 @@ import java.util.stream.Stream;
  *
  * }</pre>
  */
-public interface DtoQuery<T> {
+public interface DtoQuery<T> extends CancelableQuery {
 
   /**
    * Execute the query returning a list.

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

@@ -103,7 +103,7 @@ public final class Ebean {
    * </p>
    */
   public static ExpressionFactory getExpressionFactory() {
-    return getDefault().getExpressionFactory();
+    return getDefault().expressionFactory();
   }
 
   /**
@@ -642,7 +642,7 @@ public final class Ebean {
    * @param id       the id value
    */
   public static <T> T getReference(Class<T> beanType, Object id) {
-    return getDefault().getReference(beanType, id);
+    return getDefault().reference(beanType, id);
   }
 
   /**
@@ -1201,14 +1201,14 @@ public final class Ebean {
    * </p>
    */
   public static BeanState getBeanState(Object bean) {
-    return getDefault().getBeanState(bean);
+    return getDefault().beanState(bean);
   }
 
   /**
    * Return the manager of the server cache ("L2" cache).
    */
   public static ServerCacheManager getServerCacheManager() {
-    return getDefault().getServerCacheManager();
+    return getDefault().cacheManager();
   }
 
   /**
@@ -1216,7 +1216,7 @@ public final class Ebean {
    * queries.
    */
   public static BackgroundExecutor getBackgroundExecutor() {
-    return getDefault().getBackgroundExecutor();
+    return getDefault().backgroundExecutor();
   }
 
   /**

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

@@ -16,7 +16,7 @@ import java.util.Map;
  * This provides a convenient way to create expressions for the default
  * database.
  * <p>
- * See also {@link DB#getExpressionFactory()}
+ * See also {@link DB#expressionFactory()}
  * </p>
  * <p>
  * Creates standard common expressions for using in a Query Where or Having
@@ -34,14 +34,14 @@ public class Expr {
    * Equal To - property equal to the given value.
    */
   public static Expression eq(String propertyName, Object value) {
-    return DB.getExpressionFactory().eq(propertyName, value);
+    return DB.expressionFactory().eq(propertyName, value);
   }
 
   /**
    * Not Equal To - property not equal to the given value.
    */
   public static Expression ne(String propertyName, Object value) {
-    return DB.getExpressionFactory().ne(propertyName, value);
+    return DB.expressionFactory().ne(propertyName, value);
   }
 
   /**
@@ -49,7 +49,7 @@ public class Expr {
    * using a lower() function to make it case insensitive).
    */
   public static Expression ieq(String propertyName, String value) {
-    return DB.getExpressionFactory().ieq(propertyName, value);
+    return DB.expressionFactory().ieq(propertyName, value);
   }
 
   /**
@@ -59,28 +59,28 @@ public class Expr {
    * </p>
    */
   public static Expression inRange(String propertyName, Object value1, Object value2) {
-    return DB.getExpressionFactory().inRange(propertyName, value1, value2);
+    return DB.expressionFactory().inRange(propertyName, value1, value2);
   }
 
   /**
    * Between - property between the two given values.
    */
   public static Expression between(String propertyName, Object value1, Object value2) {
-    return DB.getExpressionFactory().between(propertyName, value1, value2);
+    return DB.expressionFactory().between(propertyName, value1, value2);
   }
 
   /**
    * Between - value between two given properties.
    */
   public static Expression between(String lowProperty, String highProperty, Object value) {
-    return DB.getExpressionFactory().betweenProperties(lowProperty, highProperty, value);
+    return DB.expressionFactory().betweenProperties(lowProperty, highProperty, value);
   }
 
   /**
    * Greater Than - property greater than the given value.
    */
   public static Expression gt(String propertyName, Object value) {
-    return DB.getExpressionFactory().gt(propertyName, value);
+    return DB.expressionFactory().gt(propertyName, value);
   }
 
   /**
@@ -88,42 +88,42 @@ public class Expr {
    * value.
    */
   public static Expression ge(String propertyName, Object value) {
-    return DB.getExpressionFactory().ge(propertyName, value);
+    return DB.expressionFactory().ge(propertyName, value);
   }
 
   /**
    * Less Than - property less than the given value.
    */
   public static Expression lt(String propertyName, Object value) {
-    return DB.getExpressionFactory().lt(propertyName, value);
+    return DB.expressionFactory().lt(propertyName, value);
   }
 
   /**
    * Less Than or Equal to - property less than or equal to the given value.
    */
   public static Expression le(String propertyName, Object value) {
-    return DB.getExpressionFactory().le(propertyName, value);
+    return DB.expressionFactory().le(propertyName, value);
   }
 
   /**
    * Is Null - property is null.
    */
   public static Expression isNull(String propertyName) {
-    return DB.getExpressionFactory().isNull(propertyName);
+    return DB.expressionFactory().isNull(propertyName);
   }
 
   /**
    * Is Not Null - property is not null.
    */
   public static Expression isNotNull(String propertyName) {
-    return DB.getExpressionFactory().isNotNull(propertyName);
+    return DB.expressionFactory().isNotNull(propertyName);
   }
 
   /**
    * Case insensitive {@link #exampleLike(Object)}
    */
   public static ExampleExpression iexampleLike(Object example) {
-    return DB.getExpressionFactory().iexampleLike(example);
+    return DB.expressionFactory().iexampleLike(example);
   }
 
   /**
@@ -131,14 +131,14 @@ public class Expr {
    * LikeType.RAW (you need to add you own wildcards % and _).
    */
   public static ExampleExpression exampleLike(Object example) {
-    return DB.getExpressionFactory().exampleLike(example);
+    return DB.expressionFactory().exampleLike(example);
   }
 
   /**
    * Create the query by Example expression specifying more options.
    */
   public static ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType) {
-    return DB.getExpressionFactory().exampleLike(example, caseInsensitive, likeType);
+    return DB.expressionFactory().exampleLike(example, caseInsensitive, likeType);
   }
 
   /**
@@ -146,7 +146,7 @@ public class Expr {
    * characters % (percentage) and _ (underscore).
    */
   public static Expression like(String propertyName, String value) {
-    return DB.getExpressionFactory().like(propertyName, value);
+    return DB.expressionFactory().like(propertyName, value);
   }
 
   /**
@@ -155,14 +155,14 @@ public class Expr {
    * a lower() function to make the expression case insensitive.
    */
   public static Expression ilike(String propertyName, String value) {
-    return DB.getExpressionFactory().ilike(propertyName, value);
+    return DB.expressionFactory().ilike(propertyName, value);
   }
 
   /**
    * Starts With - property like value%.
    */
   public static Expression startsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().startsWith(propertyName, value);
+    return DB.expressionFactory().startsWith(propertyName, value);
   }
 
   /**
@@ -170,14 +170,14 @@ public class Expr {
    * lower() function to make the expression case insensitive.
    */
   public static Expression istartsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().istartsWith(propertyName, value);
+    return DB.expressionFactory().istartsWith(propertyName, value);
   }
 
   /**
    * Ends With - property like %value.
    */
   public static Expression endsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().endsWith(propertyName, value);
+    return DB.expressionFactory().endsWith(propertyName, value);
   }
 
   /**
@@ -185,14 +185,14 @@ public class Expr {
    * function to make the expression case insensitive.
    */
   public static Expression iendsWith(String propertyName, String value) {
-    return DB.getExpressionFactory().iendsWith(propertyName, value);
+    return DB.expressionFactory().iendsWith(propertyName, value);
   }
 
   /**
    * Contains - property like %value%.
    */
   public static Expression contains(String propertyName, String value) {
-    return DB.getExpressionFactory().contains(propertyName, value);
+    return DB.expressionFactory().contains(propertyName, value);
   }
 
   /**
@@ -200,42 +200,42 @@ public class Expr {
    * function to make the expression case insensitive.
    */
   public static Expression icontains(String propertyName, String value) {
-    return DB.getExpressionFactory().icontains(propertyName, value);
+    return DB.expressionFactory().icontains(propertyName, value);
   }
 
   /**
    * For collection properties that are empty (have not existing elements).
    */
   public static Expression isEmpty(String propertyName) {
-    return DB.getExpressionFactory().isEmpty(propertyName);
+    return DB.expressionFactory().isEmpty(propertyName);
   }
 
   /**
    * For collection properties that are not empty (have existing elements).
    */
   public static Expression isNotEmpty(String propertyName) {
-    return DB.getExpressionFactory().isNotEmpty(propertyName);
+    return DB.expressionFactory().isNotEmpty(propertyName);
   }
 
   /**
    * In - property has a value in the array of values.
    */
   public static Expression in(String propertyName, Object[] values) {
-    return DB.getExpressionFactory().in(propertyName, values);
+    return DB.expressionFactory().in(propertyName, values);
   }
 
   /**
    * In - using a subQuery.
    */
   public static Expression in(String propertyName, Query<?> subQuery) {
-    return DB.getExpressionFactory().in(propertyName, subQuery);
+    return DB.expressionFactory().in(propertyName, subQuery);
   }
 
   /**
    * In - property has a value in the collection of values.
    */
   public static Expression in(String propertyName, Collection<?> values) {
-    return DB.getExpressionFactory().in(propertyName, values);
+    return DB.expressionFactory().in(propertyName, values);
   }
 
   /**
@@ -272,14 +272,14 @@ public class Expr {
    * }</pre>
    */
   public static Expression inOrEmpty(String propertyName, Collection<?> values) {
-    return DB.getExpressionFactory().inOrEmpty(propertyName, values);
+    return DB.expressionFactory().inOrEmpty(propertyName, values);
   }
 
   /**
    * Id Equal to - ID property is equal to the value.
    */
   public static Expression idEq(Object value) {
-    return DB.getExpressionFactory().idEq(value);
+    return DB.expressionFactory().idEq(value);
   }
 
   /**
@@ -292,7 +292,7 @@ public class Expr {
    * @param propertyMap a map keyed by property names.
    */
   public static Expression allEq(Map<String, Object> propertyMap) {
-    return DB.getExpressionFactory().allEq(propertyMap);
+    return DB.expressionFactory().allEq(propertyMap);
   }
 
   /**
@@ -303,7 +303,7 @@ public class Expr {
    * </p>
    */
   public static Expression raw(String raw, Object value) {
-    return DB.getExpressionFactory().raw(raw, value);
+    return DB.expressionFactory().raw(raw, value);
   }
 
   /**
@@ -314,53 +314,48 @@ public class Expr {
    * </p>
    */
   public static Expression raw(String raw, Object[] values) {
-    return DB.getExpressionFactory().raw(raw, values);
+    return DB.expressionFactory().raw(raw, values);
   }
 
   /**
    * Add raw expression with no parameters.
    */
   public static Expression raw(String raw) {
-    return DB.getExpressionFactory().raw(raw);
+    return DB.expressionFactory().raw(raw);
   }
 
   /**
    * And - join two expressions with a logical and.
    */
   public static Expression and(Expression expOne, Expression expTwo) {
-
-    return DB.getExpressionFactory().and(expOne, expTwo);
+    return DB.expressionFactory().and(expOne, expTwo);
   }
 
   /**
    * Or - join two expressions with a logical or.
    */
   public static Expression or(Expression expOne, Expression expTwo) {
-
-    return DB.getExpressionFactory().or(expOne, expTwo);
+    return DB.expressionFactory().or(expOne, expTwo);
   }
 
   /**
    * Negate the expression (prefix it with NOT).
    */
   public static Expression not(Expression exp) {
-
-    return DB.getExpressionFactory().not(exp);
+    return DB.expressionFactory().not(exp);
   }
 
   /**
    * Return a list of expressions that will be joined by AND's.
    */
   public static <T> Junction<T> conjunction(Query<T> query) {
-
-    return DB.getExpressionFactory().conjunction(query);
+    return DB.expressionFactory().conjunction(query);
   }
 
   /**
    * Return a list of expressions that will be joined by OR's.
    */
   public static <T> Junction<T> disjunction(Query<T> query) {
-
-    return DB.getExpressionFactory().disjunction(query);
+    return DB.expressionFactory().disjunction(query);
   }
 }

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

@@ -67,7 +67,7 @@ public interface ExtendedServer {
    *
    * @return True if the query finds a matching row in the database
    */
-  <T> boolean exists(Query<?> ormQuery, Transaction transaction);
+  <T> boolean exists(Query<T> ormQuery, Transaction transaction);
 
   /**
    * Return the number of 'top level' or 'root' entities this query should return.

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

@@ -137,11 +137,11 @@ public class Finder<I, T> {
   /**
    * Creates an entity reference for this ID.
    * <p>
-   * Equivalent to {@link Database#getReference(Class, Object)}
+   * Equivalent to {@link Database#reference(Class, Object)}
    */
   @Nonnull
   public T ref(I id) {
-    return db().getReference(type, id);
+    return db().reference(type, id);
   }
 
   /**

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

@@ -177,7 +177,7 @@ import java.util.stream.Stream;
  *
  * @param <T> the type of Entity bean this query will fetch.
  */
-public interface Query<T> {
+public interface Query<T> extends CancelableQuery {
 
   /**
    * The lock type (strength) to use with query FOR UPDATE row locking.
@@ -291,15 +291,6 @@ public interface Query<T> {
    */
   UpdateQuery<T> asUpdate();
 
-  /**
-   * Cancel the query execution if supported by the underlying database and
-   * driver.
-   * <p>
-   * This must be called from a different thread to the query executor.
-   * </p>
-   */
-  void cancel();
-
   /**
    * Return a copy of the query.
    * <p>

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

@@ -70,12 +70,6 @@ public interface QueryIterator<T> extends Iterator<T>, AutoCloseable {
   @Override
   T next();
 
-  /**
-   * Remove is not allowed.
-   */
-  @Override
-  void remove();
-
   /**
    * Close the underlying resources held by this iterator.
    */

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

@@ -37,7 +37,7 @@ import java.util.function.Predicate;
  *
  * }</pre>
  */
-public interface SqlQuery extends Serializable {
+public interface SqlQuery extends Serializable, CancelableQuery {
 
   /**
    * Execute the query returning a list.

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

@@ -13,12 +13,10 @@ import java.util.Set;
  * from the Map Set or List. The purpose of gathering the additions and removals
  * is to support persisting ManyToMany objects. The additions and removals
  * become inserts and deletes from the intersection table.
- * </p>
  * <p>
  * Technically this is <em>NOT</em> an extension of
  * <em>java.util.Collection</em>. The reason being that java.util.Map is not a
  * Collection. I realise this makes this name confusing so I apologise for that.
- * </p>
  */
 public interface BeanCollection<E> extends Serializable {
 
@@ -68,7 +66,6 @@ public interface BeanCollection<E> extends Serializable {
    * Return true if the collection is uninitialised or is empty without any held modifications.
    * <p>
    * Returning true means can safely skip cascade save for this bean collection.
-   * </p>
    */
   boolean isSkipSave();
 
@@ -93,7 +90,6 @@ public interface BeanCollection<E> extends Serializable {
    * <p>
    * That is, if the collection was not loaded due to filterMany predicates etc
    * then make sure the collection is set to empty.
-   * </p>
    */
   boolean checkEmptyLazyLoad();
 
@@ -136,10 +132,7 @@ public interface BeanCollection<E> extends Serializable {
   boolean isReadOnly();
 
   /**
-   * Add the bean to the collection.
-   * <p>
-   * This is disallowed for BeanMap.
-   * </p>
+   * Add the bean to the collection. This is disallowed for BeanMap.
    */
   void internalAdd(Object bean);
 
@@ -168,7 +161,6 @@ public interface BeanCollection<E> extends Serializable {
    * Map.Entry.
    * <p>
    * For maps this returns the entrySet as we need the keys of the map.
-   * </p>
    */
   Collection<?> getActualEntries();
 
@@ -185,6 +177,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   boolean isReference();
 
+  /**
+   * Return true if the collection is modify listening and has modifications.
+   */
+  boolean hasModifications();
+
   /**
    * Set modify listening on or off. This is used to keep track of objects that
    * have been added to or removed from the list set or map.
@@ -192,7 +189,6 @@ public interface BeanCollection<E> extends Serializable {
    * This is required only for ManyToMany collections. The additions and
    * deletions are used to insert or delete entries from the intersection table.
    * Otherwise modifyListening is false.
-   * </p>
    */
   void setModifyListening(ModifyListenMode modifyListenMode);
 
@@ -206,7 +202,6 @@ public interface BeanCollection<E> extends Serializable {
    * <p>
    * This will potentially end up as an insert into a intersection table for a
    * ManyToMany.
-   * </p>
    */
   void modifyAddition(E bean);
 
@@ -215,7 +210,6 @@ public interface BeanCollection<E> extends Serializable {
    * <p>
    * This will potentially end up as an delete from an intersection table for a
    * ManyToMany.
-   * </p>
    */
   void modifyRemoval(Object bean);
 

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

@@ -11,7 +11,7 @@ public interface BeanCollectionLoader {
   /**
    * Return the name of the associated Database.
    */
-  String getName();
+  String name();
 
   /**
    * Invoke the lazy loading for this bean collection.

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

@@ -27,17 +27,6 @@ public interface EntityBean extends Serializable {
     throw new NotEnhancedException();
   }
 
-  /**
-   * Return the enhancement marker value.
-   * <p>
-   * This is the class name of the enhanced class and used to check that all
-   * entity classes are enhanced (specifically not just a super class).
-   * </p>
-   */
-  default String _ebean_getMarker() {
-    throw new NotEnhancedException();
-  }
-
   /**
    * Create and return a new entity bean instance.
    */

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

@@ -51,6 +51,11 @@ public final class EntityBeanIntercept implements Serializable {
    */
   private static final byte FLAG_ORIG_VALUE_SET = 8;
 
+  /**
+   * Flags indicating if the mutable hash is set.
+   */
+  private static final byte FLAG_MUTABLE_HASH_SET = 16;
+
   private transient final ReentrantLock lock = new ReentrantLock();
   private transient NodeUsageCollector nodeUsageCollector;
   private transient PersistenceContext persistenceContext;
@@ -91,6 +96,17 @@ public final class EntityBeanIntercept implements Serializable {
   private Object ownerId;
   private int sortOrder;
 
+  /**
+   * Holds information of json loaded jackson beans (e.g. the original json or checksum).
+   */
+  private MutableValueInfo[] mutableInfo;
+
+  /**
+   * Holds json content determined at point of dirty check.
+   * Stored here on dirty check such that we only convert to json once.
+   */
+  private MutableValueNext[] mutableNext;
+
   /**
    * Create a intercept with a given entity.
    */
@@ -228,6 +244,17 @@ public final class EntityBeanIntercept implements Serializable {
    * if any embedded beans are either new or dirty (and hence need saving).
    */
   public boolean isDirty() {
+    if (dirty) {
+      return true;
+    }
+    if (mutableInfo != null) {
+      for (int i = 0; i < mutableInfo.length; i++) {
+        if (mutableInfo[i] != null && !mutableInfo[i].isEqualToObject(owner._ebean_getField(i))) {
+          dirty = true;
+          break;
+        }
+      }
+    }
     return dirty;
   }
 
@@ -368,8 +395,18 @@ public final class EntityBeanIntercept implements Serializable {
     this.owner._ebean_setEmbeddedLoaded();
     this.lazyLoadProperty = -1;
     this.origValues = null;
+    // after save, transfer the mutable next values back to mutable info
+    if (mutableNext != null) {
+      for (int i = 0; i < mutableNext.length; i++) {
+        MutableValueNext next = mutableNext[i];
+        if (next != null) {
+          mutableInfo(i, next.info());
+        }
+      }
+    }
+    this.mutableNext = null;
     for (int i = 0; i < flags.length; i++) {
-      flags[i] &= ~(FLAG_CHANGED_PROP + FLAG_ORIG_VALUE_SET);
+      flags[i] &= ~(FLAG_CHANGED_PROP | FLAG_ORIG_VALUE_SET);
     }
     this.dirty = false;
   }
@@ -442,6 +479,10 @@ public final class EntityBeanIntercept implements Serializable {
    * Return the original value that was changed via an update.
    */
   public Object getOrigValue(int propertyIndex) {
+    if ((flags[propertyIndex] & (FLAG_ORIG_VALUE_SET | FLAG_MUTABLE_HASH_SET)) == FLAG_MUTABLE_HASH_SET) {
+      // mutable hash set, but not ORIG_VALUE
+      setOriginalValue(propertyIndex, mutableInfo[propertyIndex].get());
+    }
     if (origValues == null) {
       return null;
     }
@@ -476,7 +517,7 @@ public final class EntityBeanIntercept implements Serializable {
    * Return the number of properties.
    */
   public int getPropertyLength() {
-    return owner._ebean_getPropertyNames().length;
+    return flags.length;
   }
 
   /**
@@ -564,7 +605,7 @@ public final class EntityBeanIntercept implements Serializable {
 
   private void setOriginalValue(int propertyIndex, Object value) {
     if (origValues == null) {
-      origValues = new Object[owner._ebean_getPropertyNames().length];
+      origValues = new Object[flags.length];
     }
     if ((flags[propertyIndex] & FLAG_ORIG_VALUE_SET) == 0) {
       flags[propertyIndex] |= FLAG_ORIG_VALUE_SET;
@@ -577,7 +618,7 @@ public final class EntityBeanIntercept implements Serializable {
    */
   private void setOriginalValueForce(int propertyIndex, Object value) {
     if (origValues == null) {
-      origValues = new Object[owner._ebean_getPropertyNames().length];
+      origValues = new Object[flags.length];
     }
     origValues[propertyIndex] = value;
   }
@@ -638,7 +679,7 @@ public final class EntityBeanIntercept implements Serializable {
   public void addDirtyPropertyNames(Set<String> props, String prefix) {
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
+      if (isChangedProp(i)) {
         // the property has been changed on this bean
         props.add((prefix == null ? getProperty(i) : prefix + getProperty(i)));
       } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
@@ -656,7 +697,7 @@ public final class EntityBeanIntercept implements Serializable {
     String[] names = owner._ebean_getPropertyNames();
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
+      if (isChangedProp(i)) {
         if (propertyNames.contains(names[i])) {
           return true;
         }
@@ -684,7 +725,7 @@ public final class EntityBeanIntercept implements Serializable {
   public void addDirtyPropertyValues(Map<String, ValuePair> dirtyValues, String prefix) {
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
+      if (isChangedProp(i)) {
         // the property has been changed on this bean
         String propName = (prefix == null ? getProperty(i) : prefix + getProperty(i));
         Object newVal = owner._ebean_getField(i);
@@ -706,7 +747,7 @@ public final class EntityBeanIntercept implements Serializable {
   public void addDirtyPropertyValues(BeanDiffVisitor visitor) {
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
+      if (isChangedProp(i)) {
         // the property has been changed on this bean
         Object newVal = owner._ebean_getField(i);
         Object oldVal = getOrigValue(i);
@@ -741,7 +782,7 @@ public final class EntityBeanIntercept implements Serializable {
     }
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) { // we do not check against mutablecontent here.
         sb.append(i).append(',');
       } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         // an embedded property has been changed - recurse
@@ -802,7 +843,7 @@ public final class EntityBeanIntercept implements Serializable {
         }
         // For stand alone reference bean or after deserialisation lazy load
         // using the ebeanServer. Synchronise only on the bean.
-        loadBeanInternal(loadProperty, database.getPluginApi().beanLoader());
+        loadBeanInternal(loadProperty, database.pluginApi().beanLoader());
         return;
       }
     } finally {
@@ -1112,7 +1153,7 @@ public final class EntityBeanIntercept implements Serializable {
    */
   public void setLoadError(int propertyIndex, Exception t) {
     if (loadErrors == null) {
-      loadErrors = new Exception[owner._ebean_getPropertyNames().length];
+      loadErrors = new Exception[flags.length];
     }
     loadErrors[propertyIndex] = t;
     flags[propertyIndex] |= FLAG_LOADED_PROP;
@@ -1138,4 +1179,61 @@ public final class EntityBeanIntercept implements Serializable {
     }
     return ret;
   }
+
+  private boolean isChangedProp(int i) {
+    if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
+      return true;
+    } else if (mutableInfo == null || mutableInfo[i] == null || mutableInfo[i].isEqualToObject(owner._ebean_getField(i))) {
+      return false;
+    } else {
+      // mark for change
+      flags[i] |= FLAG_CHANGED_PROP;
+      dirty = true; // this makes the bean automatically dirty!
+      return true;
+    }
+  }
+
+  /**
+   * Return the MutableValueInfo for the given property or null.
+   */
+  public MutableValueInfo mutableInfo(int propertyIndex) {
+    return mutableInfo == null ? null : mutableInfo[propertyIndex];
+  }
+
+  /**
+   * Set the MutableValueInfo for the given property.
+   */
+  public void mutableInfo(int propertyIndex, MutableValueInfo info) {
+    if (mutableInfo == null) {
+      mutableInfo = new MutableValueInfo[flags.length];
+    }
+    flags[propertyIndex] |= FLAG_MUTABLE_HASH_SET;
+    mutableInfo[propertyIndex] = info;
+  }
+
+  /**
+   * Dirty detection set the next mutable property content and info .
+   * <p>
+   * Set here as the mutable property dirty detection is based on json content comparison.
+   * We only want to perform the json serialisation once so storing it here as part of
+   * dirty detection so that we can get it back to bind in insert or update etc.
+   */
+  public void mutableNext(int propertyIndex, MutableValueNext next) {
+    if (mutableNext == null) {
+      mutableNext = new MutableValueNext[flags.length];
+    }
+    mutableNext[propertyIndex] = next;
+  }
+
+  /**
+   * Update the 'next' mutable info returning the content that was obtained via dirty detection.
+   */
+  public String mutableNext(int propertyIndex) {
+    if (mutableNext == null) {
+      return null;
+    }
+    final MutableValueNext next = mutableNext[propertyIndex];
+    return next != null ? next.content() : null;
+  }
+
 }

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

@@ -0,0 +1,42 @@
+package io.ebean.bean;
+
+/**
+ * Holds information on mutable values (like plain beans stored as json).
+ * <p>
+ * Used internally in EntityBeanIntercept for dirty detection on mutable values.
+ * Typically, mutation detection is based on a hash/checksum of json content or the
+ * original json content itself.
+ * <p>
+ * Refer to the mapping options {@code @DbJson(mutationDetection)}.
+ */
+public interface MutableValueInfo {
+
+  /**
+   * Compares the given json returning null if deemed unchanged or returning
+   * the MutableValueNext to use if deemed dirty/changed.
+   * <p>
+   * Returning MutableValueNext allows an implementation based on hash/checksum
+   * to only perform that computation once.
+   *
+   * @return Null if deemed unchanged or the MutableValueNext if deemed changed.
+   */
+  MutableValueNext nextDirty(String json);
+
+  /**
+   * Compares the given object to an internal value.
+   * <p>
+   * This is used to support changelog/beanState. The implementation can serialize the
+   * object into json form and compare it against the original json.
+   */
+  boolean isEqualToObject(Object obj);
+
+  /**
+   * Creates a new instance from the internal json string.
+   * <p>
+   * This is used to provide an original/old value for change logging / persist listeners.
+   * This is only available for properties that have {@code @DbJson(keepSource=true)}.
+   */
+  default Object get() {
+    return null;
+  }
+}

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

@@ -0,0 +1,17 @@
+package io.ebean.bean;
+
+/**
+ * Represents a next value to use for mutable content properties (DbJson with jackson beans).
+ */
+public interface MutableValueNext {
+
+  /**
+   * Return the next content to use. Provided such that we serialise to json once.
+   */
+  String content();
+
+  /**
+   * Return the next MutableValueInfo to use after an update.
+   */
+  MutableValueInfo info();
+}

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

@@ -1,13 +1,10 @@
 package io.ebean.bean;
 
-import java.util.List;
-
 /**
  * Holds entity beans by there type and id.
  * <p>
  * This is used to ensure only one instance for a given entity type and id is
  * used to build object graphs from queries and lazy loading.
- * </p>
  */
 public interface PersistenceContext {
 
@@ -22,7 +19,6 @@ public interface PersistenceContext {
    * <p>
    * Returns an existing entity bean (if one is already there) and otherwise
    * returns null.
-   * </p>
    */
   Object putIfAbsent(Class<?> rootType, Object id, Object bean);
 
@@ -79,17 +75,11 @@ public interface PersistenceContext {
    */
   boolean resetLimit();
 
-  /**
-   * Return the list of dirty beans held by this persistence context.
-   */
-  List<Object> dirtyBeans();
-
   /**
    * Wrapper on a bean to also indicate if a bean has been deleted.
    * <p>
    * If a bean has been deleted then for the same persistence context is should
    * not be able to be fetched from persistence context or L2 cache.
-   * </p>
    */
   class WithOption {
 

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

@@ -20,7 +20,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
   @Override
   public String getName() {
-    return database.getName();
+    return database.name();
   }
 
   @Override
@@ -39,7 +39,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBeanL2(ebi);
+      database.pluginApi().loadBeanL2(ebi);
     }
   }
 
@@ -53,7 +53,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBeanRef(ebi);
+      database.pluginApi().loadBeanRef(ebi);
     }
   }
 
@@ -67,7 +67,7 @@ public abstract class SingleBeanLoader implements BeanLoader {
 
     @Override
     public void loadBean(EntityBeanIntercept ebi) {
-      database.getPluginApi().loadBean(ebi);
+      database.pluginApi().loadBean(ebi);
     }
   }
 }

ebean-api/src/main/java/io/ebean/cache/ServerCache.java

@@ -10,17 +10,17 @@ import java.util.Set;
  * Represents part of the "L2" server side cache.
  * <p>
  * This is used to cache beans or query results (bean collections).
- * </p>
  * <p>
  * There are 2 ServerCache's for each bean type. One is used as the 'bean cache'
  * which holds beans of a given type. The other is the 'query cache' holding
  * query results for a given type.
- * </p>
  */
 public interface ServerCache {
 
+  /**
+   * Get values for many keys.
+   */
   default Map<Object, Object> getAll(Set<Object> keys) {
-
     Map<Object, Object> map = new LinkedHashMap<>();
     for (Object key : keys) {
       Object value = get(key);
@@ -73,6 +73,14 @@ public interface ServerCache {
   /**
    * Return the hit ratio the cache is currently getting.
    */
+  default int hitRatio() {
+    return getHitRatio();
+  }
+
+  /**
+   * Deprecated migrate to hitRatio().
+   */
+  @Deprecated
   int getHitRatio();
 
   /**
@@ -80,6 +88,14 @@ public interface ServerCache {
    *
    * @param reset if true the statistics are reset.
    */
+  default ServerCacheStatistics statistics(boolean reset) {
+    return getStatistics(reset);
+  }
+
+  /**
+   * Deprecated migrate to statistics().
+   */
+  @Deprecated
   ServerCacheStatistics getStatistics(boolean reset);
 
   /**

ebean-api/src/main/java/io/ebean/cache/ServerCacheManager.java

@@ -21,7 +21,15 @@ public interface ServerCacheManager {
    * rather than background processing.
    * </p>
    */
-  boolean isLocalL2Caching();
+  boolean localL2Caching();
+
+  /**
+   * Deprecated migrate to localL2Caching().
+   */
+  @Deprecated
+  default boolean isLocalL2Caching() {
+    return localL2Caching();
+  }
 
   /**
    * Return all the cache regions.
@@ -36,37 +44,78 @@ public interface ServerCacheManager {
    *
    * @param regions A region name or comma delimited list of region names.
    */
-  void setEnabledRegions(String regions);
+  void enabledRegions(String regions);
+
+  /**
+   * Deprecated migrate to enabledRegions().
+   */
+  @Deprecated
+  default void setEnabledRegions(String regions) {
+    enabledRegions(regions);
+  }
 
   /**
    * Enable or disable all the cache regions.
    */
-  void setAllRegionsEnabled(boolean enabled);
+  void allRegionsEnabled(boolean enabled);
 
   /**
-   * Return the cache region by name. Typically to enable or disable the region.
+   * Deprecated migrate to allRegionsEnabled().
    */
-  ServerCacheRegion getRegion(String name);
+  @Deprecated
+  default void setAllRegionsEnabled(boolean enabled) {
+    allRegionsEnabled(enabled);
+  }
+
+  /**
+   * Return the cache region by name. Typically, to enable or disable the region.
+   */
+  ServerCacheRegion region(String name);
+
+  @Deprecated
+  default ServerCacheRegion getRegion(String name) {
+    return region(name);
+  }
 
   /**
    * Return the cache for mapping natural keys to id values.
    */
-  ServerCache getNaturalKeyCache(Class<?> beanType);
+  ServerCache naturalKeyCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getNaturalKeyCache(Class<?> beanType) {
+    return naturalKeyCache(beanType);
+  }
 
   /**
    * Return the cache for beans of a particular type.
    */
-  ServerCache getBeanCache(Class<?> beanType);
+  ServerCache beanCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getBeanCache(Class<?> beanType) {
+    return beanCache(beanType);
+  }
 
   /**
    * Return the cache for associated many properties of a bean type.
    */
-  ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName);
+  ServerCache collectionIdsCache(Class<?> beanType, String propertyName);
+
+  @Deprecated
+  default ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName) {
+    return collectionIdsCache(beanType, propertyName);
+  }
 
   /**
    * Return the cache for query results of a particular type of bean.
    */
-  ServerCache getQueryCache(Class<?> beanType);
+  ServerCache queryCache(Class<?> beanType);
+
+  @Deprecated
+  default ServerCache getQueryCache(Class<?> beanType) {
+    return queryCache(beanType);
+  }
 
   /**
    * This clears both the bean and query cache for a given type.

ebean-api/src/main/java/io/ebean/common/AbstractBeanCollection.java

@@ -63,7 +63,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
    */
   AbstractBeanCollection(BeanCollectionLoader loader, EntityBean ownerBean, String propertyName) {
     this.loader = loader;
-    this.ebeanServerName = loader.getName();
+    this.ebeanServerName = loader.name();
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
     this.readOnly = ownerBean != null && ownerBean._ebean_getIntercept().isReadOnly();
@@ -111,7 +111,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   public void setLoader(BeanCollectionLoader loader) {
     this.registeredWithLoadContext = true;
     this.loader = loader;
-    this.ebeanServerName = loader.getName();
+    this.ebeanServerName = loader.name();
   }
 
   @Override
@@ -135,6 +135,11 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   // Support for modify additions deletions etc - ManyToMany
   // ---------------------------------------------------------
 
+  @Override
+  public boolean hasModifications() {
+    return modifyHolder != null && modifyHolder.hasModifications();
+  }
+
   @Override
   public ModifyListenMode getModifyListening() {
     return modifyListenMode;
@@ -145,7 +150,6 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
    */
   @Override
   public void setModifyListening(ModifyListenMode mode) {
-
     this.modifyListenMode = mode;
     this.modifyListening = mode != null && ModifyListenMode.NONE != mode;
     if (modifyListening) {

ebean-api/src/main/java/io/ebean/common/ModifyHolder.java

@@ -3,9 +3,7 @@ package io.ebean.common;
 import io.ebean.bean.EntityBean;
 
 import java.io.Serializable;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.Set;
+import java.util.*;
 
 /**
  * Holds sets of additions and deletions from a 'owner' List Set or Map.
@@ -23,19 +21,19 @@ class ModifyHolder<E> implements Serializable {
   /**
    * Deletions list for manyToMany persistence.
    */
-  private Set<E> modifyDeletions = new LinkedHashSet<>();
+  private Map<E,Object> modifyDeletions = new IdentityHashMap<>();
 
   /**
    * Additions list for manyToMany persistence.
    */
-  private Set<E> modifyAdditions = new LinkedHashSet<>();
+  private Map<E,Object> modifyAdditions = new IdentityHashMap<>();
 
   private boolean touched;
 
   void reset() {
     touched = false;
-    modifyDeletions = new LinkedHashSet<>();
-    modifyAdditions = new LinkedHashSet<>();
+    modifyDeletions = new IdentityHashMap<>();
+    modifyAdditions = new IdentityHashMap<>();
   }
 
   /**
@@ -50,51 +48,46 @@ class ModifyHolder<E> implements Serializable {
   }
 
   private boolean undoDeletion(E bean) {
-    return (bean != null) && modifyDeletions.remove(bean);
+    return (bean != null) && modifyDeletions.remove(bean) != null;
   }
 
   void modifyAddition(E bean) {
     if (bean != null) {
       touched = true;
-
       if (bean instanceof EntityBean) {
         ((EntityBean) bean)._ebean_getIntercept().setDeletedFromCollection(false);
       }
-
       // If it is to delete then just remove the deletion
       if (!undoDeletion(bean)) {
-        // Insert
-        modifyAdditions.add(bean);
+        modifyAdditions.put(bean, bean);
       }
     }
   }
 
   private boolean undoAddition(Object bean) {
-    return (bean != null) && modifyAdditions.remove(bean);
+    return (bean != null) && modifyAdditions.remove(bean) != null;
   }
 
   @SuppressWarnings("unchecked")
   void modifyRemoval(Object bean) {
     if (bean != null) {
       touched = true;
-
       if (bean instanceof EntityBean) {
         ((EntityBean) bean)._ebean_getIntercept().setDeletedFromCollection(true);
       }
-
       // If it is to be added then just remove the addition
       if (!undoAddition(bean)) {
-        modifyDeletions.add((E) bean);
+        modifyDeletions.put((E) bean, bean);
       }
     }
   }
 
   Set<E> getModifyAdditions() {
-    return modifyAdditions;
+    return modifyAdditions.keySet();
   }
 
   Set<E> getModifyRemovals() {
-    return modifyDeletions;
+    return modifyDeletions.keySet();
   }
 
   /**

ebean-api/src/main/java/io/ebean/config/DatabaseConfig.java

@@ -7,9 +7,7 @@ import io.ebean.EbeanVersion;
 import io.ebean.PersistenceContextScope;
 import io.ebean.Query;
 import io.ebean.Transaction;
-import io.ebean.annotation.Encrypted;
-import io.ebean.annotation.PersistBatch;
-import io.ebean.annotation.Platform;
+import io.ebean.annotation.*;
 import io.ebean.cache.ServerCachePlugin;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.DbEncrypt;
@@ -194,10 +192,9 @@ public class DatabaseConfig {
   private JsonConfig.Include jsonInclude = JsonConfig.Include.ALL;
 
   /**
-   * When true then by default DbJson beans are assumed to be dirty.
-   * I believe we want to change this default to false in the future.
+   * The default mode used for {@code @DbJson} with Jackson ObjectMapper.
    */
-  private boolean jsonDirtyByDefault = true;
+  private MutationDetection jsonMutationDetection = MutationDetection.HASH;
 
   /**
    * The database platform name. Used to imply a DatabasePlatform to use.
@@ -322,6 +319,8 @@ public class DatabaseConfig {
    */
   private ExternalTransactionManager externalTransactionManager;
 
+  private boolean skipDataSourceCheck;
+
   /**
    * The data source (if programmatically provided).
    */
@@ -744,23 +743,21 @@ public class DatabaseConfig {
   }
 
   /**
-   * Return true if DbJson beans are assumed dirty by default.
-   * <p>
-   * That is, when true beans that do not implement ModifyAwareType are by
-   * default assumed to be dirty and included in updates.
+   * Return the default MutableDetection to use with {@code @DbJson} using Jackson.
+   *
+   * @see DbJson#mutationDetection()
    */
-  public boolean isJsonDirtyByDefault() {
-    return jsonDirtyByDefault;
+  public MutationDetection getJsonMutationDetection() {
+    return jsonMutationDetection;
   }
 
   /**
-   * Set to false if we want DbJson beans to not be assumed to be dirty.
-   * <p>
-   * That is, when true beans that do not implement ModifyAwareType are by
-   * default assumed to be dirty and included in updates.
+   * Set the default MutableDetection to use with {@code @DbJson} using Jackson.
+   *
+   * @see DbJson#mutationDetection()
    */
-  public void setJsonDirtyByDefault(boolean jsonDirtyByDefault) {
-    this.jsonDirtyByDefault = jsonDirtyByDefault;
+  public void setJsonMutationDetection(MutationDetection jsonMutationDetection) {
+    this.jsonMutationDetection = jsonMutationDetection;
   }
 
   /**
@@ -1656,6 +1653,20 @@ public class DatabaseConfig {
     this.autoTuneConfig = autoTuneConfig;
   }
 
+  /**
+   * Return true if the startup DataSource check should be skipped.
+   */
+  public boolean skipDataSourceCheck() {
+    return skipDataSourceCheck;
+  }
+
+  /**
+   * Set to true to skip the startup DataSource check.
+   */
+  public void setSkipDataSourceCheck(boolean skipDataSourceCheck) {
+    this.skipDataSourceCheck = skipDataSourceCheck;
+  }
+
   /**
    * Return the DataSource.
    */
@@ -2935,8 +2946,9 @@ public class DatabaseConfig {
     jsonInclude = p.getEnum(JsonConfig.Include.class, "jsonInclude", jsonInclude);
     jsonDateTime = p.getEnum(JsonConfig.DateTime.class, "jsonDateTime", jsonDateTime);
     jsonDate = p.getEnum(JsonConfig.Date.class, "jsonDate", jsonDate);
-    jsonDirtyByDefault = p.getBoolean("jsonDirtyByDefault", jsonDirtyByDefault);
+    jsonMutationDetection = p.getEnum(MutationDetection.class, "jsonMutationDetection", jsonMutationDetection);
 
+    skipDataSourceCheck = p.getBoolean("skipDataSourceCheck", skipDataSourceCheck);
     runMigration = p.getBoolean("migration.run", runMigration);
     ddlGenerate = p.getBoolean("ddl.generate", ddlGenerate);
     ddlRun = p.getBoolean("ddl.run", ddlRun);

ebean-api/src/main/java/io/ebean/config/dbplatform/oracle/Oracle11Platform.java

@@ -11,7 +11,6 @@ public class Oracle11Platform extends OraclePlatform {
   public Oracle11Platform() {
     super();
     this.platform = Platform.ORACLE11;
-    this.columnAliasPrefix = "c";
     this.sqlLimiter = new OracleRownumSqlLimiter();
     this.basicSqlLimiter = new OracleRownumBasicLimiter();
     dbIdentity.setIdType(IdType.SEQUENCE);

ebean-api/src/main/java/io/ebean/config/dbplatform/oracle/OraclePlatform.java

@@ -22,6 +22,7 @@ public class OraclePlatform extends DatabasePlatform {
   public OraclePlatform() {
     super();
     this.platform = Platform.ORACLE;
+    this.columnAliasPrefix = "c";
     this.supportsDeleteTableAlias = true;
     this.maxTableNameLength = 30;
     this.maxConstraintNameLength = 30;

ebean-api/src/main/java/io/ebean/event/BeanDeleteIdRequest.java

@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Transaction;
 
@@ -9,18 +10,62 @@ import io.ebean.Transaction;
 public interface BeanDeleteIdRequest {
 
   /**
-   * Return the server processing the request.
+   * Deprecated migrate to database().
    */
+  @Deprecated
   EbeanServer getEbeanServer();
 
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
+  default Database getDatabase() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Return the DB processing the request.
+   */
+  default Database database() {
+    return getEbeanServer();
+  }
+
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
+
+  /**
+   * Returns the bean type of the bean being deleted.
+   */
+  Class<?> beanType();
+
+  /**
+   * Deprecated migrate to beanType().
+   */
+  @Deprecated
+  default Class<?> getBeanType() {
+    return beanType();
+  }
 
   /**
    * Returns the Id value of the bean being deleted.
    */
-  Object getId();
+  Object id();
 
+  /**
+   * Deprecated migrate to id().
+   */
+  @Deprecated
+  default Object getId() {
+    return id();
+  }
 }

ebean-api/src/main/java/io/ebean/event/BeanPersistRequest.java

@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Transaction;
 import io.ebean.ValuePair;
@@ -17,20 +18,44 @@ import java.util.Set;
 public interface BeanPersistRequest<T> {
 
   /**
-   * Return the server processing the request.
+   * Return the DB processing the request.
    */
+  default Database database() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
   EbeanServer getEbeanServer();
 
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
 
   /**
    * For an update or delete of a partially populated bean this is the set of
    * loaded properties and otherwise returns null.
    */
-  Set<String> getLoadedProperties();
+  Set<String> loadedProperties();
+
+  /**
+   * Deprecated migrate to loadedProperties().
+   */
+  @Deprecated
+  default Set<String> getLoadedProperties() {
+    return loadedProperties();
+  }
 
   /**
    * For an update this is the set of properties that where updated.
@@ -39,12 +64,28 @@ public interface BeanPersistRequest<T> {
    * should be preferred if it satisfies the requirement.
    * </p>
    */
-  Set<String> getUpdatedProperties();
+  Set<String> updatedProperties();
+
+  /**
+   * Deprecated migrate to updatedProperties().
+   */
+  @Deprecated
+  default Set<String> getUpdatedProperties() {
+    return updatedProperties();
+  }
 
   /**
    * Flags set for dirty properties (used by ElasticSearch integration).
    */
-  boolean[] getDirtyProperties();
+  boolean[] dirtyProperties();
+
+  /**
+   * Deprecated migrate to updatedProperties().
+   */
+  @Deprecated
+  default boolean[] getDirtyProperties() {
+    return dirtyProperties();
+  }
 
   /**
    * Return true for an update request if at least one of dirty properties is contained
@@ -66,11 +107,27 @@ public interface BeanPersistRequest<T> {
   /**
    * Returns the bean being inserted updated or deleted.
    */
-  T getBean();
+  T bean();
+
+  /**
+   * Deprecated migrate to bean().
+   */
+  @Deprecated
+  default T getBean() {
+    return bean();
+  }
 
   /**
    * Returns a map of the properties that have changed and their new and old values.
    */
-  Map<String, ValuePair> getUpdatedValues();
+  Map<String, ValuePair> updatedValues();
+
+  /**
+   * Deprecated migrate to updatedValues().
+   */
+  @Deprecated
+  default Map<String, ValuePair> getUpdatedValues() {
+    return updatedValues();
+  }
 
 }

ebean-api/src/main/java/io/ebean/event/BeanQueryRequest.java

@@ -1,5 +1,6 @@
 package io.ebean.event;
 
+import io.ebean.Database;
 import io.ebean.EbeanServer;
 import io.ebean.Query;
 import io.ebean.Transaction;
@@ -10,19 +11,43 @@ import io.ebean.Transaction;
 public interface BeanQueryRequest<T> {
 
   /**
-   * Return the server processing the request.
+   * Return the DB processing the request.
    */
+  default Database database() {
+    return getEbeanServer();
+  }
+
+  /**
+   * Deprecated migrate to database().
+   */
+  @Deprecated
   EbeanServer getEbeanServer();
 
   /**
    * Return the Transaction associated with this request.
    */
-  Transaction getTransaction();
+  Transaction transaction();
+
+  /**
+   * Deprecated migrate to transaction().
+   */
+  @Deprecated
+  default Transaction getTransaction() {
+    return transaction();
+  }
 
   /**
    * Returns the query.
    */
-  Query<T> getQuery();
+  Query<T> query();
+
+  /**
+   * Deprecated migrate to query().
+   */
+  @Deprecated
+  default Query<T> getQuery() {
+    return query();
+  }
 
   /**
    * Return true if an Id IN expression should have the bind parameters padded.

ebean-api/src/main/java/io/ebean/event/BulkTableEvent.java

@@ -8,7 +8,15 @@ public interface BulkTableEvent {
   /**
    * Return the name of the table that was involved.
    */
-  String getTableName();
+  String tableName();
+
+  /**
+   * Deprecated migrate to tableName().
+   */
+  @Deprecated
+  default String getTableName() {
+    return tableName();
+  }
 
   /**
    * Return true if rows were inserted.

ebean-api/src/main/java/io/ebean/event/ShutdownManager.java

@@ -14,10 +14,9 @@ import java.util.List;
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
- * Manages the shutdown of the JVM Runtime.
+ * Manages the shutdown of Ebean.
  * <p>
  * Makes sure all the resources are shutdown properly and in order.
- * </p>
  */
 public final class ShutdownManager {
 
@@ -44,6 +43,9 @@ public final class ShutdownManager {
   private ShutdownManager() {
   }
 
+  /**
+   * Registers the container (potentially with cluster management).
+   */
   public static void registerContainer(SpiContainer ebeanContainer) {
     container = ebeanContainer;
   }
@@ -94,7 +96,7 @@ public final class ShutdownManager {
   /**
    * Register the shutdown hook with the Runtime.
    */
-  protected static void registerShutdownHook() {
+  private static void registerShutdownHook() {
     lock.lock();
     try {
       String value = System.getProperty("ebean.registerShutdownHook");
@@ -123,13 +125,10 @@ public final class ShutdownManager {
         // Already run shutdown...
         return;
       }
-
       if (logger.isDebugEnabled()) {
         logger.debug("Shutting down");
       }
-
       stopping = true;
-
       deregisterShutdownHook();
 
       String shutdownRunner = System.getProperty("ebean.shutdown.runnable");
@@ -147,7 +146,6 @@ public final class ShutdownManager {
         // shutdown cluster networking if active
         container.shutdown();
       }
-
       // shutdown any registered servers that have not
       // already been shutdown manually
       for (Database server : databases) {
@@ -158,7 +156,6 @@ public final class ShutdownManager {
           ex.printStackTrace();
         }
       }
-
       if ("true".equalsIgnoreCase(System.getProperty("ebean.datasource.deregisterAllDrivers", "false"))) {
         deregisterAllJdbcDrivers();
       }
@@ -168,15 +165,15 @@ public final class ShutdownManager {
   }
 
   private static void deregisterAllJdbcDrivers() {
-    // This manually deregisters all JDBC drivers
+    // This manually de-registers all JDBC drivers
     Enumeration<Driver> drivers = DriverManager.getDrivers();
     while (drivers.hasMoreElements()) {
       Driver driver = drivers.nextElement();
       try {
-        logger.info("Deregistering jdbc driver: " + driver);
+        logger.info("De-registering jdbc driver: " + driver);
         DriverManager.deregisterDriver(driver);
       } catch (SQLException e) {
-        logger.error("Error deregistering driver " + driver, e);
+        logger.error("Error de-registering driver " + driver, e);
       }
     }
   }
@@ -209,6 +206,9 @@ public final class ShutdownManager {
   }
 
   private static class ShutdownHook extends Thread {
+    private ShutdownHook() {
+      super("EbeanHook");
+    }
     @Override
     public void run() {
       ShutdownManager.shutdown();

ebean-api/src/main/java/io/ebean/meta/AbstractMetricVisitor.java

@@ -18,22 +18,22 @@ public abstract class AbstractMetricVisitor implements MetricVisitor {
   }
 
   @Override
-  public boolean isReset() {
+  public boolean reset() {
     return reset;
   }
 
   @Override
-  public boolean isCollectTransactionMetrics() {
+  public boolean collectTransactionMetrics() {
     return collectTransactionMetrics;
   }
 
   @Override
-  public boolean isCollectQueryMetrics() {
+  public boolean collectQueryMetrics() {
     return collectQueryMetrics;
   }
 
   @Override
-  public boolean isCollectL2Metrics() {
+  public boolean collectL2Metrics() {
     return collectL2Metrics;
   }
 

ebean-api/src/main/java/io/ebean/meta/BasicMetricVisitor.java

@@ -27,17 +27,17 @@ public class BasicMetricVisitor extends AbstractMetricVisitor implements ServerM
   }
 
   @Override
-  public List<MetaTimedMetric> getTimedMetrics() {
+  public List<MetaTimedMetric> timedMetrics() {
     return timed;
   }
 
   @Override
-  public List<MetaQueryMetric> getQueryMetrics() {
+  public List<MetaQueryMetric> queryMetrics() {
     return query;
   }
 
   @Override
-  public List<MetaCountMetric> getCountMetrics() {
+  public List<MetaCountMetric> countMetrics() {
     return count;
   }
 

ebean-api/src/main/java/io/ebean/meta/MetaCountMetric.java

@@ -8,6 +8,13 @@ public interface MetaCountMetric extends MetaMetric {
   /**
    * Return the total count.
    */
-  long getCount();
+  long count();
 
+  /**
+   * Migrate to count()
+   */
+  @Deprecated
+  default long getCount() {
+    return count();
+  }
 }

ebean-api/src/main/java/io/ebean/meta/MetaMetric.java

@@ -8,6 +8,13 @@ public interface MetaMetric {
   /**
    * Return the metric name.
    */
-  String getName();
+  String name();
 
+  /**
+   * Migrate to name().
+   */
+  @Deprecated
+  default String getName() {
+    return name();
+  }
 }

ebean-api/src/main/java/io/ebean/meta/MetaQueryMetric.java

@@ -8,21 +8,45 @@ public interface MetaQueryMetric extends MetaTimedMetric {
   /**
    * The type of entity or DTO bean.
    */
-  Class<?> getType();
+  Class<?> type();
+
+  /**
+   * Migrate to type().
+   */
+  @Deprecated
+  default Class<?> getType() {
+    return type();
+  }
 
   /**
    * The label for the query (can be null).
    */
-  String getLabel();
+  String label();
+
+  /**
+   * Migrate to label().
+   */
+  @Deprecated
+  default String getLabel() {
+    return label();
+  }
 
   /**
    * The actual SQL of the query.
    */
-  String getSql();
+  String sql();
+
+  /**
+   * Migrate to sql().
+   */
+  @Deprecated
+  default String getSql() {
+    return sql();
+  }
 
   /**
    * Return the hash of the plan.
    */
-  String getHash();
+  String hash();
 
 }

ebean-api/src/main/java/io/ebean/meta/MetaQueryPlan.java

@@ -10,45 +10,45 @@ public interface MetaQueryPlan {
   /**
    * Return the bean type for the query.
    */
-  Class<?> getBeanType();
+  Class<?> beanType();
 
   /**
    * Return the label of the query.
    */
-  String getLabel();
+  String label();
 
   /**
    * Return the profile location for the query.
    */
-  ProfileLocation getProfileLocation();
+  ProfileLocation profileLocation();
 
   /**
    * Return the sql of the query.
    */
-  String getSql();
+  String sql();
 
   /**
    * Return the hash of the plan.
    */
-  String getHash();
+  String hash();
 
   /**
    * Return a description of the bind values.
    */
-  String getBind();
+  String bind();
 
   /**
    * Return the raw plan.
    */
-  String getPlan();
+  String plan();
 
   /**
    * Return the query execution time associated with the bind values capture.
    */
-  long getQueryTimeMicros();
+  long queryTimeMicros();
 
   /**
    * Return the total count of times bind capture has occurred.
    */
-  long getCaptureCount();
+  long captureCount();
 }

ebean-api/src/main/java/io/ebean/meta/MetaTimedMetric.java

@@ -9,27 +9,68 @@ public interface MetaTimedMetric extends MetaMetric {
   /**
    * Return the metric location if defined.
    */
-  String getLocation();
+  String location();
+
+  /**
+   * Migrate to location()
+   */
+  @Deprecated
+  default String getLocation() {
+    return location();
+  }
 
   /**
    * Return the total count.
    */
-  long getCount();
+  long count();
+
+  /**
+   * Migrate to count()
+   */
+  @Deprecated
+  default long getCount() {
+    return count();
+  }
 
   /**
    * Return the total execution time in micros.
    */
-  long getTotal();
+  long total();
+
+  /**
+   * Migrate to total()
+   */
+  @Deprecated
+  default long getTotal() {
+    return total();
+  }
 
   /**
    * Return the max execution time in micros.
    */
-  long getMax();
+  long max();
+
+  /**
+   * Migrate to max()
+   */
+  @Deprecated
+  default long getMax() {
+    return max();
+  }
 
   /**
    * Return the mean execution time in micros.
    */
-  long getMean();
+  long mean();
+
+
+  /**
+   * Migrate to mean()
+   */
+  @Deprecated
+  default long getMean() {
+    return mean();
+  }
 
   /**
    * Return true if this is the first metrics collection for this query.

ebean-api/src/main/java/io/ebean/meta/MetricVisitor.java

@@ -8,22 +8,22 @@ public interface MetricVisitor {
   /**
    * Return true if the metrics should be reset.
    */
-  boolean isReset();
+  boolean reset();
 
   /**
    * Return true if we should visit the transaction metrics.
    */
-  boolean isCollectTransactionMetrics();
+  boolean collectTransactionMetrics();
 
   /**
    * Return true if we should visit the ORM and SQL query metrics.
    */
-  boolean isCollectQueryMetrics();
+  boolean collectQueryMetrics();
 
   /**
    * Return true if we should visit the L2 cache metrics.
    */
-  boolean isCollectL2Metrics();
+  boolean collectL2Metrics();
 
   /**
    * Visit has started.

ebean-api/src/main/java/io/ebean/meta/QueryPlanInit.java

@@ -32,7 +32,7 @@ public class QueryPlanInit {
    * Return the query execution time threshold which must be exceeded to initiate
    * query plan collection.
    */
-  public long getThresholdMicros() {
+  public long thresholdMicros() {
     return thresholdMicros;
   }
 
@@ -40,7 +40,7 @@ public class QueryPlanInit {
    * Set the query execution time threshold which must be exceeded to initiate
    * query plan collection.
    */
-  public void setThresholdMicros(long thresholdMicros) {
+  public void thresholdMicros(long thresholdMicros) {
     this.thresholdMicros = thresholdMicros;
   }
 
@@ -54,14 +54,14 @@ public class QueryPlanInit {
   /**
    * Return the specific hashes that we want to collect query plans on.
    */
-  public Set<String> getHashes() {
+  public Set<String> hashes() {
     return hashes;
   }
 
   /**
    * Set the specific hashes that we want to collect query plans on.
    */
-  public void setHashes(Set<String> hashes) {
+  public void hashes(Set<String> hashes) {
     this.hashes = hashes;
   }
 }

ebean-api/src/main/java/io/ebean/meta/QueryPlanRequest.java

@@ -18,7 +18,7 @@ public class QueryPlanRequest {
    * have been around for a while (e.g. 5 mins) and so reasonably represent
    * bind values that match the slowest execution for this query plan.
    */
-  public long getSince() {
+  public long since() {
     return since;
   }
 
@@ -28,14 +28,14 @@ public class QueryPlanRequest {
    *
    * @param since The minimum age of the bind values capture.
    */
-  public void setSince(long since) {
+  public void since(long since) {
     this.since = since;
   }
 
   /**
    * Return the maximum number of plans to capture.
    */
-  public int getMaxCount() {
+  public int maxCount() {
     return maxCount;
   }
 
@@ -45,7 +45,7 @@ public class QueryPlanRequest {
    * Use this to limit how much query plan capturing is done as query
    * plan capture is actual database load.
    */
-  public void setMaxCount(int maxCount) {
+  public void maxCount(int maxCount) {
     this.maxCount = maxCount;
   }
 
@@ -54,7 +54,7 @@ public class QueryPlanRequest {
    * <p>
    * Query plan collection will stop once this time is exceeded.
    */
-  public long getMaxTimeMillis() {
+  public long maxTimeMillis() {
     return maxTimeMillis;
   }
 
@@ -65,7 +65,7 @@ public class QueryPlanRequest {
    * this to ensure the query plan capture does not use excessive amount
    * of time - put too much load on the database.
    */
-  public void setMaxTimeMillis(long maxTimeMillis) {
+  public void maxTimeMillis(long maxTimeMillis) {
     this.maxTimeMillis = maxTimeMillis;
   }
 }

ebean-api/src/main/java/io/ebean/meta/ServerMetrics.java

@@ -10,16 +10,39 @@ public interface ServerMetrics {
   /**
    * Return timed metrics for Transactions, labelled SqlQuery, labelled SqlUpdate.
    */
-  List<MetaTimedMetric> getTimedMetrics();
+  List<MetaTimedMetric> timedMetrics();
+
+  /**
+   * Migrate to timedMetrics().
+   */
+  @Deprecated
+  default List<MetaTimedMetric> getTimedMetrics() {
+    return timedMetrics();
+  }
 
   /**
    * Return the query metrics.
    */
-  List<MetaQueryMetric> getQueryMetrics();
+  List<MetaQueryMetric> queryMetrics();
+
+  /**
+   * Migrate to queryMetrics().
+   */
+  @Deprecated
+  default List<MetaQueryMetric> getQueryMetrics() {
+    return queryMetrics();
+  }
 
   /**
    * Return the Counter metrics.
    */
-  List<MetaCountMetric> getCountMetrics();
+  List<MetaCountMetric> countMetrics();
 
+  /**
+   * Migrate to countMetrics().
+   */
+  @Deprecated
+  default List<MetaCountMetric> getCountMetrics() {
+    return countMetrics();
+  }
 }

ebean-api/src/main/java/io/ebean/meta/ServerMetricsAsJson.java

@@ -8,12 +8,12 @@ import java.util.Comparator;
 public interface ServerMetricsAsJson {
 
   /**
-   * Set to false to exclude profile location and sql.
+   * Set to false in order to exclude profile location and sql.
    */
   ServerMetricsAsJson withExtraAttributes(boolean withLocation);
 
   /**
-   * Set to false to exclude SQL hash.
+   * Set to false in order to exclude SQL hash.
    */
   ServerMetricsAsJson withHash(boolean withHash);
 

ebean-api/src/main/java/io/ebean/meta/SortMetric.java

@@ -32,7 +32,7 @@ public class SortMetric {
 
     @Override
     public int compare(MetaCountMetric o1, MetaCountMetric o2) {
-      return stringCompare(o1.getName(), o2.getName());
+      return stringCompare(o1.name(), o2.name());
     }
   }
 
@@ -43,8 +43,8 @@ public class SortMetric {
 
     @Override
     public int compare(MetaTimedMetric o1, MetaTimedMetric o2) {
-      int i = stringCompare(o1.getName(), o2.getName());
-      return i != 0 ? i : Long.compare(o1.getCount(), o2.getCount());
+      int i = stringCompare(o1.name(), o2.name());
+      return i != 0 ? i : Long.compare(o1.count(), o2.count());
     }
   }
 
@@ -55,7 +55,7 @@ public class SortMetric {
 
     @Override
     public int compare(MetaTimedMetric o1, MetaTimedMetric o2) {
-      return Long.compare(o2.getCount(), o1.getCount());
+      return Long.compare(o2.count(), o1.count());
     }
   }
 
@@ -66,7 +66,7 @@ public class SortMetric {
 
     @Override
     public int compare(MetaTimedMetric o1, MetaTimedMetric o2) {
-      return Long.compare(o2.getTotal(), o1.getTotal());
+      return Long.compare(o2.total(), o1.total());
     }
   }
 
@@ -77,7 +77,7 @@ public class SortMetric {
 
     @Override
     public int compare(MetaTimedMetric o1, MetaTimedMetric o2) {
-      return Long.compare(o2.getMean(), o1.getMean());
+      return Long.compare(o2.mean(), o1.mean());
     }
   }
 
@@ -88,7 +88,7 @@ public class SortMetric {
 
     @Override
     public int compare(MetaTimedMetric o1, MetaTimedMetric o2) {
-      return Long.compare(o2.getMax(), o1.getMax());
+      return Long.compare(o2.max(), o1.max());
     }
   }
 }

ebean-api/src/main/java/io/ebean/plugin/BeanType.java

@@ -121,8 +121,9 @@ public interface BeanType<T> {
   Object beanId(Object bean);
 
   /**
-   * Return the id value for the given bean.
+   * Deprecated migrate to beanId()
    */
+  @Deprecated
   Object getBeanId(T bean);
 
   /**

ebean-api/src/main/java/io/ebean/plugin/SpiServer.java

@@ -16,32 +16,80 @@ public interface SpiServer extends Database {
   /**
    * Return the DatabaseConfig.
    */
-  DatabaseConfig getServerConfig();
+  DatabaseConfig config();
+
+  /**
+   * Migrate to config().
+   */
+  @Deprecated
+  default DatabaseConfig getServerConfig() {
+    return config();
+  }
 
   /**
    * Return the DatabasePlatform for this database.
    */
-  DatabasePlatform getDatabasePlatform();
+  DatabasePlatform databasePlatform();
+
+  /**
+   * Migrate to config().
+   */
+  @Deprecated
+  default DatabasePlatform getDatabasePlatform() {
+    return databasePlatform();
+  }
 
   /**
    * Return all the bean types registered on this server instance.
    */
-  List<? extends BeanType<?>> getBeanTypes();
+  List<? extends BeanType<?>> beanTypes();
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default List<? extends BeanType<?>> getBeanTypes() {
+    return beanTypes();
+  }
 
   /**
    * Return the bean type for a given entity bean class.
    */
-  <T> BeanType<T> getBeanType(Class<T> beanClass);
+  <T> BeanType<T> beanType(Class<T> beanClass);
+
+  /**
+   * Migrate to beanType().
+   */
+  @Deprecated
+  default <T> BeanType<T> getBeanType(Class<T> beanClass) {
+    return beanType(beanClass);
+  }
 
   /**
    * Return the bean types mapped to the given base table.
    */
-  List<? extends BeanType<?>> getBeanTypes(String baseTableName);
+  List<? extends BeanType<?>> beanTypes(String baseTableName);
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default List<? extends BeanType<?>> getBeanTypes(String baseTableName) {
+    return beanTypes(baseTableName);
+  }
 
   /**
    * Return the bean type for a given doc store queueId.
    */
-  BeanType<?> getBeanTypeForQueueId(String queueId);
+  BeanType<?> beanTypeForQueueId(String queueId);
+
+  /**
+   * Migrate to beanTypes().
+   */
+  @Deprecated
+  default BeanType<?> getBeanTypeForQueueId(String queueId) {
+    return beanTypeForQueueId(queueId);
+  }
 
   /**
    * Return a BeanLoader.

ebean-api/src/main/java/io/ebean/util/JdbcClose.java

@@ -66,4 +66,17 @@ public class JdbcClose {
       logger.warn("Error on connection rollback", e);
     }
   }
+
+  /**
+   * Cancels the statement
+   */
+  public static void cancel(Statement stmt) {
+    try {
+      if (stmt != null) {
+        stmt.cancel();
+      }
+    } catch (SQLException e) {
+      logger.warn("Error on cancelling statement", e);
+    }
+  }
 }

ebean-autotune/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.9.2</version>
+    <version>12.11.3</version>
   </parent>
 <!--  <parent>-->
 <!--    <groupId>org.avaje</groupId>-->
@@ -14,7 +14,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.9.2</tag>
+    <tag>ebean-parent-12.11.3</tag>
   </scm>
 
   <name>ebean autotune</name>
@@ -26,7 +26,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core</artifactId>
-      <version>12.9.2</version>
+      <version>12.11.3</version>
       <scope>provided</scope>
     </dependency>
 

ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/AutoTuneDiffCollection.java

@@ -113,7 +113,7 @@ public class AutoTuneDiffCollection {
 
     diffCount++;
 
-    Origin origin = createOrigin(entry, point, tuneDetail.toString());
+    Origin origin = createOrigin(entry, point, tuneDetail.asString());
     ProfileDiff diff = document.getProfileDiff();
     if (diff == null) {
       diff = new ProfileDiff();
@@ -147,7 +147,7 @@ public class AutoTuneDiffCollection {
     Origin origin = new Origin();
     origin.setKey(point.getKey());
     origin.setBeanType(point.getBeanType());
-    origin.setDetail(entry.getDetail().toString());
+    origin.setDetail(entry.getDetail().asString());
     origin.setCallStack(point.getCallOrigin().getFullDescription());
     origin.setOriginal(query);
 

ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/BaseQueryTuner.java

@@ -146,7 +146,8 @@ public class BaseQueryTuner {
       case ID_LIST:
       case UPDATE:
       case DELETE:
-      case SUBQUERY:
+      case SQ_EXISTS:
+      case SQ_IN:
         return false;
       default:
         // not using autoTune when explicitly loading the l2 bean cache

ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/DefaultAutoTuneService.java

@@ -59,7 +59,7 @@ public class DefaultAutoTuneService implements AutoTuneService {
     this.tuningFile = config.getQueryTuningFile();
     this.profilingFile = config.getProfilingFile();
     this.profilingUpdateFrequency = config.getProfilingUpdateFrequency();
-    this.serverName = server.getName();
+    this.serverName = server.name();
     this.profileManager = new ProfileManager(config, server);
     this.queryTuner = new BaseQueryTuner(config, server, profileManager);
     this.skipGarbageCollectionOnShutdown = config.isSkipGarbageCollectionOnShutdown();
@@ -77,7 +77,7 @@ public class DefaultAutoTuneService implements AutoTuneService {
       loadTuningFile();
       if (isRuntimeTuningUpdates()) {
         // periodically gather and update query tuning
-        server.getBackgroundExecutor().scheduleWithFixedDelay(new ProfilingUpdate(), profilingUpdateFrequency, profilingUpdateFrequency, TimeUnit.SECONDS);
+        server.backgroundExecutor().scheduleWithFixedDelay(new ProfilingUpdate(), profilingUpdateFrequency, profilingUpdateFrequency, TimeUnit.SECONDS);
       }
     }
   }

ebean-autotune/src/main/java/io/ebeaninternal/server/autotune/service/TunedQueryInfo.java

@@ -65,7 +65,7 @@ public class TunedQueryInfo implements Serializable {
 
   @Override
   public String toString() {
-    return tunedDetail.toString();
+    return tunedDetail.asString();
   }
 
 }

ebean-bom/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.9.2</version>
+    <version>12.11.3</version>
   </parent>
 
   <name>ebean bom</name>
@@ -12,16 +12,6 @@
   <artifactId>ebean-bom</artifactId>
   <packaging>pom</packaging>
 
-  <properties>
-    <ebean-ddl-runner.version>1.0</ebean-ddl-runner.version>
-    <ebean-migration-auto.version>1.0</ebean-migration-auto.version>
-    <ebean-migration.version>12.4.0</ebean-migration.version>
-    <ebean-test-docker.version>4.1</ebean-test-docker.version>
-    <ebean-datasource.version>7.0</ebean-datasource.version>
-    <ebean-agent.version>12.9.0</ebean-agent.version>
-    <ebean-maven-plugin.version>12.9.1</ebean-maven-plugin.version>
-  </properties>
-
   <dependencyManagement>
 
     <dependencies>
@@ -81,88 +71,88 @@
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-api</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-core</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-core-type</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-ddl-generator</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-externalmapping-api</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-externalmapping-xml</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-autotune</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-querybean</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>querybean-generator</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
         <scope>provided</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>kotlin-querybean-generator</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
         <scope>provided</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-test</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
         <scope>test</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-postgis</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-redis</artifactId>
-        <version>12.9.2</version>
+        <version>12.11.3</version>
       </dependency>
 
     </dependencies>

ebean-core-type/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.9.2</version>
+    <version>12.11.3</version>
   </parent>
 
   <artifactId>ebean-core-type</artifactId>
@@ -16,7 +16,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.9.2</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>

ebean-core-type/src/main/java/io/ebean/core/type/DataBinder.java

@@ -163,4 +163,15 @@ public interface DataBinder {
    * Bind an array value.
    */
   void setArray(String arrayType, Object[] elements) throws SQLException;
+
+  /**
+   * Push json from dirty detection to be available for binding.
+   */
+  void pushJson(String json);
+
+  /**
+   * Pop json made during dirty detection for scalarType binding.
+   */
+  String popJson();
+
 }

ebean-core-type/src/main/java/io/ebean/core/type/DataReader.java

@@ -48,4 +48,14 @@ public interface DataReader {
   Object getObject() throws SQLException;
 
   InputStream getBinaryStream() throws SQLException;
+
+  /**
+   * Push json from dirty detection to be available for binding.
+   */
+  void pushJson(String json);
+
+  /**
+   * Pop json made during dirty detection for scalarType binding.
+   */
+  String popJson();
 }

ebean-core-type/src/main/java/io/ebean/core/type/ScalarType.java

@@ -2,6 +2,7 @@ package io.ebean.core.type;
 
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonParser;
+
 import io.ebean.text.StringFormatter;
 import io.ebean.text.StringParser;
 
@@ -34,6 +35,10 @@ import java.sql.SQLException;
  */
 public interface ScalarType<T> extends StringParser, StringFormatter, ScalarDataReader<T> {
 
+  default boolean isJsonMapper() {
+    return false;
+  }
+
   /**
    * Return true if this is a binary type and can not support parse() and format() from/to string.
    * This allows Ebean to optimise marshalling types to string.

ebean-core/pom.xml

@@ -3,7 +3,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.9.2</version>
+    <version>12.11.3</version>
   </parent>
 
   <artifactId>ebean-core</artifactId>
@@ -15,27 +15,18 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.9.2</tag>
+    <tag>ebean-parent-12.11.3</tag>
   </scm>
 
   <profiles>
     <profile>
-      <!-- Note: to use this profile, you need to download manually the db2jcc4 driver.
-        After that, install it into your local maven repository:
-
-        mvn install:install-file \
-          -Dfile=db2jcc4.jar \
-          -DgroupId=com.ibm.jdbc \
-          -DartifactId=db2jcc4 \
-          -Dversion=4.23.42 \
-          -Dpackaging=jar
-      -->
       <id>db2</id>
       <dependencies>
+        <!-- https://mvnrepository.com/artifact/com.ibm.db2/jcc -->
         <dependency>
-          <groupId>com.ibm.jdbc</groupId>
-          <artifactId>db2jcc4</artifactId>
-          <version>4.23.42</version>
+          <groupId>com.ibm.db2</groupId>
+          <artifactId>jcc</artifactId>
+          <version>11.5.5.0</version>
           <scope>test</scope>
         </dependency>
       </dependencies>
@@ -52,13 +43,13 @@
     <dependency>
       <groupId>io.avaje</groupId>
       <artifactId>classpath-scanner</artifactId>
-      <version>4.2</version>
+      <version>6.0</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-migration-auto</artifactId>
-      <version>1.0</version>
+      <version>1.1</version>
     </dependency>
 
     <!-- keep testing in core using ebean-ddl-generator & ebean-migration -->
@@ -72,7 +63,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-ddl-generator</artifactId>
-      <version>12.9.0</version>
+      <version>12.11.0</version>
       <scope>test</scope>
     </dependency>
 
@@ -87,19 +78,19 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.9.2</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core-type</artifactId>
-      <version>12.9.2</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-externalmapping-api</artifactId>
-      <version>12.9.2</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>
@@ -182,7 +173,7 @@
     <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
-      <version>42.2.10</version>
+      <version>42.2.20</version>
       <optional>true</optional>
     </dependency>
 
@@ -302,7 +293,7 @@
       <plugin>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-maven-plugin</artifactId>
-        <version>12.9.1</version>
+        <version>${ebean-maven-plugin.version}</version>
         <executions>
           <execution>
             <id>test</id>

ebean-core/src/main/java/io/ebeaninternal/api/BeanCacheResult.java

@@ -6,7 +6,7 @@ import java.util.List;
 /**
  * The results of bean cache hit.
  */
-public class BeanCacheResult<T> {
+public final class BeanCacheResult<T> {
 
   private final List<Entry<T>> list = new ArrayList<>();
 
@@ -27,7 +27,7 @@ public class BeanCacheResult<T> {
   /**
    * Bean and cache key pair.
    */
-  static class Entry<T> {
+  static final class Entry<T> {
 
     private final T bean;
     private final Object key;

ebean-core/src/main/java/io/ebeaninternal/api/BinaryReadContext.java

@@ -7,7 +7,7 @@ import java.io.IOException;
 /**
  * Context used to read binary format messages.
  */
-public class BinaryReadContext {
+public final class BinaryReadContext {
 
   private final DataInputStream in;
 

ebean-core/src/main/java/io/ebeaninternal/api/BinaryWriteContext.java

@@ -6,10 +6,9 @@ import java.io.IOException;
 /**
  * Context used to write binary message (like RemoteTransactionEvent).
  */
-public class BinaryWriteContext {
+public final class BinaryWriteContext {
 
   private final DataOutputStream out;
-
   private long counter;
 
   public BinaryWriteContext(DataOutputStream out) {

ebean-core/src/main/java/io/ebeaninternal/api/BindParams.java

@@ -4,11 +4,7 @@ import io.ebeaninternal.server.persist.MultiValueWrapper;
 import io.ebeaninternal.server.querydefn.NaturalKeyBindParam;
 
 import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
 
 /**
@@ -17,35 +13,28 @@ import java.util.Map.Entry;
  * Supports ordered or named parameters.
  * </p>
  */
-public class BindParams implements Serializable {
+public final class BindParams implements Serializable {
 
   private static final long serialVersionUID = 4541081933302086285L;
 
   private final List<Param> positionedParameters = new ArrayList<>();
-
   private final Map<String, Param> namedParameters = new LinkedHashMap<>();
-
   /**
    * This is the sql. For named parameters this is the sql after the named
    * parameters have been replaced with question mark place holders and the
    * parameters have been ordered by addNamedParamInOrder().
    */
   private String preparedSql;
-
   /**
    * Bind hash and count used to detect when the bind values have changed such
    * that the generated SQL (with named parameters) needs to be recalculated.
    */
   private String bindHash;
-
   /**
    * Helper to add positioned parameters in order.
    */
   private int addPos;
 
-  public BindParams() {
-  }
-
   /**
    * Reset positioned parameters (usually due to bind parameter expansion).
    */
@@ -54,12 +43,11 @@ public class BindParams implements Serializable {
     positionedParameters.clear();
   }
 
-  public int queryBindHash() {
-    int hc = namedParameters.hashCode();
-    for (Param positionedParameter : positionedParameters) {
-      hc = hc * 92821 + positionedParameter.hashCode();
+  public void queryBindHash(BindValuesKey key) {
+    key.add(positionedParameters.size());
+    for (Param param : positionedParameters) {
+       param.queryBindHash(key);
     }
-    return hc;
   }
 
   /**
@@ -424,7 +412,14 @@ public class BindParams implements Serializable {
 
     @Override
     public boolean equals(Object o) {
-      return o != null && (o == this || (o instanceof Param) && hashCode() == o.hashCode());
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      Param param = (Param) o;
+      return isInParam == param.isInParam && isOutParam == param.isOutParam && type == param.type && Objects.equals(inValue, param.inValue);
+    }
+
+    void queryBindHash(BindValuesKey key) {
+      key.add(isInParam).add(isOutParam).add(type).add(inValue);
     }
 
     /**

ebean-core/src/main/java/io/ebeaninternal/api/BindValuesKey.java

@@ -0,0 +1,35 @@
+package io.ebeaninternal.api;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * BindValues used for L2 query cache key matching.
+ * <p>
+ * The equals/hashCode implementation must meet the requirement that the query bind values
+ * match for L2 query cache hit (given the query plan hash is already a match).
+ */
+public final class BindValuesKey {
+
+  private final List<Object> values = new ArrayList<>();
+
+  /**
+   * Add a bind value.
+   */
+  public BindValuesKey add(Object value) {
+    values.add(value);
+    return this;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    return obj instanceof BindValuesKey && ((BindValuesKey) obj).values.equals(values);
+  }
+
+  @Override
+  public int hashCode() {
+    return values.hashCode();
+  }
+
+
+}

ebean-core/src/main/java/io/ebeaninternal/api/CacheIdLookupMany.java

@@ -11,10 +11,9 @@ import java.util.Set;
 /**
  * Used for bean cache lookup with where ids in expression.
  */
-public class CacheIdLookupMany<T> implements CacheIdLookup<T> {
+public final class CacheIdLookupMany<T> implements CacheIdLookup<T> {
 
   private final IdInExpression idInExpression;
-
   private int remaining;
 
   public CacheIdLookupMany(IdInExpression idInExpression) {

ebean-core/src/main/java/io/ebeaninternal/api/CacheIdLookupSingle.java

@@ -7,7 +7,7 @@ import java.util.List;
 /**
  * Used for bean cache lookup with a single id value.
  */
-public class CacheIdLookupSingle<T> implements CacheIdLookup<T> {
+public final class CacheIdLookupSingle<T> implements CacheIdLookup<T> {
 
   private final Object idValue;
   private boolean found;

ebean-core/src/main/java/io/ebeaninternal/api/DbOffline.java

@@ -1,16 +1,12 @@
 package io.ebeaninternal.api;
 
 import io.ebean.annotation.Platform;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * Helper to indicate that an EbeanServer should come up offline
  * typically for DDL generation purposes.
  */
-public class DbOffline {
-
-  private static final Logger logger = LoggerFactory.getLogger(DbOffline.class);
+public final class DbOffline {
 
   private static final String KEY = "ebean.dboffline";
 
@@ -73,7 +69,6 @@ public class DbOffline {
   public static void reset() {
     generateMigration = false;
     System.clearProperty(KEY);
-    logger.debug("reset");
   }
 
 }

ebean-core/src/main/java/io/ebeaninternal/api/ExtraMetrics.java

@@ -8,7 +8,7 @@ import io.ebean.metric.TimedMetric;
 /**
  * Extra metrics collected to measure internal behaviour.
  */
-public class ExtraMetrics {
+public final class ExtraMetrics {
 
   private final TimedMetric bindCapture;
   private final TimedMetric planCollect;

ebean-core/src/main/java/io/ebeaninternal/api/HashQuery.java

@@ -3,18 +3,17 @@ package io.ebeaninternal.api;
 /**
  * A hash key for a query including both the query plan and bind values.
  */
-public class HashQuery {
+public final class HashQuery {
 
   private final CQueryPlanKey planHash;
-
-  private final int bindHash;
+  private final BindValuesKey bindValuesKey;
 
   /**
    * Create the HashQuery.
    */
-  public HashQuery(CQueryPlanKey planHash, int bindHash) {
+  public HashQuery(CQueryPlanKey planHash, BindValuesKey bindValuesKey) {
     this.planHash = planHash;
-    this.bindHash = bindHash;
+    this.bindValuesKey = bindValuesKey;
   }
 
   @Override
@@ -25,7 +24,7 @@ public class HashQuery {
   @Override
   public int hashCode() {
     int hc = 92821 * planHash.hashCode();
-    hc = 92821 * hc + bindHash;
+    hc = 92821 * hc + bindValuesKey.hashCode();
     return hc;
   }
 
@@ -37,8 +36,7 @@ public class HashQuery {
     if (!(obj instanceof HashQuery)) {
       return false;
     }
-
     HashQuery e = (HashQuery) obj;
-    return e.bindHash == bindHash && e.planHash.equals(planHash);
+    return e.bindValuesKey.equals(bindValuesKey) && e.planHash.equals(planHash);
   }
 }

ebean-core/src/main/java/io/ebeaninternal/api/HelpScopeTrans.java

@@ -6,7 +6,7 @@ import io.ebean.TxScope;
 /**
  * Helper object to make AOP generated code simpler.
  */
-public class HelpScopeTrans {
+public final class HelpScopeTrans {
   private static boolean enabled = true;
 
   /**

ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanBuffer.java

@@ -11,15 +11,15 @@ import java.util.List;
  */
 public interface LoadBeanBuffer {
 
-  int getBatchSize();
+  int batchSize();
 
-  List<EntityBeanIntercept> getBatch();
+  List<EntityBeanIntercept> batch();
 
-  BeanDescriptor<?> getBeanDescriptor();
+  BeanDescriptor<?> descriptor();
 
-  PersistenceContext getPersistenceContext();
+  PersistenceContext persistenceContext();
 
-  String getFullPath();
+  String fullPath();
 
   void configureQuery(SpiQuery<?> query, String lazyLoadProperty);
 

ebean-core/src/main/java/io/ebeaninternal/api/LoadBeanRequest.java

@@ -1,7 +1,8 @@
 package io.ebeaninternal.api;
 
-import io.ebean.bean.EntityBean;
+import io.ebean.CacheMode;
 import io.ebean.bean.EntityBeanIntercept;
+import io.ebeaninternal.api.SpiQuery.Mode;
 import io.ebeaninternal.server.core.OrmQueryRequest;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 
@@ -13,89 +14,60 @@ import java.util.Set;
 /**
  * Request for loading ManyToOne and OneToOne relationships.
  */
-public class LoadBeanRequest extends LoadRequest {
+public final class LoadBeanRequest extends LoadRequest {
 
   private final List<EntityBeanIntercept> batch;
-
   private final LoadBeanBuffer loadBuffer;
-
   private final String lazyLoadProperty;
-
   private final boolean loadCache;
-
-  private boolean loadedFromCache;
+  private final boolean alreadyLoaded;
 
   /**
    * Construct for lazy load request.
    */
-  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, EntityBeanIntercept ebi, boolean loadCache) {
-    this(LoadBuffer, null, true, ebi.getLazyLoadProperty(), loadCache);
-    this.loadedFromCache = ebi.isLoadedFromCache();
+  public LoadBeanRequest(LoadBeanBuffer loadBuffer, EntityBeanIntercept ebi, boolean loadCache) {
+    this(loadBuffer, null, true, ebi.getLazyLoadProperty(), ebi.isLoaded(), loadCache || ebi.isLoadedFromCache());
   }
 
   /**
    * Construct for secondary query.
    */
-  public LoadBeanRequest(LoadBeanBuffer LoadBuffer, OrmQueryRequest<?> parentRequest) {
-    this(LoadBuffer, parentRequest, false, null, false);
+  public LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest<?> parentRequest) {
+    this(loadBuffer, parentRequest, false, null, false, false);
   }
 
   private LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest<?> parentRequest, boolean lazy,
-                          String lazyLoadProperty, boolean loadCache) {
-
+                          String lazyLoadProperty, boolean alreadyLoaded, boolean loadCache) {
     super(parentRequest, lazy);
     this.loadBuffer = loadBuffer;
-    this.batch = loadBuffer.getBatch();
+    this.batch = loadBuffer.batch();
     this.lazyLoadProperty = lazyLoadProperty;
+    this.alreadyLoaded = alreadyLoaded;
     this.loadCache = loadCache;
   }
 
   @Override
-  public Class<?> getBeanType() {
-    return loadBuffer.getBeanDescriptor().getBeanType();
+  public Class<?> beanType() {
+    return loadBuffer.descriptor().getBeanType();
   }
 
-  /**
-   * Return true if the beans invoking lazy loading were previously loaded from cache.
-   */
-  public boolean isLoadedFromCache() {
-    return loadedFromCache;
-  }
-
-  private boolean isLoadCache() {
-    return loadCache;
-  }
-
-  public String getDescription() {
-    return "path:" + loadBuffer.getFullPath() + " batch:" + batch.size();
+  public String description() {
+    return loadBuffer.fullPath();
   }
 
   /**
    * Return the batch of beans to actually load.
    */
-  public List<EntityBeanIntercept> getBatch() {
+  public List<EntityBeanIntercept> batch() {
     return batch;
   }
 
-  /**
-   * Return the load context.
-   */
-  private LoadBeanBuffer getLoadContext() {
-    return loadBuffer;
-  }
-
-  public int getBatchSize() {
-    return getLoadContext().getBatchSize();
-  }
-
   /**
    * Return the list of Id values for the beans in the lazy load buffer.
    */
   public List<Object> getIdList() {
-
     List<Object> idList = new ArrayList<>();
-
-    BeanDescriptor<?> desc = loadBuffer.getBeanDescriptor();
+    BeanDescriptor<?> desc = loadBuffer.descriptor();
     for (EntityBeanIntercept ebi : batch) {
       idList.add(desc.getId(ebi.getOwner()));
     }
@@ -106,20 +78,21 @@ public class LoadBeanRequest extends LoadRequest {
    * Configure the query for lazy loading execution.
    */
   public void configureQuery(SpiQuery<?> query, List<Object> idList) {
-
-    query.setMode(SpiQuery.Mode.LAZYLOAD_BEAN);
-    query.setPersistenceContext(loadBuffer.getPersistenceContext());
-
-    String mode = isLazy() ? "+lazy" : "+query";
-    query.setLoadDescription(mode, getDescription());
-
-    if (isLazy()) {
-      // cascade the batch size (if set) for further lazy loading
-      query.setLazyLoadBatchSize(getBatchSize());
+    query.setMode(Mode.LAZYLOAD_BEAN);
+    query.setPersistenceContext(loadBuffer.persistenceContext());
+    query.setLoadDescription(lazy ? "+lazy" : "+query", description());
+    if (lazy) {
+      query.setLazyLoadBatchSize(loadBuffer.batchSize());
+      if (alreadyLoaded) {
+        query.setBeanCacheMode(CacheMode.OFF);
+      }
+    } else {
+      query.setBeanCacheMode(CacheMode.OFF);
     }
-
     loadBuffer.configureQuery(query, lazyLoadProperty);
-
+    if (loadCache) {
+      query.setBeanCacheMode(CacheMode.PUT);
+    }
     if (idList.size() == 1) {
       query.where().idEq(idList.get(0));
     } else {
@@ -131,19 +104,15 @@ public class LoadBeanRequest extends LoadRequest {
    * Load the beans into the L2 cache if that is requested and check for load failures due to deletes.
    */
   public void postLoad(List<?> list) {
-
     Set<Object> loadedIds = new HashSet<>();
-
-    BeanDescriptor<?> desc = loadBuffer.getBeanDescriptor();
+    BeanDescriptor<?> desc = loadBuffer.descriptor();
     // collect Ids and maybe load bean cache
-    for (Object aList : list) {
-      EntityBean loadedBean = (EntityBean) aList;
-      loadedIds.add(desc.getId(loadedBean));
+    for (Object bean : list) {
+      loadedIds.add(desc.beanId(bean));
     }
-    if (isLoadCache()) {
+    if (loadCache) {
       desc.cacheBeanPutAll(list);
     }
-
     if (lazyLoadProperty != null) {
       for (EntityBeanIntercept ebi : batch) {
         // check if the underlying row in DB was deleted. Mark the bean as 'failed' if

ebean-core/src/main/java/io/ebeaninternal/api/LoadManyRequest.java

@@ -1,5 +1,6 @@
 package io.ebeaninternal.api;
 
+import io.ebean.CacheMode;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebeaninternal.server.core.BindPadding;
@@ -15,16 +16,13 @@ import java.util.List;
 /**
  * Request for loading Associated Many Beans.
  */
-public class LoadManyRequest extends LoadRequest {
+public final class LoadManyRequest extends LoadRequest {
 
   private static final Logger logger = LoggerFactory.getLogger(LoadManyRequest.class);
 
   private final List<BeanCollection<?>> batch;
-
   private final LoadManyBuffer loadContext;
-
   private final boolean onlyIds;
-
   private final boolean loadCache;
 
   /**
@@ -50,49 +48,17 @@ public class LoadManyRequest extends LoadRequest {
   }
 
   @Override
-  public Class<?> getBeanType() {
+  public Class<?> beanType() {
     return loadContext.getBeanDescriptor().getBeanType();
   }
 
-  public String getDescription() {
-    return "path:" + loadContext.getFullPath() + " size:" + batch.size();
-  }
-
-  /**
-   * Return the batch of collections to actually load.
-   */
-  public List<BeanCollection<?>> getBatch() {
-    return batch;
-  }
-
-  /**
-   * Return true if lazy loading should only load the id values.
-   * <p>
-   * This for use when lazy loading is invoked on methods such as clear() and removeAll() where it
-   * generally makes sense to only fetch the Id values as the other property information is not
-   * used.
-   */
-  private boolean isOnlyIds() {
-    return onlyIds;
-  }
-
-  /**
-   * Return true if we should load the Collection ids into the cache.
-   */
-  private boolean isLoadCache() {
-    return loadCache;
-  }
-
-  /**
-   * Return the batch size used for this load context.
-   */
-  public int getBatchSize() {
-    return loadContext.getBatchSize();
+  public String description() {
+    return loadContext.getFullPath();
   }
 
   private List<Object> parentIdList(SpiEbeanServer server) {
     List<Object> idList = new ArrayList<>();
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     for (BeanCollection<?> bc : batch) {
       idList.add(many.getParentId(bc.getOwnerBean()));
       bc.setLoader(server); // don't use the load buffer again
@@ -103,42 +69,36 @@ public class LoadManyRequest extends LoadRequest {
     return idList;
   }
 
-  private BeanPropertyAssocMany<?> getMany() {
+  private BeanPropertyAssocMany<?> many() {
     return loadContext.getBeanProperty();
   }
 
   public SpiQuery<?> createQuery(SpiEbeanServer server) {
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     SpiQuery<?> query = many.newQuery(server);
     String orderBy = many.getLazyFetchOrderBy();
     if (orderBy != null) {
       query.order(orderBy);
     }
-
     String extraWhere = many.getExtraWhere();
     if (extraWhere != null) {
       // replace special ${ta} placeholder with the base table alias
       // which is always t0 and add the extra where clause
-      query.where().raw(extraWhere.replace("${ta}", "t0"));
+      query.where().raw(extraWhere.replace("${ta}", "t0").replace("${mta}", "int_"));
     }
-
     query.setLazyLoadForParents(many);
     many.addWhereParentIdIn(query, parentIdList(server), loadContext.isUseDocStore());
     query.setPersistenceContext(loadContext.getPersistenceContext());
-
-    String mode = isLazy() ? "+lazy" : "+query";
-    query.setLoadDescription(mode, getDescription());
-
-    if (isLazy()) {
-      // cascade the batch size (if set) for further lazy loading
-      query.setLazyLoadBatchSize(getBatchSize());
+    query.setLoadDescription(lazy ? "+lazy" : "+query", description());
+    if (lazy) {
+      query.setLazyLoadBatchSize(loadContext.getBatchSize());
+    } else {
+      query.setBeanCacheMode(CacheMode.OFF);
     }
-
-    // potentially changes the joins and selected properties
+    // potentially changes the joins, selected properties, cache mode
     loadContext.configureQuery(query);
-
-    if (isOnlyIds()) {
-      // override to just select the Id values
+    if (onlyIds) {
+      // lazy loading invoked via clear() and removeAll()
       query.select(many.getTargetIdProperty());
     }
     return query;
@@ -149,7 +109,7 @@ public class LoadManyRequest extends LoadRequest {
    */
   public void postLoad() {
     BeanDescriptor<?> desc = loadContext.getBeanDescriptor();
-    BeanPropertyAssocMany<?> many = getMany();
+    BeanPropertyAssocMany<?> many = many();
     // check for BeanCollection's that where never processed
     // in the +query or +lazy load due to no rows (predicates)
     for (BeanCollection<?> bc : batch) {
@@ -159,9 +119,8 @@ public class LoadManyRequest extends LoadRequest {
           Object parentId = desc.getId(ownerBean);
           logger.debug("BeanCollection after lazy load was empty. type:" + ownerBean.getClass().getName() + " id:" + parentId + " owner:" + ownerBean);
         }
-      } else if (isLoadCache() && many.isUseCache()) {
-        Object parentId = desc.getId(bc.getOwnerBean());
-        desc.cacheManyPropPut(many, bc, parentId);
+      } else if (loadCache && many.isUseCache()) {
+        desc.cacheManyPropPut(many, bc, desc.getId(bc.getOwnerBean()));
       }
     }
   }

ebean-core/src/main/java/io/ebeaninternal/api/LoadRequest.java

@@ -9,22 +9,19 @@ import io.ebeaninternal.server.core.OrmQueryRequest;
 public abstract class LoadRequest {
 
   protected final OrmQueryRequest<?> parentRequest;
-
   protected final Transaction transaction;
-
   protected final boolean lazy;
 
-  public LoadRequest(OrmQueryRequest<?> parentRequest, boolean lazy) {
-
+  LoadRequest(OrmQueryRequest<?> parentRequest, boolean lazy) {
     this.parentRequest = parentRequest;
-    this.transaction = parentRequest == null ? null : parentRequest.getTransaction();
+    this.transaction = parentRequest == null ? null : parentRequest.transaction();
     this.lazy = lazy;
   }
 
   /**
    * Return the associated bean type for this load request.
    */
-  public abstract Class<?> getBeanType();
+  public abstract Class<?> beanType();
 
   /**
    * Return true if this is a lazy load and false if it is a secondary query.
@@ -39,7 +36,7 @@ public abstract class LoadRequest {
    * Lazy loading queries run in their own transaction.
    * </p>
    */
-  public Transaction getTransaction() {
+  public Transaction transaction() {
     return transaction;
   }
 
@@ -48,6 +45,6 @@ public abstract class LoadRequest {
    * So one of - findIterate(), findEach(), findEachWhile() or findVisit().
    */
   public boolean isParentFindIterate() {
-    return parentRequest != null && parentRequest.getQuery().getType() == SpiQuery.Type.ITERATE;
+    return parentRequest != null && parentRequest.query().getType() == SpiQuery.Type.ITERATE;
   }
 }

ebean-core/src/main/java/io/ebeaninternal/api/ManyWhereJoins.java

@@ -17,16 +17,13 @@ import java.util.TreeSet;
  * Holds the joins needs to support the many where predicates.
  * These joins are independent of any 'fetch' joins on the many.
  */
-public class ManyWhereJoins implements Serializable {
+public final class ManyWhereJoins implements Serializable {
 
   private static final long serialVersionUID = -6490181101871795417L;
 
   private final TreeMap<String, PropertyJoin> joins = new TreeMap<>();
-
   private List<String> formulaJoinProperties;
-
   private boolean aggregation;
-
   /**
    * 'Mode' indicating that joins added while this is true are required to be outer joins.
    */

ebean-core/src/main/java/io/ebeaninternal/api/Monitor.java

@@ -1,12 +0,0 @@
-package io.ebeaninternal.api;
-
-import java.io.Serializable;
-
-/**
- * Object used as a synchronization monitor that is serializable.
- */
-public class Monitor implements Serializable {
-
-  private static final long serialVersionUID = -2741687226680981940L;
-
-}

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeyEntryBasic.java

@@ -11,7 +11,7 @@ import java.util.Map;
 /**
  * Natural key entry with name value pairs for each of the properties making up the key.
  */
-class NaturalKeyEntryBasic implements NaturalKeyEntry {
+final class NaturalKeyEntryBasic implements NaturalKeyEntry {
 
   private final Map<String,Object> map = new HashMap<>();
   private final String key;

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeyEntrySimple.java

@@ -1,6 +1,6 @@
 package io.ebeaninternal.api;
 
-class NaturalKeyEntrySimple implements NaturalKeyEntry {
+final class NaturalKeyEntrySimple implements NaturalKeyEntry {
 
   private final String key;
   private final Object val;

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeyEq.java

@@ -3,7 +3,7 @@ package io.ebeaninternal.api;
 /**
  * A property value pair in a natural key lookup.
  */
-public class NaturalKeyEq {
+public final class NaturalKeyEq {
 
   final String property;
   final Object value;

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeyQueryData.java

@@ -11,28 +11,22 @@ import java.util.Set;
 /**
  * Collects the data for processing the natural key cache processing.
  */
-public class NaturalKeyQueryData<T> {
+public final class NaturalKeyQueryData<T> {
 
   private final BeanNaturalKey naturalKey;
-
   /**
    * Only one of IN or IN PAIRS is allowed.
    */
   private boolean hasIn;
-
   // IN Pairs clause - only one allowed
   private String inProperty0, inProperty1;
   private List<Pairs.Entry> inPairs;
-
   // IN clause - only one allowed
   private List<Object> inValues;
   private String inProperty;
-
   // normal EQ expressions
   private List<NaturalKeyEq> eqList;
-
   private NaturalKeySet set;
-
   private int hitCount;
 
   public NaturalKeyQueryData(BeanNaturalKey naturalKey) {

ebean-core/src/main/java/io/ebeaninternal/api/NaturalKeySet.java

@@ -4,8 +4,7 @@ import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 
-public class NaturalKeySet {
-
+public final class NaturalKeySet {
 
   private final Map<Object, NaturalKeyEntry> map = new LinkedHashMap<>();
 

ebean-core/src/main/java/io/ebeaninternal/api/NoopQueryBindCapture.java

@@ -2,7 +2,7 @@ package io.ebeaninternal.api;
 
 import io.ebeaninternal.server.type.bindcapture.BindCapture;
 
-class NoopQueryBindCapture implements SpiQueryBindCapture {
+final class NoopQueryBindCapture implements SpiQueryBindCapture {
 
   @Override
   public boolean collectFor(long timeMicros) {

ebean-core/src/main/java/io/ebeaninternal/api/NoopQueryPlanManager.java

@@ -6,7 +6,7 @@ import io.ebean.meta.QueryPlanRequest;
 import java.util.Collections;
 import java.util.List;
 
-class NoopQueryPlanManager implements QueryPlanManager {
+final class NoopQueryPlanManager implements QueryPlanManager {
 
   @Override
   public void setDefaultThreshold(long thresholdMicros) {

ebean-core/src/main/java/io/ebeaninternal/api/PlatformMatch.java

@@ -3,7 +3,7 @@ package io.ebeaninternal.api;
 import io.ebean.annotation.Platform;
 import io.ebean.util.StringHelper;
 
-public class PlatformMatch {
+public final class PlatformMatch {
 
   /**
    * Return true if the script platforms is a match/supported for the given platform.
@@ -15,7 +15,6 @@ public class PlatformMatch {
     if (platforms == null || platforms.trim().isEmpty()) {
       return true;
     }
-
     // match on base platform name and platform name
     for (String name : StringHelper.splitNames(platforms)) {
       if (name.equalsIgnoreCase(platform.base().name()) || name.equalsIgnoreCase(platform.name())) {

ebean-core/src/main/java/io/ebeaninternal/api/PropertyJoin.java

@@ -5,16 +5,9 @@ import io.ebeaninternal.server.query.SqlJoinType;
 /**
  * Represents a join required for a given property and whether than needs to be an outer join.
  */
-public class PropertyJoin {
+public final class PropertyJoin {
 
-  /**
-   * The property name.
-   */
   private final String property;
-
-  /**
-   * Set to true if the property needs to be an outer join.
-   */
   private final SqlJoinType joinType;
 
   public PropertyJoin(String property, SqlJoinType joinType) {

ebean-core/src/main/java/io/ebeaninternal/api/ScopeTrans.java

@@ -7,7 +7,7 @@ import java.util.ArrayList;
 /**
  * Used internally to handle the scoping of transactions for methods.
  */
-public class ScopeTrans {
+public final class ScopeTrans {
 
   private static final int OPCODE_ATHROW = 191;
 
@@ -15,43 +15,32 @@ public class ScopeTrans {
    * The transaction in scope (can be null).
    */
   private final SpiTransaction transaction;
-
   /**
    * If true by default rollback on Checked exceptions.
    */
   private final boolean rollbackOnChecked;
-
   /**
    * True if the transaction was created and hence should be committed
    * on finally if it hasn't already been rolled back.
    */
   private final boolean created;
-
   /**
    * Explicit set of Exceptions that DO NOT cause a rollback to occur.
    */
   private final ArrayList<Class<? extends Throwable>> noRollbackFor;
-
   /**
    * Explicit set of Exceptions that DO cause a rollback to occur.
    */
   private final ArrayList<Class<? extends Throwable>> rollbackFor;
-
   private Boolean restoreBatch;
-
   private Boolean restoreBatchOnCascade;
-
   private int restoreBatchSize;
-
   private Boolean restoreBatchGeneratedKeys;
-
   private boolean restoreBatchFlushOnQuery;
-
   /**
    * Flag set when a rollback has occurred.
    */
   private boolean rolledBack;
-
   /**
    * Flag set when nested commit has occurred.
    */

ebean-core/src/main/java/io/ebeaninternal/api/ScopedTransaction.java

@@ -10,15 +10,13 @@ import javax.persistence.PersistenceException;
  *
  * These can be nested and internally they are pushed and popped from a stack.
  */
-public class ScopedTransaction extends SpiTransactionProxy {
+public final class ScopedTransaction extends SpiTransactionProxy {
 
   private final TransactionScopeManager manager;
-
   /**
    * Stack of 'nested' transactions.
    */
   private final ArrayStack<ScopeTrans> stack = new ArrayStack<>();
-
   private ScopeTrans current;
 
   /**

ebean-core/src/main/java/io/ebeaninternal/api/SpiBeanType.java

@@ -0,0 +1,17 @@
+package io.ebeaninternal.api;
+
+import io.ebean.bean.EntityBean;
+
+/**
+ * SPI interface for underlying BeanDescriptor.
+ */
+public interface SpiBeanType {
+
+  /**
+   * Return true if the bean contains a many property that has modifications.
+   * <p>
+   * That is a ManyToMany or a OneToMany with orphan removal with additions
+   * or removals from the collection.
+   */
+  boolean isToManyDirty(EntityBean bean);
+}

ebean-core/src/main/java/io/ebeaninternal/api/SpiBeanTypeManager.java

@@ -0,0 +1,13 @@
+package io.ebeaninternal.api;
+
+/**
+ * Manager of SpiBeanTypes.
+ */
+public interface SpiBeanTypeManager {
+
+  /**
+   * Return the bean type for the given entity class.
+   */
+  SpiBeanType getBeanType(Class<?> entityType);
+
+}

ebean-core/src/main/java/io/ebeaninternal/api/SpiCancelableQuery.java

@@ -0,0 +1,26 @@
+package io.ebeaninternal.api;
+
+import javax.persistence.PersistenceException;
+
+import io.ebean.CancelableQuery;
+
+/**
+ * Cancellable query, that has a delegate.
+ *
+ * @author Roland Praml, FOCONIS AG
+ *
+ */
+public interface SpiCancelableQuery extends CancelableQuery {
+
+  /**
+   * Checks if the query was cancelled.
+   * @throws PersistenceException if query was cancelled.
+   */
+  void checkCancelled();
+
+  /**
+   * Set the underlying cancelable query (with the PreparedStatement).
+   */
+  void setCancelableQuery(CancelableQuery cancelableQuery);
+
+}

ebean-core/src/main/java/io/ebeaninternal/api/SpiDtoQuery.java

@@ -36,11 +36,6 @@ public interface SpiDtoQuery<T> extends DtoQuery<T>, SpiSqlBinding {
    */
   boolean isRelaxedMode();
 
-  /**
-   * Return the label for the query.
-   */
-  String getLabel();
-
   /**
    * Return the label with fallback to profile location label.
    */

ebean-core/src/main/java/io/ebeaninternal/api/SpiEbeanServer.java

@@ -8,6 +8,8 @@ import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.event.readaudit.ReadAuditLogger;
 import io.ebean.event.readaudit.ReadAuditPrepare;
 import io.ebean.meta.MetricVisitor;
+import io.ebean.plugin.SpiServer;
+import io.ebeaninternal.api.SpiQuery.Type;
 import io.ebeaninternal.server.core.SpiResultSet;
 import io.ebeaninternal.server.core.timezone.DataTimeZone;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
@@ -22,7 +24,7 @@ import java.util.stream.Stream;
 /**
  * Service Provider extension to EbeanServer.
  */
-public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollectionLoader {
+public interface SpiEbeanServer extends SpiServer, ExtendedServer, EbeanServer, BeanCollectionLoader {
 
   /**
    * Return true if the L2 cache has been disabled.
@@ -49,16 +51,6 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
    */
   Object currentTenantId();
 
-  /**
-   * Return the server configuration.
-   */
-  DatabaseConfig getServerConfig();
-
-  /**
-   * Return the DatabasePlatform for this server.
-   */
-  DatabasePlatform getDatabasePlatform();
-
   /**
    * Create an object to represent the current CallStack.
    * <p>
@@ -149,7 +141,7 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanCollect
   /**
    * Compile a query.
    */
-  <T> CQuery<T> compileQuery(Query<T> query, Transaction t);
+  <T> CQuery<T> compileQuery(Type type, Query<T> query, Transaction t);
 
   /**
    * Execute the findId's query but without copying the query.

ebean-core/src/main/java/io/ebeaninternal/api/SpiExpression.java

@@ -54,9 +54,9 @@ public interface SpiExpression extends Expression {
   void queryPlanHash(StringBuilder builder);
 
   /**
-   * Return the hash value for the values that will be bound.
+   * Build the key for bind values of the query.
    */
-  int queryBindHash();
+  void queryBindKey(BindValuesKey key);
 
   /**
    * Return true if the expression is the same with respect to bind values.

ebean-core/src/main/java/io/ebeaninternal/api/SpiExpressionList.java

@@ -44,8 +44,4 @@ public interface SpiExpressionList<T> extends ExpressionList<T>, SpiExpression {
     // do nothing by default
   }
 
-  /**
-   * Apply property prefix when filterMany expressions included in main query.
-   */
-  void prefixProperty(String path);
 }

ebean-core/src/main/java/io/ebeaninternal/api/SpiExpressionValidation.java

@@ -8,10 +8,9 @@ import java.util.Set;
 /**
  * Property expression validation request for a given root bean type.
  */
-public class SpiExpressionValidation {
+public final class SpiExpressionValidation {
 
   private final BeanType<?> desc;
-
   private final LinkedHashSet<String> unknown = new LinkedHashSet<>();
 
   public SpiExpressionValidation(BeanType<?> desc) {