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

#2335 -  L2 cache be triggered by in ?

ebean-api/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2</version>
+    <version>12.11.3</version>
   </parent>
 
   <name>ebean api</name>

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

@@ -843,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 {

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

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/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-autotune/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.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.11.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.11.2</version>
+      <version>12.11.3</version>
       <scope>provided</scope>
     </dependency>
 

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-bom/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2</version>
+    <version>12.11.3</version>
   </parent>
 
   <name>ebean bom</name>
@@ -71,88 +71,88 @@
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-api</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-core</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-core-type</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-ddl-generator</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-externalmapping-api</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-externalmapping-xml</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-autotune</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-querybean</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>querybean-generator</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
         <scope>provided</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>kotlin-querybean-generator</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
         <scope>provided</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-test</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
         <scope>test</scope>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-postgis</artifactId>
-        <version>12.11.2</version>
+        <version>12.11.3</version>
       </dependency>
 
       <dependency>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-redis</artifactId>
-        <version>12.11.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.11.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.11.2</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>

ebean-core/pom.xml

@@ -3,7 +3,7 @@
   <parent>
     <artifactId>ebean-parent</artifactId>
     <groupId>io.ebean</groupId>
-    <version>12.11.2</version>
+    <version>12.11.3</version>
   </parent>
 
   <artifactId>ebean-core</artifactId>
@@ -15,7 +15,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-parent-12.11.2</tag>
+    <tag>ebean-parent-12.11.3</tag>
   </scm>
 
   <profiles>
@@ -78,19 +78,19 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-api</artifactId>
-      <version>12.11.2</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-core-type</artifactId>
-      <version>12.11.2</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-externalmapping-api</artifactId>
-      <version>12.11.2</version>
+      <version>12.11.3</version>
     </dependency>
 
     <dependency>

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;
 
@@ -19,77 +20,54 @@ public final class LoadBeanRequest extends LoadRequest {
   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()));
     }
@@ -100,16 +78,21 @@ public final 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 {
@@ -122,13 +105,12 @@ public final class LoadBeanRequest extends LoadRequest {
    */
   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 bean : list) {
-      EntityBean loadedBean = (EntityBean) bean;
-      loadedIds.add(desc.getId(loadedBean));
+      loadedIds.add(desc.beanId(bean));
     }
-    if (isLoadCache()) {
+    if (loadCache) {
       desc.cacheBeanPutAll(list);
     }
     if (lazyLoadProperty != null) {

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;
@@ -47,49 +48,17 @@ public final 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
@@ -100,42 +69,36 @@ public final 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").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;
@@ -146,7 +109,7 @@ public final 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) {
@@ -156,9 +119,8 @@ public final 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/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,7 @@ 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;
@@ -23,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.
@@ -50,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>

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

@@ -39,7 +39,7 @@ public final class TransactionEventTable implements Serializable, BinaryWritable
   }
 
   public void add(TableIUD newTableIUD) {
-    TableIUD existingTableIUD = map.put(newTableIUD.getTableName(), newTableIUD);
+    TableIUD existingTableIUD = map.put(newTableIUD.tableName(), newTableIUD);
     if (existingTableIUD != null) {
       newTableIUD.add(existingTableIUD);
     }
@@ -104,7 +104,7 @@ public final class TransactionEventTable implements Serializable, BinaryWritable
     }
 
     @Override
-    public String getTableName() {
+    public String tableName() {
       return table;
     }
 

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultCacheAdapter.java

@@ -27,7 +27,7 @@ public final class DefaultCacheAdapter implements ServerCacheManager {
   }
 
   @Override
-  public boolean isLocalL2Caching() {
+  public boolean localL2Caching() {
     return cacheManager.isLocalL2Caching();
   }
 
@@ -37,37 +37,37 @@ public final class DefaultCacheAdapter implements ServerCacheManager {
   }
 
   @Override
-  public void setEnabledRegions(String regions) {
+  public void enabledRegions(String regions) {
     cacheManager.setEnabledRegions(regions);
   }
 
   @Override
-  public ServerCacheRegion getRegion(String region) {
+  public ServerCacheRegion region(String region) {
     return cacheManager.getRegion(region);
   }
 
   @Override
-  public void setAllRegionsEnabled(boolean enabled) {
+  public void allRegionsEnabled(boolean enabled) {
     cacheManager.setAllRegionsEnabled(enabled);
   }
 
   @Override
-  public ServerCache getNaturalKeyCache(Class<?> beanType) {
+  public ServerCache naturalKeyCache(Class<?> beanType) {
     return cacheManager.getNaturalKeyCache(beanType);
   }
 
   @Override
-  public ServerCache getBeanCache(Class<?> beanType) {
+  public ServerCache beanCache(Class<?> beanType) {
     return cacheManager.getBeanCache(beanType);
   }
 
   @Override
-  public ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName) {
+  public ServerCache collectionIdsCache(Class<?> beanType, String propertyName) {
     return cacheManager.getCollectionIdsCache(beanType, propertyName);
   }
 
   @Override
-  public ServerCache getQueryCache(Class<?> beanType) {
+  public ServerCache queryCache(Class<?> beanType) {
     return cacheManager.getQueryCache(beanType);
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/changelog/DefaultChangeLogListener.java

@@ -46,7 +46,7 @@ public final class DefaultChangeLogListener implements ChangeLogListener, Plugin
   @Override
   public void configure(SpiServer server) {
     jsonBuilder = new ChangeJsonBuilder();
-    Properties properties = server.getServerConfig().getProperties();
+    Properties properties = server.config().getProperties();
     if (properties != null) {
       String bufferSize = properties.getProperty("ebean.changeLog.bufferSize");
       if (bufferSize != null) {

ebean-core/src/main/java/io/ebeaninternal/server/cluster/ClusterManager.java

@@ -56,7 +56,7 @@ public class ClusterManager implements ServerLookup {
   public void registerServer(EbeanServer server) {
     lock.lock();
     try {
-      serverMap.put(server.getName(), server);
+      serverMap.put(server.name(), server);
       if (!started) {
         startup();
       }

ebean-core/src/main/java/io/ebeaninternal/server/core/AbstractSqlQueryRequest.java

@@ -121,7 +121,7 @@ public abstract class AbstractSqlQueryRequest implements CancelableQuery {
     int firstRow = query.getFirstRow();
     int maxRows = query.getMaxRows();
     if (firstRow > 0 || maxRows > 0) {
-      return server.getDatabasePlatform().getBasicSqlLimiter().limit(sql, firstRow, maxRows);
+      return server.databasePlatform().getBasicSqlLimiter().limit(sql, firstRow, maxRows);
     }
     return sql;
   }

ebean-core/src/main/java/io/ebeaninternal/server/core/BeanRequest.java

@@ -14,21 +14,13 @@ public abstract class BeanRequest {
 
   static final Logger log = LoggerFactory.getLogger(BeanRequest.class);
 
-  /**
-   * The server processing the request.
-   */
-  protected final SpiEbeanServer ebeanServer;
-
-  /**
-   * The transaction this is part of.
-   */
+  protected final SpiEbeanServer server;
   protected SpiTransaction transaction;
-
   protected boolean createdTransaction;
 
-  public BeanRequest(SpiEbeanServer ebeanServer, SpiTransaction t) {
-    this.ebeanServer = ebeanServer;
-    this.transaction = t;
+  public BeanRequest(SpiEbeanServer server, SpiTransaction transaction) {
+    this.server = server;
+    this.transaction = transaction;
   }
 
   /**
@@ -36,7 +28,6 @@ public abstract class BeanRequest {
    * <p>
    * A transaction may have been passed in or active in the thread local. If
    * not then create one implicitly to handle the request.
-   * </p>
    *
    * @return True if a transaction was set (from current or created).
    */
@@ -44,10 +35,10 @@ public abstract class BeanRequest {
     if (transaction != null) {
       return false;
     }
-    transaction = ebeanServer.currentServerTransaction();
+    transaction = server.currentServerTransaction();
     if (transaction == null || !transaction.isActive()) {
       // create an implicit transaction to execute this query
-      transaction = ebeanServer.beginServerTransaction();
+      transaction = server.beginServerTransaction();
       createdTransaction = true;
     }
     return true;
@@ -58,7 +49,7 @@ public abstract class BeanRequest {
    */
   public void commitTransIfRequired() {
     if (createdTransaction) {
-      ebeanServer.commitTransaction();
+      server.commitTransaction();
     }
   }
 
@@ -68,7 +59,7 @@ public abstract class BeanRequest {
   public void rollbackTransIfRequired() {
     if (createdTransaction) {
       try {
-        ebeanServer.endTransaction();
+        server.endTransaction();
       } catch (Exception e) {
         // Just log this and carry on. A previous exception has been
         // thrown and if this rollback throws exception it likely means
@@ -83,7 +74,7 @@ public abstract class BeanRequest {
    */
   public void clearTransIfRequired() {
     if (createdTransaction) {
-      ebeanServer.clearServerTransaction();
+      server.clearServerTransaction();
     }
   }
 
@@ -92,45 +83,45 @@ public abstract class BeanRequest {
    * BeanController and BeanFinder.
    */
   public EbeanServer getEbeanServer() {
-    return ebeanServer;
+    return server;
   }
 
-  public SpiEbeanServer getServer() {
-    return ebeanServer;
+  public SpiEbeanServer server() {
+    return server;
   }
 
   /**
    * Return the Transaction associated with this request.
    */
-  public SpiTransaction getTransaction() {
+  public SpiTransaction transaction() {
     return transaction;
   }
 
   /**
    * Set the transaction to use for this request.
    */
-  public void setTransaction(SpiTransaction transaction) {
+  public void transaction(SpiTransaction transaction) {
     this.transaction = transaction;
   }
 
   /**
    * Return true if SQL should be logged for this transaction.
    */
-  public boolean isLogSql() {
+  public boolean logSql() {
     return transaction.isLogSql();
   }
 
   /**
    * Return true if SUMMARY information should be logged for this transaction.
    */
-  public boolean isLogSummary() {
+  public boolean logSummary() {
     return transaction.isLogSummary();
   }
 
   /**
    * Return the DataTimeZone to use.
    */
-  public DataTimeZone getDataTimeZone() {
-    return ebeanServer.getDataTimeZone();
+  public DataTimeZone dataTimeZone() {
+    return server.getDataTimeZone();
   }
 }

ebean-core/src/main/java/io/ebeaninternal/server/core/DScriptRunner.java

@@ -26,7 +26,7 @@ final class DScriptRunner implements ScriptRunner {
 
   DScriptRunner(SpiEbeanServer server) {
     this.server = server;
-    this.platformName = this.server.getDatabasePlatform().getPlatform().base().name();
+    this.platformName = this.server.platform().base().name();
   }
 
   @Override
@@ -102,7 +102,7 @@ final class DScriptRunner implements ScriptRunner {
 
   private Connection obtainConnection() {
     try {
-      return server.getDataSource().getConnection();
+      return server.dataSource().getConnection();
     } catch (SQLException e) {
       throw new PersistenceException("Failed to obtain connection to run script", e);
     }

ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultBeanLoader.java

@@ -35,19 +35,16 @@ final class DefaultBeanLoader {
 
   DefaultBeanLoader(DefaultServer server) {
     this.server = server;
-    this.onIterateUseExtraTxn = server.getDatabasePlatform().useExtraTransactionOnIterateSecondaryQueries();
+    this.onIterateUseExtraTxn = server.databasePlatform().useExtraTransactionOnIterateSecondaryQueries();
   }
 
   void loadMany(LoadManyRequest loadRequest) {
-    SpiQuery<?> query = loadRequest.createQuery(server);
-    executeQuery(loadRequest, query);
+    executeQuery(loadRequest, loadRequest.createQuery(server));
     loadRequest.postLoad();
   }
 
   void loadMany(BeanCollection<?> bc, boolean onlyIds) {
-    EntityBean parentBean = bc.getOwnerBean();
-    String propertyName = bc.getPropertyName();
-    loadManyInternal(parentBean, propertyName, null, false, onlyIds);
+    loadManyInternal(bc.getOwnerBean(), bc.getPropertyName(), null, false, onlyIds);
   }
 
   void refreshMany(EntityBean parentBean, String propertyName) {
@@ -69,12 +66,10 @@ final class DefaultBeanLoader {
     }
 
     Object parentId = parentDesc.getId(parentBean);
-
     if (pc == null) {
       pc = new DefaultPersistenceContext();
       parentDesc.contextPut(pc, parentId, parentBean);
     }
-
     boolean useManyIdCache = beanCollection != null && parentDesc.isManyPropCaching() && many.isUseCache();
     if (useManyIdCache) {
       Boolean readOnly = null;
@@ -87,7 +82,6 @@ final class DefaultBeanLoader {
     }
 
     SpiQuery<?> query = server.createQuery(parentDesc.getBeanType());
-
     if (refresh) {
       // populate a new collection
       BeanCollection<?> emptyCollection = many.createEmpty(parentBean);
@@ -98,7 +92,6 @@ final class DefaultBeanLoader {
     }
 
     query.select(parentDesc.getIdBinder().getIdProperty());
-
     if (onlyIds) {
       query.fetch(many.getName(), many.getTargetIdProperty());
     } else {
@@ -109,11 +102,10 @@ final class DefaultBeanLoader {
     }
 
     query.where().idEq(parentId);
-    query.setUseCache(false);
+    query.setBeanCacheMode(CacheMode.OFF);
     query.setMode(Mode.LAZYLOAD_MANY);
     query.setLazyLoadManyPath(many.getName());
     query.setPersistenceContext(pc);
-
     if (ebi.isReadOnly()) {
       query.setReadOnly(true);
     }
@@ -134,7 +126,7 @@ final class DefaultBeanLoader {
    * Load a batch of beans for +query or +lazy loading.
    */
   void loadBean(LoadBeanRequest loadRequest) {
-    List<EntityBeanIntercept> batch = loadRequest.getBatch();
+    List<EntityBeanIntercept> batch = loadRequest.batch();
     if (batch.isEmpty()) {
       throw new RuntimeException("Nothing in batch?");
     }
@@ -145,12 +137,8 @@ final class DefaultBeanLoader {
       return;
     }
 
-    SpiQuery<?> query = server.createQuery(loadRequest.getBeanType());
+    SpiQuery<?> query = server.createQuery(loadRequest.beanType());
     loadRequest.configureQuery(query, idList);
-    if (loadRequest.isLoadedFromCache()) {
-      query.setBeanCacheMode(CacheMode.PUT);
-    }
-
     List<?> list = executeQuery(loadRequest, query);
     loadRequest.postLoad(list);
   }
@@ -168,7 +156,7 @@ final class DefaultBeanLoader {
         extraTxn.end();
       }
     } else {
-      return server.findList(query, loadRequest.getTransaction());
+      return server.findList(query, loadRequest.transaction());
     }
   }
 
@@ -192,8 +180,7 @@ final class DefaultBeanLoader {
     if (EntityType.EMBEDDED == desc.getEntityType()) {
       // lazy loading on an embedded bean property
       EntityBean embeddedOwner = (EntityBean) ebi.getEmbeddedOwner();
-      int ownerIndex = ebi.getEmbeddedOwnerIndex();
-      refreshBeanInternal(embeddedOwner, mode, ownerIndex);
+      refreshBeanInternal(embeddedOwner, mode, ebi.getEmbeddedOwnerIndex());
     }
 
     Object id = desc.getId(bean);
@@ -235,7 +222,7 @@ final class DefaultBeanLoader {
     query.setId(id);
     if (embeddedOwnerIndex > -1 || mode == Mode.REFRESH_BEAN) {
       // make sure the query doesn't use the cache
-      query.setUseCache(false);
+      query.setBeanCacheMode(CacheMode.OFF);
     }
     if (ebi.isReadOnly()) {
       query.setReadOnly(true);
@@ -249,8 +236,7 @@ final class DefaultBeanLoader {
 
     Object dbBean = query.findOne();
     if (dbBean == null) {
-      String msg = "Bean not found during lazy load or refresh." + " id[" + id + "] type[" + desc.getBeanType() + "]";
-      throw new EntityNotFoundException(msg);
+      throw new EntityNotFoundException("Bean not found during lazy load or refresh." + " id[" + id + "] type[" + desc.getBeanType() + "]");
     }
     desc.resetManyProperties(dbBean);
   }

ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultCallableSql.java

@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.core;
 
 import io.ebean.CallableSql;
-import io.ebean.EbeanServer;
+import io.ebean.Database;
 import io.ebeaninternal.api.BindParams;
 import io.ebeaninternal.api.BindParams.Param;
 import io.ebeaninternal.api.SpiCallableSql;
@@ -9,39 +9,23 @@ import io.ebeaninternal.api.TransactionEventTable;
 
 import java.io.Serializable;
 import java.sql.CallableStatement;
-import java.sql.SQLException;
 
-
-public final class DefaultCallableSql implements Serializable, SpiCallableSql {
+final class DefaultCallableSql implements Serializable, SpiCallableSql {
 
   private static final long serialVersionUID = 8984272253185424701L;
 
-  private transient final EbeanServer server;
-
-  /**
-   * The callable sql.
-   */
-  private String sql;
-
-  /**
-   * To display in the transaction log to help identify the procedure.
-   */
-  private String label;
-
-  private int timeout;
-
   /**
    * Holds the table modification information. On commit this information is
    * used to manage the cache etc.
    */
   private final TransactionEventTable transactionEvent = new TransactionEventTable();
-
   private final BindParams bindParameters = new BindParams();
+  private transient final Database server;
+  private String sql;
+  private String label;
+  private int timeout;
 
-  /**
-   * Create with callable sql.
-   */
-  public DefaultCallableSql(EbeanServer server, String sql) {
+  DefaultCallableSql(Database server, String sql) {
     this.server = server;
     this.sql = sql;
   }
@@ -108,13 +92,12 @@ public final class DefaultCallableSql implements Serializable, SpiCallableSql {
   }
 
   @Override
-  public boolean executeOverride(CallableStatement cstmt) throws SQLException {
+  public boolean executeOverride(CallableStatement statement) {
     return false;
   }
 
   @Override
   public CallableSql addModification(String tableName, boolean inserts, boolean updates, boolean deletes) {
-
     transactionEvent.add(tableName, inserts, updates, deletes);
     return this;
   }
@@ -122,7 +105,7 @@ public final class DefaultCallableSql implements Serializable, SpiCallableSql {
   /**
    * Return the TransactionEvent which holds the table modification
    * information for this CallableSql. This information is merged into the
-   * transaction after the transaction is commited.
+   * transaction after the transaction is committed.
    */
   @Override
   public TransactionEventTable getTransactionEventTable() {

ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultQueryPlanListener.java

@@ -15,7 +15,7 @@ final class DefaultQueryPlanListener implements QueryPlanListener {
   @Override
   public void process(QueryPlanCapture capture) {
     // better to log this in JSON form?
-    String dbName = capture.getDatabase().getName();
+    String dbName = capture.getDatabase().name();
     for (MetaQueryPlan plan : capture.getPlans()) {
       log.info("queryPlan  db:{} label:{} queryTimeMicros:{} loc:{} sql:{} bind:{} plan:{}",
         dbName, plan.label(), plan.queryTimeMicros(), plan.profileLocation(),

ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultServer.java

@@ -305,12 +305,12 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public DatabaseConfig getServerConfig() {
+  public DatabaseConfig config() {
     return config;
   }
 
   @Override
-  public DatabasePlatform getDatabasePlatform() {
+  public DatabasePlatform databasePlatform() {
     return databasePlatform;
   }
 
@@ -325,42 +325,42 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public MetaInfoManager getMetaInfoManager() {
+  public MetaInfoManager metaInfo() {
     return metaInfoManager;
   }
 
   @Override
-  public Platform getPlatform() {
+  public Platform platform() {
     return databasePlatform.getPlatform();
   }
 
   @Override
-  public SpiServer getPluginApi() {
+  public SpiServer pluginApi() {
     return this;
   }
 
   @Override
-  public BackgroundExecutor getBackgroundExecutor() {
+  public BackgroundExecutor backgroundExecutor() {
     return backgroundExecutor;
   }
 
   @Override
-  public ExpressionFactory getExpressionFactory() {
+  public ExpressionFactory expressionFactory() {
     return expressionFactory;
   }
 
   @Override
-  public AutoTune getAutoTune() {
+  public AutoTune autoTune() {
     return autoTuneService;
   }
 
   @Override
-  public DataSource getDataSource() {
+  public DataSource dataSource() {
     return transactionManager.getDataSource();
   }
 
   @Override
-  public DataSource getReadOnlyDataSource() {
+  public DataSource readOnlyDataSource() {
     return transactionManager.getReadOnlyDataSource();
   }
 
@@ -381,7 +381,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     if (encryptKeyManager != null) {
       encryptKeyManager.initialise();
     }
-    serverCacheManager.setEnabledRegions(config.getEnabledL2Regions());
+    serverCacheManager.enabledRegions(config.getEnabledL2Regions());
   }
 
   /**
@@ -499,7 +499,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Return the server name.
    */
   @Override
-  public String getName() {
+  public String name() {
     return serverName;
   }
 
@@ -519,7 +519,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public BeanState getBeanState(Object bean) {
+  public BeanState beanState(Object bean) {
     if (bean instanceof EntityBean) {
       return new DefaultBeanState((EntityBean) bean);
     }
@@ -538,7 +538,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public ServerCacheManager getServerCacheManager() {
+  public ServerCacheManager cacheManager() {
     return serverCacheManager;
   }
 
@@ -635,7 +635,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public void truncate(String... tables) {
-    try (Connection connection = getDataSource().getConnection()) {
+    try (Connection connection = dataSource().getConnection()) {
       for (String table : tables) {
         executeSql(connection, databasePlatform.truncateStatement(table));
       }
@@ -687,7 +687,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    */
   @Override
   @SuppressWarnings({"unchecked", "rawtypes"})
-  public <T> T getReference(Class<T> type, Object id) {
+  public <T> T reference(Class<T> type, Object id) {
     if (id == null) {
       throw new NullPointerException("The id is null");
     }
@@ -1227,7 +1227,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     request.resetBeanCacheAutoMode(false);
     if ((t == null || !t.isSkipCache()) && request.getFromBeanCache()) {
       // hit bean cache and got all results from cache
-      return request.getBeanCacheHitsAsMap();
+      return request.beanCacheHitsAsMap();
     }
     Object result = request.getFromQueryCache();
     if (result != null) {
@@ -1312,7 +1312,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     SpiOrmQueryRequest<?> request = createQueryRequest(Type.ID_LIST, query, t);
     Object result = request.getFromQueryCache();
     if (result != null) {
-      if (Boolean.FALSE.equals(request.getQuery().isReadOnly())) {
+      if (Boolean.FALSE.equals(request.query().isReadOnly())) {
         return new CopyOnFirstWriteList<>((List<A>) result);
       } else {
         return (List<A>) result;
@@ -1341,7 +1341,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
         if (ids.isEmpty()) {
           return 0;
         } else {
-          return persister.deleteByIds(request.getBeanDescriptor(), ids, request.getTransaction(), false);
+          return persister.deleteByIds(request.descriptor(), ids, request.transaction(), false);
         }
       }
     } finally {
@@ -1504,7 +1504,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     request.resetBeanCacheAutoMode(findOne);
     if ((t == null || !t.isSkipCache()) && request.getFromBeanCache()) {
       // hit bean cache and got all results from cache
-      return request.getBeanCacheHits();
+      return request.beanCacheHits();
     }
     request.prepareQuery();
     Object result = request.getFromQueryCache();
@@ -2079,7 +2079,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public Object setBeanId(Object bean, Object id) {
+  public Object beanId(Object bean, Object id) {
     EntityBean eb = checkEntityBean(bean);
     BeanDescriptor<?> desc = getBeanDescriptor(bean.getClass());
     if (desc == null) {
@@ -2089,7 +2089,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public Object getBeanId(Object bean) {
+  public Object beanId(Object bean) {
     EntityBean eb = checkEntityBean(bean);
     BeanDescriptor<?> desc = getBeanDescriptor(bean.getClass());
     if (desc == null) {
@@ -2118,7 +2118,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Return all the SPI BeanTypes.
    */
   @Override
-  public List<? extends BeanType<?>> getBeanTypes() {
+  public List<? extends BeanType<?>> beanTypes() {
     return getBeanDescriptors();
   }
 
@@ -2126,12 +2126,12 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Return the SPI bean types mapped to the given table.
    */
   @Override
-  public List<? extends BeanType<?>> getBeanTypes(String tableName) {
+  public List<? extends BeanType<?>> beanTypes(String tableName) {
     return beanDescriptorManager.getBeanTypes(tableName);
   }
 
   @Override
-  public BeanType<?> getBeanTypeForQueueId(String queueId) {
+  public BeanType<?> beanTypeForQueueId(String queueId) {
     return getBeanDescriptorByQueueId(queueId);
   }
 
@@ -2144,7 +2144,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Return the SPI bean types for the given bean class.
    */
   @Override
-  public <T> BeanType<T> getBeanType(Class<T> beanType) {
+  public <T> BeanType<T> beanType(Class<T> beanType) {
     return getBeanDescriptor(beanType);
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/core/DefaultSqlUpdate.java

@@ -1,6 +1,6 @@
 package io.ebeaninternal.server.core;
 
-import io.ebean.Ebean;
+import io.ebean.DB;
 import io.ebean.SqlUpdate;
 import io.ebean.Update;
 import io.ebeaninternal.api.BindParams;
@@ -143,7 +143,7 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
       return server.execute(this);
     } else {
       // Hopefully this doesn't catch anyone out...
-      return Ebean.execute(this);
+      return DB.getDefault().execute(this);
     }
   }
 
@@ -167,7 +167,6 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
     return server.executeBatch(this, transaction);
   }
 
-
   @Override
   public void addBatch() {
     if (server == null) {
@@ -179,7 +178,6 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
         throw new IllegalStateException("No current transaction? Must have a transaction to use addBatch()");
       }
     }
-
     batched = true;
     server.addBatch(this, transaction);
   }
@@ -287,8 +285,7 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
     return this;
   }
 
-  private SqlUpdate setParamWithBindExpansion(int position, Collection values, String bindLiteral) {
-
+  private SqlUpdate setParamWithBindExpansion(int position, Collection<?> values, String bindLiteral) {
     StringBuilder sqlExpand = new StringBuilder(values.size() * 2);
     position = position + bindExpansion;
     int offset = 0;
@@ -310,10 +307,9 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
       String bindLiteral = "?" + position;
       int pos = baseSql.indexOf(bindLiteral);
       if (pos > -1) {
-        return setParamWithBindExpansion(position, (Collection) value, bindLiteral);
+        return setParamWithBindExpansion(position, (Collection<?>) value, bindLiteral);
       }
     }
-
     bindParams.setParameter(bindExpansion + position, value);
     return this;
   }

ebean-core/src/main/java/io/ebeaninternal/server/core/DtoQueryRequest.java

@@ -114,6 +114,7 @@ public final class DtoQueryRequest<T> extends AbstractSqlQueryRequest {
     return queryEngine.findList(this);
   }
 
+  @Override
   public boolean next() throws SQLException {
     query.checkCancelled();
     return dataReader.next();

ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetrics.java

@@ -73,8 +73,8 @@ final class DumpMetrics {
 
   void dump() {
 
-    out("-- Dumping metrics for " + server.getName() + " -- ");
-    ServerMetrics serverMetrics = server.getMetaInfoManager().collectMetrics();
+    out("-- Dumping metrics for " + server.name() + " -- ");
+    ServerMetrics serverMetrics = server.metaInfo().collectMetrics();
 
     for (MetaTimedMetric metric : serverMetrics.timedMetrics()) {
       log(metric);

ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsData.java

@@ -24,7 +24,7 @@ final class DumpMetricsData {
   }
 
   List<MetricData> data() {
-    collect(database.getMetaInfoManager().collectMetrics());
+    collect(database.metaInfo().collectMetrics());
     return list;
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/core/DumpMetricsJson.java

@@ -66,14 +66,14 @@ final class DumpMetricsJson implements ServerMetricsAsJson {
   @Override
   public String json() {
     writer = new StringWriter();
-    collect(database.getMetaInfoManager().collectMetrics());
+    collect(database.metaInfo().collectMetrics());
     return writer.toString();
   }
 
   @Override
   public void write(Appendable buffer) {
     writer = buffer;
-    collect(database.getMetaInfoManager().collectMetrics());
+    collect(database.metaInfo().collectMetrics());
   }
 
   private void collect(ServerMetrics serverMetrics) {
@@ -112,7 +112,7 @@ final class DumpMetricsJson implements ServerMetricsAsJson {
     if (withHeader) {
       objStart();
       key("db");
-      val(database.getName());
+      val(database.name());
       key("metrics");
       listStart();
     }

ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java

@@ -60,38 +60,21 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   private static final Logger log = LoggerFactory.getLogger(OrmQueryRequest.class);
 
   private final BeanDescriptor<T> beanDescriptor;
-
   private final OrmQueryEngine queryEngine;
-
   private final SpiQuery<T> query;
-
   private final BeanFindController finder;
-
   private final Boolean readOnly;
-
   private LoadContext loadContext;
-
   private PersistenceContext persistenceContext;
-
   private JsonReadOptions jsonRead;
-
   private HashQuery cacheKey;
-
   private CQueryPlanKey queryPlanKey;
-
   private SpiQuerySecondary secondaryQueries;
-
   private List<T> cacheBeans;
-
   private BeanPropertyAssocMany<?> manyProperty;
-
   private boolean inlineCountDistinct;
-
   private Set<String> dependentTables;
 
-  /**
-   * Create the InternalQueryRequest.
-   */
   public OrmQueryRequest(SpiEbeanServer server, OrmQueryEngine queryEngine, SpiQuery<T> query, SpiTransaction t) {
     super(server, t);
     this.beanDescriptor = query.getBeanDescriptor();
@@ -145,8 +128,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Return the database platform like clause.
    */
   @Override
-  public String getDBLikeClause(boolean rawLikeExpression) {
-    return ebeanServer.getDatabasePlatform().getLikeClause(rawLikeExpression);
+  public String dbLikeClause(boolean rawLikeExpression) {
+    return server.databasePlatform().getLikeClause(rawLikeExpression);
   }
 
   /**
@@ -154,7 +137,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    */
   @Override
   public String escapeLikeString(String value) {
-    return ebeanServer.getDatabasePlatform().escapeLikeString(value);
+    return server.databasePlatform().escapeLikeString(value);
   }
 
   @Override
@@ -171,9 +154,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * <p>
    * If -1 is returned then NO secondary queries are registered and simple
    * iteration is fine.
-   * </p>
    */
-  public int getSecondaryQueriesMinBatchSize() {
+  public int secondaryQueriesMinBatchSize() {
     return loadContext.getSecondaryQueriesMinBatchSize();
   }
 
@@ -188,14 +170,14 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Return the BeanDescriptor for the associated bean.
    */
   @Override
-  public BeanDescriptor<T> getBeanDescriptor() {
+  public BeanDescriptor<T> descriptor() {
     return beanDescriptor;
   }
 
   /**
    * Return the graph context for this query.
    */
-  public LoadContext getGraphContext() {
+  public LoadContext loadContext() {
     return loadContext;
   }
 
@@ -244,7 +226,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the PersistenceContext used for this request.
    */
-  public PersistenceContext getPersistenceContext() {
+  public PersistenceContext persistenceContext() {
     return persistenceContext;
   }
 
@@ -271,15 +253,15 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
     if (transaction == null) {
       if (query.getType().isUpdate()) {
         // bulk update or delete query
-        transaction = ebeanServer.beginServerTransaction();
+        transaction = server.beginServerTransaction();
       } else {
         // create an implicit transaction to execute this query
         // potentially using read-only DataSource with autoCommit
-        transaction = ebeanServer.createReadOnlyTransaction(query.getTenantId());
+        transaction = server.createReadOnlyTransaction(query.getTenantId());
       }
       createdTransaction = true;
     }
-    persistenceContext = getPersistenceContext(query, transaction);
+    persistenceContext = persistenceContext(query, transaction);
     loadContext = new DLoadContext(this, secondaryQueries);
   }
 
@@ -305,7 +287,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    */
   @Override
   public JsonReadOptions createJsonReadOptions() {
-    persistenceContext = getPersistenceContext(query, transaction);
+    persistenceContext = persistenceContext(query, transaction);
     if (query.getPersistenceContext() == null) {
       query.setPersistenceContext(persistenceContext);
     }
@@ -336,14 +318,14 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Get the TransactionContext either explicitly set on the query or
    * transaction scoped.
    */
-  private PersistenceContext getPersistenceContext(SpiQuery<?> query, SpiTransaction t) {
+  private PersistenceContext persistenceContext(SpiQuery<?> query, SpiTransaction t) {
     // check if there is already a persistence context set which is the case
     // when lazy loading or query joins are executed
     PersistenceContext ctx = query.getPersistenceContext();
     if (ctx != null) return ctx;
 
     // determine the scope (from the query and then server)
-    PersistenceContextScope scope = ebeanServer.getPersistenceContextScope(query);
+    PersistenceContextScope scope = server.getPersistenceContextScope(query);
     if (scope == PersistenceContextScope.QUERY || t == null) {
       return new DefaultPersistenceContext();
     }
@@ -365,7 +347,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
       transaction.commit();
       if (query.getType().isUpdate()) {
         // for implicit update/delete queries clear the thread local
-        ebeanServer.clearServerTransaction();
+        server.clearServerTransaction();
       }
     }
   }
@@ -504,12 +486,12 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return a bean specific finder if one has been set.
    */
-  public BeanFindController getBeanFinder() {
+  public BeanFindController finder() {
     return finder;
   }
 
   @Override
-  public SpiQuery<T> getQuery() {
+  public SpiQuery<T> query() {
     return query;
   }
 
@@ -524,7 +506,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the many property that is fetched in the query or null if there is not one.
    */
-  public BeanPropertyAssocMany<?> getManyProperty() {
+  public BeanPropertyAssocMany<?> manyProperty() {
     return manyProperty;
   }
 
@@ -532,7 +514,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Return a queryPlan for the current query if one exists. Returns null if no
    * query plan for this query exists.
    */
-  public CQueryPlan getQueryPlan() {
+  public CQueryPlan queryPlan() {
     return beanDescriptor.getQueryPlan(queryPlanKey);
   }
 
@@ -542,9 +524,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * This identifies the query plan for a given bean type. It effectively
    * matches a SQL statement with ? bind variables. A query plan can be reused
    * with just the bind variables changing.
-   * </p>
    */
-  public CQueryPlanKey getQueryPlanKey() {
+  public CQueryPlanKey queryPlanKey() {
     return queryPlanKey;
   }
 
@@ -608,7 +589,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   }
 
   @Override
-  public List<T> getBeanCacheHits() {
+  public List<T> beanCacheHits() {
     OrderBy<T> orderBy = query.getOrderBy();
     if (orderBy != null) {
       beanDescriptor.sort(cacheBeans, orderBy.toStringFormat());
@@ -617,7 +598,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   }
 
   @Override
-  public <K> Map<K, T> getBeanCacheHitsAsMap() {
+  public <K> Map<K, T> beanCacheHitsAsMap() {
     OrderBy<T> orderBy = query.getOrderBy();
     if (orderBy != null) {
       beanDescriptor.sort(cacheBeans, orderBy.toStringFormat());
@@ -665,7 +646,6 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
     if (!beanDescriptor.isNaturalKeyCaching()) {
       return false;
     }
-
     NaturalKeyQueryData<T> data = query.naturalKey();
     if (data != null) {
       NaturalKeySet naturalKeySet = data.buildKeys();
@@ -688,18 +668,16 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   public Object getFromQueryCache() {
     if (query.getUseQueryCache() == CacheMode.OFF
       || (transaction != null && transaction.isSkipCache())
-      || ebeanServer.isDisableL2Cache()) {
+      || server.isDisableL2Cache()) {
       return null;
     } else {
       cacheKey = query.queryHash();
     }
-
     if (!query.getUseQueryCache().isGet()) {
       return null;
     }
 
     Object cached = beanDescriptor.queryCacheGet(cacheKey);
-
     if (cached != null && isAuditReads() && readAuditQueryType()) {
       if (cached instanceof BeanCollection) {
         // raw sql can't use L2 cache so normal queries only in here
@@ -711,7 +689,6 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
         beanDescriptor.readAuditMany(queryPlanKey.getPartialKey(), "l2-query-cache", ids);
       }
     }
-
     if (Boolean.FALSE.equals(query.isReadOnly())) {
       // return shallow copies if readonly is explicitly set to false
       if (cached instanceof BeanCollection) {
@@ -750,7 +727,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   }
 
   /**
-   * Set an Query object that owns the PreparedStatement that can be cancelled.
+   * Set a Query object that owns the PreparedStatement that can be cancelled.
    */
   public void setCancelableQuery(CancelableQuery cancelableQuery) {
     query.setCancelableQuery(cancelableQuery);
@@ -766,16 +743,15 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the batch size for lazy loading on this bean query request.
    */
-  public int getLazyLoadBatchSize() {
+  public int lazyLoadBatchSize() {
     int batchSize = query.getLazyLoadBatchSize();
-    return (batchSize > 0) ? batchSize : ebeanServer.getLazyLoadBatchSize();
+    return (batchSize > 0) ? batchSize : server.getLazyLoadBatchSize();
   }
 
   /**
    * Return true if read auditing is on for this query request.
    * <p>
    * This means that read audit is on for this bean type and that query has not explicitly disabled it.
-   * </p>
    */
   public boolean isAuditReads() {
     return beanDescriptor.isReadAuditing() && !query.isDisableReadAudit();
@@ -784,7 +760,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the base table alias for this query.
    */
-  public String getBaseTableAlias() {
+  public String baseTableAlias() {
     return query.getAlias(beanDescriptor.getBaseTableAlias());
   }
 
@@ -798,7 +774,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Return the tenantId associated with this request.
    */
-  public Object getTenantId() {
+  public Object tenantId() {
     return (transaction == null) ? null : transaction.getTenantId();
   }
 
@@ -806,7 +782,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Check for slow query event.
    */
   public void slowQueryCheck(long executionTimeMicros, int rowCount) {
-    ebeanServer.slowQueryCheck(executionTimeMicros, rowCount, query);
+    server.slowQueryCheck(executionTimeMicros, rowCount, query);
   }
 
   public void setInlineCountDistinct() {
@@ -830,6 +806,6 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
    * Return true if no MaxRows or use LIMIT in SQL update.
    */
   public boolean isInlineSqlUpdateLimit() {
-    return query.getMaxRows() < 1 || ebeanServer.getDatabasePlatform().isInlineSqlUpdateLimit();
+    return query.getMaxRows() < 1 || server.databasePlatform().isInlineSqlUpdateLimit();
   }
 }

ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequest.java

@@ -31,17 +31,10 @@ public abstract class PersistRequest extends BeanRequest implements BatchPostExe
     }
   }
 
-  boolean persistCascade;
-
-  /**
-   * One of INSERT, UPDATE, DELETE, UPDATESQL or CALLABLESQL.
-   */
   protected Type type;
-
+  boolean persistCascade;
   final PersistExecute persistExecute;
-
   protected String label;
-
   protected long startNanos;
 
   PersistRequest(SpiEbeanServer server, SpiTransaction t, PersistExecute persistExecute) {
@@ -95,12 +88,12 @@ public abstract class PersistRequest extends BeanRequest implements BatchPostExe
   }
 
   @Override
-  public boolean isLogSql() {
+  public boolean logSql() {
     return transaction.isLogSql();
   }
 
   @Override
-  public boolean isLogSummary() {
+  public boolean logSummary() {
     return transaction.isLogSummary();
   }
 
@@ -149,10 +142,9 @@ public abstract class PersistRequest extends BeanRequest implements BatchPostExe
   }
 
   /**
-   * Return the type of this request. One of INSERT, UPDATE, DELETE, UPDATESQL
-   * or CALLABLESQL.
+   * Return the type of this request. One of INSERT, UPDATE, DELETE, UPDATESQL or CALLABLESQL.
    */
-  public Type getType() {
+  public Type type() {
     return type;
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestBean.java

@@ -50,142 +50,94 @@ import java.util.Set;
 public final class PersistRequestBean<T> extends PersistRequest implements BeanPersistRequest<T>, DocStoreUpdate, PreGetterCallback, SpiProfileTransactionEvent {
 
   private final BeanManager<T> beanManager;
-
   private final BeanDescriptor<T> beanDescriptor;
-
   private final BeanPersistListener beanPersistListener;
-
-  /**
-   * For per post insert update delete control.
-   */
   private final BeanPersistController controller;
-
-  /**
-   * The bean being persisted.
-   */
   private final T bean;
-
   private final EntityBean entityBean;
-
-  /**
-   * The associated intercept.
-   */
   private final EntityBeanIntercept intercept;
-
   /**
    * The parent bean for unidirectional save.
    */
   private final Object parentBean;
-
   private final boolean dirty;
-
   private final boolean publish;
-
   private int flags;
-
   private boolean saveRecurse;
-
   private DocStoreMode docStoreMode;
-
   private final ConcurrencyMode concurrencyMode;
-
   /**
    * The unique id used for logging summary.
    */
   private Object idValue;
-
   /**
    * Hash value used to handle cascade delete both ways in a relationship.
    */
   private Integer beanHash;
-
-  /**
-   * Flag set if this is a stateless update.
-   */
   private boolean statelessUpdate;
-
   private boolean notifyCache;
-
   /**
    * Flag used to detect when only many properties where updated via a cascade. Used to ensure
    * appropriate caches are updated in that case.
    */
   private boolean updatedManysOnly;
-
   /**
    * Element collection change as part of bean cache.
    */
   private Map<String, Object> collectionChanges;
-
   /**
    * Set true when the request includes cascade save to a many.
    */
   private boolean updatedMany;
-
   /**
    * Many properties that were cascade saved (and hence might need caches updated later).
    */
   private List<BeanPropertyAssocMany<?>> updatedManys;
-
   /**
    * Need to get and store the updated properties because the persist listener is notified
    * later on a different thread and the bean has been reset at that point.
    */
   private Set<String> updatedProperties;
-
   /**
    * Flags indicating the dirty properties on the bean.
    */
   private boolean[] dirtyProperties;
-
   /**
    * Imported OneToOne orphan that needs to be deleted.
    */
   private EntityBean orphanBean;
-
   /**
    * Flag set when request is added to JDBC batch.
    */
   private boolean batched;
-
   /**
    * Flag set when batchOnCascade to avoid using batch on the top bean.
    */
   private boolean skipBatchForTopLevel;
-
   /**
    * Flag set when batch mode is turned on for a persist cascade.
    */
   private boolean batchOnCascadeSet;
-
   /**
    * Set for updates to determine if all loaded properties are included in the update.
    */
   private boolean requestUpdateAllLoadedProps;
-
   private long version;
-
   private long now;
-
   private long profileOffset;
-
   /**
    * Flag set when request is added to JDBC batch registered as a "getter callback" to automatically flush batch.
    */
   private boolean getterCallback;
-
   private boolean pendingPostUpdateNotify;
-
   /**
    * Set to true when post execute has occurred (so includes batch flush).
    */
   private boolean postExecute;
-
   /**
    * Set to true after many properties have been persisted (so includes element collections).
    */
   private boolean complete;
-
   /**
    * Many to many intersection table changes that are held for later batch processing.
    */
@@ -424,12 +376,12 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   @Override
-  public Set<String> getLoadedProperties() {
+  public Set<String> loadedProperties() {
     return intercept.getLoadedPropertyNames();
   }
 
   @Override
-  public Set<String> getUpdatedProperties() {
+  public Set<String> updatedProperties() {
     return intercept.getDirtyPropertyNames();
   }
 
@@ -437,7 +389,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Return the dirty properties on this request.
    */
   @Override
-  public boolean[] getDirtyProperties() {
+  public boolean[] dirtyProperties() {
     return dirtyProperties;
   }
 
@@ -462,7 +414,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   @Override
-  public Map<String, ValuePair> getUpdatedValues() {
+  public Map<String, ValuePair> updatedValues() {
     return intercept.getDirtyValues();
   }
 
@@ -582,8 +534,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   /**
-   * Return true if this bean has been already been persisted (inserted or updated) in this
-   * transaction.
+   * Return true if this bean has been already been persisted (inserted or updated) in this transaction.
    */
   public boolean isRegisteredBean() {
     return transaction.isRegisteredBean(bean);
@@ -600,7 +551,6 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * The hash used to register the bean with the transaction.
    * <p>
    * Takes into account the class type and id value.
-   * </p>
    */
   private Integer getBeanHash() {
     if (beanHash == null) {
@@ -631,7 +581,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the BeanDescriptor for the associated bean.
    */
-  public BeanDescriptor<T> getBeanDescriptor() {
+  public BeanDescriptor<T> descriptor() {
     return beanDescriptor;
   }
 
@@ -656,7 +606,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the concurrency mode used for this persist.
    */
-  public ConcurrencyMode getConcurrencyMode() {
+  public ConcurrencyMode concurrencyMode() {
     return concurrencyMode;
   }
 
@@ -667,7 +617,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Used to determine common persist requests for queueing and statement batching.
    * </p>
    */
-  public String getFullName() {
+  public String fullName() {
     return beanDescriptor.getFullName();
   }
 
@@ -675,18 +625,18 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Return the bean associated with this request.
    */
   @Override
-  public T getBean() {
+  public T bean() {
     return bean;
   }
 
-  public EntityBean getEntityBean() {
+  public EntityBean entityBean() {
     return entityBean;
   }
 
   /**
    * Return the Id value for the bean.
    */
-  public Object getBeanId() {
+  public Object beanId() {
     return beanDescriptor.getId(entityBean);
   }
 
@@ -694,7 +644,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Create and return a new reference bean matching this beans Id value.
    */
   public T createReference() {
-    return beanDescriptor.createRef(getBeanId(), null);
+    return beanDescriptor.createRef(beanId(), null);
   }
 
   /**
@@ -739,14 +689,14 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the parent bean for cascading save with unidirectional relationship.
    */
-  public Object getParentBean() {
+  public Object parentBean() {
     return parentBean;
   }
 
   /**
    * Return the intercept if there is one.
    */
-  public EntityBeanIntercept getEntityBeanIntercept() {
+  public EntityBeanIntercept intercept() {
     return intercept;
   }
 
@@ -783,7 +733,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       case UPDATE:
         if (beanPersistListener != null) {
           // store the updated properties for sending later
-          updatedProperties = getUpdatedProperties();
+          updatedProperties = updatedProperties();
         }
         executeUpdate();
         return -1;
@@ -854,7 +804,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Check for optimistic concurrency exception.
    */
   @Override
-  public final void checkRowCount(int rowCount) {
+  public void checkRowCount(int rowCount) {
     if (rowCount != 1 && rowCount != Statement.SUCCESS_NO_INFO) {
       if (ConcurrencyMode.VERSION == concurrencyMode) {
         throw new OptimisticLockException("Data has changed. updated row count " + rowCount, null, bean);
@@ -937,8 +887,8 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     }
     addPostCommitListeners();
     notifyCacheOnPostExecute();
-    if (isLogSummary()) {
-      logSummary();
+    if (logSummary()) {
+      logSummaryMessage();
     }
   }
 
@@ -985,7 +935,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     }
   }
 
-  private void logSummary() {
+  private void logSummaryMessage() {
     String draft = (beanDescriptor.isDraftable() && !publish) ? " draft[true]" : "";
     String name = beanDescriptor.getName();
     switch (type) {
@@ -1031,7 +981,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Register the derived relationships to get executed later (on JDBC batch flush or commit).
    */
   public void deferredRelationship(EntityBean assocBean, ImportedId importedId, EntityBean bean) {
-    transaction.registerDeferred(new PersistDeferredRelationship(ebeanServer, beanDescriptor, assocBean, importedId, bean));
+    transaction.registerDeferred(new PersistDeferredRelationship(server, beanDescriptor, assocBean, importedId, bean));
   }
 
   private void postInsert() {
@@ -1074,7 +1024,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the list of updated many properties for L2 cache update (can be null).
    */
-  public List<BeanPropertyAssocMany<?>> getUpdatedManyForL2Cache() {
+  public List<BeanPropertyAssocMany<?>> updatedManyForL2Cache() {
     return updatedManys;
   }
 
@@ -1175,7 +1125,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       requestUpdateAllLoadedProps = txnUpdateAll;
     } else {
       // if using batch use the server default setting
-      requestUpdateAllLoadedProps = isBatchThisRequest() && ebeanServer.isUpdateAllPropertiesInBatch();
+      requestUpdateAllLoadedProps = isBatchThisRequest() && server.isUpdateAllPropertiesInBatch();
     }
     return requestUpdateAllLoadedProps;
   }
@@ -1183,7 +1133,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the flags set on this persist request.
    */
-  public int getFlags() {
+  public int flags() {
     return flags;
   }
 
@@ -1197,7 +1147,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the key for an update persist request.
    */
-  public String getUpdatePlanHash() {
+  public String updatePlanHash() {
     StringBuilder key;
     if (determineUpdateAllLoadedProperties()) {
       key = intercept.getLoadedPropertyKey();
@@ -1219,7 +1169,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the table to update depending if the request is a 'publish' one or normal.
    */
-  public String getUpdateTable() {
+  public String updateTable() {
     return publish ? beanDescriptor.getBaseTable() : beanDescriptor.getDraftTable();
   }
 
@@ -1240,7 +1190,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Return the version in long form (if set).
    */
-  public long getVersion() {
+  public long version() {
     return version;
   }
 
@@ -1313,7 +1263,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   public long now() {
     if (now == 0) {
-      now = ebeanServer.clockNow();
+      now = server.clockNow();
     }
     return now;
   }
@@ -1383,8 +1333,8 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
       String key = beanDescriptor.cacheKey(idValue);
       Map<String, Object> changes = new LinkedHashMap<>();
-      EntityBean bean = getEntityBean();
-      boolean[] dirtyProperties = getDirtyProperties();
+      EntityBean bean = entityBean();
+      boolean[] dirtyProperties = dirtyProperties();
       if (dirtyProperties != null) {
         for (int i = 0; i < dirtyProperties.length; i++) {
           if (dirtyProperties[i]) {
@@ -1405,7 +1355,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
         // add element collection update
         changes.putAll(collectionChanges);
       }
-      changeSet.addBeanUpdate(beanDescriptor, key, changes, updateNaturalKey, getVersion());
+      changeSet.addBeanUpdate(beanDescriptor, key, changes, updateNaturalKey, version());
     }
   }
 
@@ -1419,7 +1369,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     }
   }
 
-  public EntityBean getImportedOrphanForRemoval() {
+  public EntityBean importedOrphanForRemoval() {
     return orphanBean;
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestCallableSql.java

@@ -19,20 +19,15 @@ import java.util.List;
 public final class PersistRequestCallableSql extends PersistRequest {
 
   private final SpiCallableSql callableSql;
-
   private int rowCount;
-
   private String bindLog;
-
   private CallableStatement cstmt;
-
   private BindParams bindParam;
 
   /**
    * Create.
    */
   public PersistRequestCallableSql(SpiEbeanServer server, CallableSql cs, SpiTransaction t, PersistExecute persistExecute) {
-
     super(server, t, persistExecute, cs.getLabel());
     this.type = PersistRequest.Type.CALLABLESQL;
     this.callableSql = (SpiCallableSql) cs;
@@ -56,7 +51,7 @@ public final class PersistRequestCallableSql extends PersistRequest {
   /**
    * Return the CallableSql.
    */
-  public SpiCallableSql getCallableSql() {
+  public SpiCallableSql callableSql() {
     return callableSql;
   }
 
@@ -97,13 +92,11 @@ public final class PersistRequestCallableSql extends PersistRequest {
 
     // register table modifications with the transaction event
     TransactionEventTable tableEvents = callableSql.getTransactionEventTable();
-
     if (tableEvents != null && !tableEvents.isEmpty()) {
       transaction.getEvent().add(tableEvents);
     } else {
       transaction.markNotQueryOnly();
     }
-
   }
 
   /**
@@ -120,7 +113,6 @@ public final class PersistRequestCallableSql extends PersistRequest {
    * Execute the statement in normal non batch mode.
    */
   public int executeUpdate() throws SQLException {
-
     // check to see if the execution has been overridden
     // only works in non-batch mode
     if (callableSql.executeOverride(cstmt)) {
@@ -129,20 +121,15 @@ public final class PersistRequestCallableSql extends PersistRequest {
       // rowCount = callableSql.getRowCount();
       // return rowCount;
     }
-
     rowCount = cstmt.executeUpdate();
-
     // only read in non-batch mode
     readOutParams();
-
     return rowCount;
   }
 
   private void readOutParams() throws SQLException {
-
     List<Param> list = bindParam.positionedParameters();
     int pos = 0;
-
     for (Param param : list) {
       pos++;
       if (param.isOutParam()) {
@@ -151,5 +138,4 @@ public final class PersistRequestCallableSql extends PersistRequest {
       }
     }
   }
-
 }

ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestOrmUpdate.java

@@ -14,19 +14,11 @@ import io.ebeaninternal.server.persist.PersistExecute;
 public final class PersistRequestOrmUpdate extends PersistRequest {
 
   private final BeanDescriptor<?> beanDescriptor;
-
   private final SpiUpdate<?> ormUpdate;
-
   private int rowCount;
-
   private String bindLog;
 
-  /**
-   * Create.
-   */
-  public PersistRequestOrmUpdate(SpiEbeanServer server, BeanManager<?> mgr, SpiUpdate<?> ormUpdate,
-                                 SpiTransaction t, PersistExecute persistExecute) {
-
+  public PersistRequestOrmUpdate(SpiEbeanServer server, BeanManager<?> mgr, SpiUpdate<?> ormUpdate, SpiTransaction t, PersistExecute persistExecute) {
     super(server, t, persistExecute, ormUpdate.getLabel());
     this.beanDescriptor = mgr.getBeanDescriptor();
     this.ormUpdate = ormUpdate;
@@ -37,7 +29,7 @@ public final class PersistRequestOrmUpdate extends PersistRequest {
     profileBase(EVT_ORMUPDATE, offset, beanDescriptor.getName(), flushCount);
   }
 
-  public BeanDescriptor<?> getBeanDescriptor() {
+  public BeanDescriptor<?> descriptor() {
     return beanDescriptor;
   }
 
@@ -51,11 +43,10 @@ public final class PersistRequestOrmUpdate extends PersistRequest {
     return executeStatement();
   }
 
-
   /**
    * Return the UpdateSql.
    */
-  public SpiUpdate<?> getOrmUpdate() {
+  public SpiUpdate<?> ormUpdate() {
     return ormUpdate;
   }
 
@@ -91,14 +82,11 @@ public final class PersistRequestOrmUpdate extends PersistRequest {
     }
     OrmUpdateType ormUpdateType = ormUpdate.getOrmUpdateType();
     String tableName = ormUpdate.getBaseTable();
-
     if (transaction.isLogSummary()) {
       String m = ormUpdateType + " table[" + tableName + "] rows[" + rowCount + "] bind[" + bindLog + "]";
       transaction.logSummary(m);
     }
-
     if (ormUpdate.isNotifyCache()) {
-
       // add the modification info to the TransactionEvent
       // this is used to invalidate cached objects etc
       switch (ormUpdateType) {
@@ -116,5 +104,4 @@ public final class PersistRequestOrmUpdate extends PersistRequest {
       }
     }
   }
-
 }

ebean-core/src/main/java/io/ebeaninternal/server/core/PersistRequestUpdateSql.java

@@ -18,25 +18,17 @@ public final class PersistRequestUpdateSql extends PersistRequest {
   }
 
   private final SpiSqlUpdate updateSql;
-
   private int rowCount;
-
   private String bindLog;
-
   private SqlType sqlType;
-
   private String tableName;
-
   private boolean addBatch;
-
   private final boolean forceNoBatch;
-
   private boolean batchThisRequest;
   private boolean flushQueue;
 
   public PersistRequestUpdateSql(SpiEbeanServer server, SpiSqlUpdate sqlUpdate,
                                  SpiTransaction t, PersistExecute persistExecute, boolean forceNoBatch) {
-
     super(server, t, persistExecute, sqlUpdate.getLabel());
     this.type = Type.UPDATESQL;
     this.updateSql = sqlUpdate;
@@ -105,7 +97,7 @@ public final class PersistRequestUpdateSql extends PersistRequest {
   /**
    * Return the UpdateSql.
    */
-  public SpiSqlUpdate getUpdateSql() {
+  public SpiSqlUpdate updateSql() {
     return updateSql;
   }
 
@@ -145,6 +137,7 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     this.bindLog = bindLog;
   }
 
+  @Override
   public void startBind(boolean batchThisRequest) {
     this.batchThisRequest = batchThisRequest;
     super.startBind(batchThisRequest);
@@ -170,7 +163,6 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     if (transaction.isLogSql() && !batchThisRequest) {
       transaction.logSql(Str.add(TrimLogSql.trim(updateSql.getGeneratedSql()), "; -- bind(", bindLog, ") rows(", String.valueOf(rowCount), ")"));
     }
-
     if (updateSql.isAutoTableMod()) {
       // add the modification info to the TransactionEvent
       // this is used to invalidate cached objects etc

ebean-core/src/main/java/io/ebeaninternal/server/core/SpiOrmQueryRequest.java

@@ -22,12 +22,12 @@ public interface SpiOrmQueryRequest<T> extends BeanQueryRequest<T>, DocQueryRequ
    * Return the query.
    */
   @Override
-  SpiQuery<T> getQuery();
+  SpiQuery<T> query();
 
   /**
    * Return the associated BeanDescriptor.
    */
-  BeanDescriptor<T> getBeanDescriptor();
+  BeanDescriptor<T> descriptor();
 
   /**
    * Prepare the query for execution.
@@ -145,12 +145,12 @@ public interface SpiOrmQueryRequest<T> extends BeanQueryRequest<T>, DocQueryRequ
   /**
    * Return the bean cache hits (when all hits / no misses).
    */
-  List<T> getBeanCacheHits();
+  List<T> beanCacheHits();
 
   /**
    * Return the bean cache hits for findMap (when all hits / no misses).
    */
-  <K> Map<K,T> getBeanCacheHitsAsMap();
+  <K> Map<K,T> beanCacheHitsAsMap();
 
   /**
    * Reset Bean cache mode AUTO - require explicit setting for bean cache use with findList().
@@ -160,7 +160,7 @@ public interface SpiOrmQueryRequest<T> extends BeanQueryRequest<T>, DocQueryRequ
   /**
    * Return the Database platform like clause.
    */
-  String getDBLikeClause(boolean rawLikeExpression);
+  String dbLikeClause(boolean rawLikeExpression);
 
   /**
    * Escapes a string to use it as exact match in Like clause.

ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanCollectionHelpFactory.java

@@ -44,8 +44,8 @@ public final class BeanCollectionHelpFactory {
       return SET_HELP;
 
     } else if (manyType == SpiQuery.Type.MAP) {
-      BeanDescriptor<T> target = request.getBeanDescriptor();
-      ElPropertyValue elProperty = target.getElGetValue(request.getQuery().getMapKey());
+      BeanDescriptor<T> target = request.descriptor();
+      ElPropertyValue elProperty = target.getElGetValue(request.query().getMapKey());
       return new BeanMapQueryHelp<>(elProperty);
 
     } else {

ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java

@@ -777,7 +777,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return true if this request should be included in the change log.
    */
   public BeanChange getChangeLogBean(PersistRequestBean<T> request) {
-    switch (request.getType()) {
+    switch (request.type()) {
       case INSERT:
         return changeLogFilter.includeInsert(request) ? insertBeanChange(request) : null;
       case UPDATE:
@@ -786,7 +786,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
       case DELETE:
         return changeLogFilter.includeDelete(request) ? deleteBeanChange(request) : null;
       default:
-        throw new IllegalStateException("Unhandled request type " + request.getType());
+        throw new IllegalStateException("Unhandled request type " + request.type());
     }
   }
 
@@ -799,7 +799,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * Return the bean change for a delete.
    */
   private BeanChange deleteBeanChange(PersistRequestBean<T> request) {
-    return beanChange(ChangeType.DELETE, request.getBeanId(), null, null);
+    return beanChange(ChangeType.DELETE, request.beanId(), null, null);
   }
 
   /**
@@ -808,9 +808,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
   private BeanChange updateBeanChange(PersistRequestBean<T> request) {
     try {
       BeanChangeJson changeJson = new BeanChangeJson(this, request.isStatelessUpdate());
-      request.getEntityBeanIntercept().addDirtyPropertyValues(changeJson);
+      request.intercept().addDirtyPropertyValues(changeJson);
       changeJson.flush();
-      return beanChange(ChangeType.UPDATE, request.getBeanId(), changeJson.newJson(), changeJson.oldJson());
+      return beanChange(ChangeType.UPDATE, request.beanId(), changeJson.newJson(), changeJson.oldJson());
     } catch (RuntimeException e) {
       logger.error("Failed to write ChangeLog entry for update", e);
       return null;
@@ -824,9 +824,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
     try {
       StringWriter writer = new StringWriter(200);
       SpiJsonWriter jsonWriter = createJsonWriter(writer);
-      jsonWriteForInsert(jsonWriter, request.getEntityBean());
+      jsonWriteForInsert(jsonWriter, request.entityBean());
       jsonWriter.flush();
-      return beanChange(ChangeType.INSERT, request.getBeanId(), writer.toString(), null);
+      return beanChange(ChangeType.INSERT, request.beanId(), writer.toString(), null);
     } catch (IOException e) {
       logger.error("Failed to write ChangeLog entry for insert", e);
       return null;
@@ -1793,7 +1793,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
    * We actually need to do a query because we don't know the type without the discriminator value.
    */
   private T findReferenceBean(Object id, PersistenceContext pc) {
-    DefaultOrmQuery<T> query = new DefaultOrmQuery<>(this, ebeanServer, ebeanServer.getExpressionFactory());
+    DefaultOrmQuery<T> query = new DefaultOrmQuery<>(this, ebeanServer, ebeanServer.expressionFactory());
     query.setPersistenceContext(pc);
     return query.setId(id).findOne();
   }
@@ -3087,7 +3087,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType, SpiBeanType {
 
   public boolean isIdLoaded(EntityBeanIntercept ebi) {
     // assume id loaded for IdClass case with idPropertyIndex == -1
-    return idPropertyIndex == -1 ? true : ebi.isLoadedProperty(idPropertyIndex);
+    return idPropertyIndex == -1 || ebi.isLoadedProperty(idPropertyIndex);
   }
 
   boolean hasIdValue(EntityBean bean) {

ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorCacheHelp.java

@@ -352,7 +352,7 @@ final class BeanDescriptorCacheHelp<T> {
     BeanDescriptor<?> targetDescriptor = many.getTargetDescriptor();
     List<Object> idList = new ArrayList<>(actualDetails.size());
     for (Object bean : actualDetails) {
-      idList.add(targetDescriptor.getId((EntityBean) bean));
+      idList.add(targetDescriptor.beanId(bean));
     }
     return new CachedManyIds(idList);
   }
@@ -375,7 +375,7 @@ final class BeanDescriptorCacheHelp<T> {
     for (Map.Entry<Object, Object> entry : beanDataMap.entrySet()) {
       CachedBeanData cachedBeanData = (CachedBeanData) entry.getValue();
       T bean = convertToBean(entry.getKey(), false, context, cachedBeanData);
-      result.add(bean, desc.getBeanId(bean));
+      result.add(bean, desc.beanId(bean));
     }
     return result;
   }
@@ -803,7 +803,7 @@ final class BeanDescriptorCacheHelp<T> {
       if (beanCache != null) {
         changeSet.addBeanRemove(desc, id);
       }
-      cacheDeleteImported(true, deleteRequest.getEntityBean(), changeSet);
+      cacheDeleteImported(true, deleteRequest.entityBean(), changeSet);
     }
   }
 
@@ -815,7 +815,7 @@ final class BeanDescriptorCacheHelp<T> {
       changeSet.addInvalidate(desc);
     } else {
       queryCacheClear(changeSet);
-      cacheDeleteImported(false, insertRequest.getEntityBean(), changeSet);
+      cacheDeleteImported(false, insertRequest.entityBean(), changeSet);
       changeSet.addBeanInsert(desc.getBaseTable());
     }
   }
@@ -839,10 +839,10 @@ final class BeanDescriptorCacheHelp<T> {
         // query caching only
         return;
       }
-      List<BeanPropertyAssocMany<?>> manyCollections = updateRequest.getUpdatedManyForL2Cache();
+      List<BeanPropertyAssocMany<?>> manyCollections = updateRequest.updatedManyForL2Cache();
       if (manyCollections != null) {
         for (BeanPropertyAssocMany<?> many : manyCollections) {
-          Object details = many.getValue(updateRequest.getEntityBean());
+          Object details = many.getValue(updateRequest.entityBean());
           CachedManyIds entry = createManyIds(many, details);
           if (entry != null) {
             changeSet.addManyPut(desc, many.getName(), id, entry);

ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorManager.java

@@ -377,7 +377,7 @@ public final class BeanDescriptorManager implements BeanDescriptorMap, SpiBeanTy
    * For SQL based modifications we need to invalidate appropriate parts of the cache.
    */
   public void cacheNotify(TransactionEventTable.TableIUD tableIUD, CacheChangeSet changeSet) {
-    String tableName = tableIUD.getTableName().toLowerCase();
+    String tableName = tableIUD.tableName().toLowerCase();
     List<BeanDescriptor<?>> normalBeanTypes = tableToDescMap.get(tableName);
     if (normalBeanTypes != null) {
       // 'normal' entity beans based on a "base table"

ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanLifecycleAdapterFactory.java

@@ -208,7 +208,7 @@ final class BeanLifecycleAdapterFactory {
 
     private void invoke(Method[] methods, BeanPersistRequest<?> request) {
       for (Method method : methods) {
-        invoke(method, request.getBean());
+        invoke(method, request.bean());
       }
     }
 

ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssoc.java

@@ -229,7 +229,7 @@ public abstract class BeanPropertyAssoc<T> extends BeanProperty implements STree
    * We use target descriptor rather than target property type to support ElementCollection.
    */
   public SpiQuery<T> newQuery(SpiEbeanServer server) {
-    return new DefaultOrmQuery<>(targetDescriptor, server, server.getExpressionFactory());
+    return new DefaultOrmQuery<>(targetDescriptor, server, server.expressionFactory());
   }
 
   @Override

ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocMany.java

@@ -414,7 +414,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
     boolean softDelete = targetDescriptor.isSoftDelete();
     boolean needsX2Table = softDelete || getExtraWhere() != null;
     StringBuilder sb = new StringBuilder(50);
-    SpiQuery<?> query = request.getQueryRequest().getQuery();
+    SpiQuery<?> query = request.getQueryRequest().query();
     if (hasJoinTable()) {
       sb.append(query.isAsDraft() ? intersectionDraftTable : intersectionPublishTable);
     } else {
@@ -869,7 +869,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
     draftVal.size();
     Collection<T> actualDetails = draftVal.getActualDetails();
     for (T bean : actualDetails) {
-      Object id = targetDescriptor.getId((EntityBean) bean);
+      Object id = targetDescriptor.beanId(bean);
       T liveBean = liveBeansAsMap.remove(id);
 
       if (isManyToMany()) {
@@ -899,7 +899,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> implements ST
     Collection<?> liveBeans = liveVal.getActualDetails();
     Map<Object, T> liveMap = new LinkedHashMap<>();
     for (Object liveBean : liveBeans) {
-      Object id = targetDescriptor.getId((EntityBean) liveBean);
+      Object id = targetDescriptor.beanId(liveBean);
       liveMap.put(id, (T) liveBean);
     }
     return liveMap;

ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocOne.java

@@ -154,6 +154,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   /**
    * Return the property value as an entity bean.
    */
+  @Override
   public EntityBean getValueAsEntityBean(EntityBean owner) {
     return (EntityBean) getValue(owner);
   }
@@ -194,7 +195,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
       } else {
         Object assocBean = getValue(bean);
         if (assocBean != null) {
-          Object parentId = targetDescriptor.getId((EntityBean) assocBean);
+          Object parentId = targetDescriptor.beanId(assocBean);
           if (parentId != null) {
             changeSet.addManyRemove(targetDescriptor, relationshipProperty.getName(), parentId);
           }
@@ -203,6 +204,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     }
   }
 
+  @Override
   Object naturalKeyVal(Map<String, Object> values) {
     EntityBean bean = (EntityBean) values.get(name);
     if (bean == null) {
@@ -339,6 +341,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     }
   }
 
+  @Override
   public boolean hasForeignKey() {
     return foreignKey == null || primaryKeyJoin || !foreignKey.isNoConstraint();
   }
@@ -402,6 +405,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   /**
    * Return the bean cache value for this property using original values.
    */
+  @Override
   public Object getCacheDataValueOrig(EntityBeanIntercept ebi) {
     return cacheDataConvert(ebi.getOrigValue(propertyIndex));
   }

ebean-core/src/main/java/io/ebeaninternal/server/expression/DefaultExpressionRequest.java

@@ -28,7 +28,7 @@ public final class DefaultExpressionRequest implements SpiExpressionRequest {
 
   public DefaultExpressionRequest(SpiOrmQueryRequest<?> queryRequest, DeployParser deployParser, Binder binder, SpiExpressionList<?> expressionList) {
     this.queryRequest = queryRequest;
-    this.beanDescriptor = queryRequest.getBeanDescriptor();
+    this.beanDescriptor = queryRequest.descriptor();
     this.deployParser = deployParser;
     this.binder = binder;
     this.expressionList = expressionList;
@@ -84,7 +84,7 @@ public final class DefaultExpressionRequest implements SpiExpressionRequest {
   @Override
   public void appendLike(boolean rawLikeExpression) {
     sql.append(" ");
-    sql.append(queryRequest.getDBLikeClause(rawLikeExpression));
+    sql.append(queryRequest.dbLikeClause(rawLikeExpression));
     sql.append(" ");
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/expression/ExistsQueryExpression.java

@@ -79,7 +79,7 @@ final class ExistsQueryExpression implements SpiExpression, UnsupportedDocStoreE
    */
   protected CQuery<?> compileSubQuery(BeanQueryRequest<?> queryRequest) {
     SpiEbeanServer ebeanServer = (SpiEbeanServer) queryRequest.getEbeanServer();
-    return ebeanServer.compileQuery(Type.SQ_EXISTS, subQuery, queryRequest.getTransaction());
+    return ebeanServer.compileQuery(Type.SQ_EXISTS, subQuery, queryRequest.transaction());
   }
 
   @Override

ebean-core/src/main/java/io/ebeaninternal/server/expression/InQueryExpression.java

@@ -67,7 +67,7 @@ final class InQueryExpression extends AbstractExpression implements UnsupportedD
   private CQuery<?> compileSubQuery(BeanQueryRequest<?> queryRequest) {
 
     SpiEbeanServer ebeanServer = (SpiEbeanServer) queryRequest.getEbeanServer();
-    return ebeanServer.compileQuery(Type.SQ_IN, subQuery, queryRequest.getTransaction());
+    return ebeanServer.compileQuery(Type.SQ_IN, subQuery, queryRequest.transaction());
   }
 
   @Override

ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBaseContext.java

@@ -35,7 +35,7 @@ abstract class DLoadBaseContext {
 
   DLoadBaseContext(DLoadContext parent, BeanDescriptor<?> desc, String path, OrmQueryProperties queryProps) {
     this.parent = parent;
-    this.serverName = parent.getEbeanServer().getName();
+    this.serverName = parent.getEbeanServer().name();
     this.desc = desc;
     this.queryProps = queryProps;
     this.fullPath = parent.getFullPath(path);

ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java

@@ -131,7 +131,7 @@ final class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContext
     }
 
     @Override
-    public int getBatchSize() {
+    public int batchSize() {
       return batchSize;
     }
 
@@ -154,7 +154,7 @@ final class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContext
     }
 
     @Override
-    public List<EntityBeanIntercept> getBatch() {
+    public List<EntityBeanIntercept> batch() {
       return list;
     }
 
@@ -164,17 +164,17 @@ final class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContext
     }
 
     @Override
-    public String getFullPath() {
+    public String fullPath() {
       return context.fullPath;
     }
 
     @Override
-    public BeanDescriptor<?> getBeanDescriptor() {
+    public BeanDescriptor<?> descriptor() {
       return context.desc;
     }
 
     @Override
-    public PersistenceContext getPersistenceContext() {
+    public PersistenceContext persistenceContext() {
       return persistenceContext;
     }
 

ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java

@@ -91,13 +91,13 @@ public final class DLoadContext implements LoadContext {
   }
 
   public DLoadContext(OrmQueryRequest<?> request, SpiQuerySecondary secondaryQueries) {
-    this.tenantId = request.getTenantId();
-    this.persistenceContext = request.getPersistenceContext();
-    this.ebeanServer = request.getServer();
-    this.defaultBatchSize = request.getLazyLoadBatchSize();
-    this.rootDescriptor = request.getBeanDescriptor();
+    this.tenantId = request.tenantId();
+    this.persistenceContext = request.persistenceContext();
+    this.ebeanServer = request.server();
+    this.defaultBatchSize = request.lazyLoadBatchSize();
+    this.rootDescriptor = request.descriptor();
 
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     this.useDocStore = query.isUseDocStore();
     this.asOf = query.getAsOf();
     this.asDraft = query.isAsDraft();

ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadManyContext.java

@@ -74,7 +74,7 @@ final class DLoadManyContext extends DLoadBaseContext implements LoadManyContext
 
 
   public String getName() {
-    return parent.getEbeanServer().getName();
+    return parent.getEbeanServer().name();
   }
 
   public void register(BeanCollection<?> bc) {
@@ -177,7 +177,7 @@ final class DLoadManyContext extends DLoadBaseContext implements LoadManyContext
     }
 
     @Override
-    public String getName() {
+    public String name() {
       return context.serverName;
     }
 

ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchControl.java

@@ -181,7 +181,7 @@ public final class BatchControl {
    * Add the request to the batch and return true if we should flush.
    */
   private boolean addToBatch(PersistRequestBean<?> request) {
-    Object alreadyInBatch = persistedBeans.put(request.getEntityBean(), DUMMY);
+    Object alreadyInBatch = persistedBeans.put(request.entityBean(), DUMMY);
     if (alreadyInBatch != null) {
       // special case where the same bean instance has already been
       // added to the batch (doesn't really occur with non-batching
@@ -345,7 +345,7 @@ public final class BatchControl {
   private BatchedBeanHolder getBeanHolder(PersistRequestBean<?> request) {
 
     int depth = transaction.depth();
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
+    BeanDescriptor<?> desc = request.descriptor();
 
     // batching by bean type AND depth
     String key = desc.rootName() + ":" + depth;

ebean-core/src/main/java/io/ebeaninternal/server/persist/BatchedBeanHolder.java

@@ -127,7 +127,7 @@ final class BatchedBeanHolder {
   public int append(PersistRequestBean<?> request) {
     empty = false;
     request.setBatched();
-    switch (request.getType()) {
+    switch (request.type()) {
       case INSERT:
         if (inserts == null) {
           inserts = new ArrayList<>();
@@ -151,7 +151,7 @@ final class BatchedBeanHolder {
         return deletes.size();
 
       default:
-        throw new RuntimeException("Invalid type code " + request.getType());
+        throw new RuntimeException("Invalid type code " + request.type());
     }
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/persist/DefaultPersister.java

@@ -73,7 +73,7 @@ public final class DefaultPersister implements Persister {
   public DefaultPersister(SpiEbeanServer server, Binder binder, BeanDescriptorManager descMgr) {
     this.server = server;
     this.beanDescriptorManager = descMgr;
-    this.persistExecute = new DefaultPersistExecute(binder, server.getServerConfig().getPersistBatchSize());
+    this.persistExecute = new DefaultPersistExecute(binder, server.config().getPersistBatchSize());
   }
 
   @Override
@@ -150,6 +150,7 @@ public final class DefaultPersister implements Persister {
   /**
    * Add to the flush queue in position 0, 1 or 2.
    */
+  @Override
   public void addToFlushQueue(SpiSqlUpdate update, SpiTransaction t, int pos) {
     new PersistRequestUpdateSql(server, update, t, persistExecute).addToFlushQueue(pos);
   }
@@ -207,7 +208,7 @@ public final class DefaultPersister implements Persister {
   private <T> List<Object> getBeanIds(BeanDescriptor<T> desc, List<T> beans) {
     List<Object> idList = new ArrayList<>(beans.size());
     for (T liveBean : beans) {
-      idList.add(desc.getBeanId(liveBean));
+      idList.add(desc.beanId(liveBean));
     }
     return idList;
   }
@@ -347,7 +348,7 @@ public final class DefaultPersister implements Persister {
      * Publish/restore the values from the sourceBean to the matching destination bean.
      */
     T publishToDestinationBean(T sourceBean) {
-      id = desc.getBeanId(sourceBean);
+      id = desc.beanId(sourceBean);
       T destBean = destBeans.get(id);
       insert = (destBean == null);
       // apply changes from liveBean to draftBean
@@ -537,7 +538,7 @@ public final class DefaultPersister implements Persister {
         request.executeOrQueue();
 
       } else if (logger.isDebugEnabled()) {
-        logger.debug("Update skipped as bean is unchanged: {}", request.getBean());
+        logger.debug("Update skipped as bean is unchanged: {}", request.bean());
       }
 
       if (request.isPersistCascade()) {
@@ -589,7 +590,7 @@ public final class DefaultPersister implements Persister {
       // skip deleting bean. Used where cascade is on
       // both sides of a relationship
       if (logger.isDebugEnabled()) {
-        logger.debug("skipping delete on alreadyRegistered " + req.getBean());
+        logger.debug("skipping delete on alreadyRegistered " + req.bean());
       }
       return 0;
     }
@@ -599,7 +600,7 @@ public final class DefaultPersister implements Persister {
       int rows = delete(req);
       if (draftReq != null) {
         // delete the 'draft' bean ('live' bean deleted first)
-        draftReq.setTrans(req.getTransaction());
+        draftReq.setTrans(req.transaction());
         rows = delete(draftReq);
       }
       req.commitTransIfRequired();
@@ -824,7 +825,7 @@ public final class DefaultPersister implements Persister {
 
     BeanPersistController controller = descriptor.getPersistController();
     if (controller != null) {
-      DeleteIdRequest request = new DeleteIdRequest(server, transaction, id);
+      DeleteIdRequest request = new DeleteIdRequest(server, transaction, descriptor.getBeanType(), id);
       if (idList == null) {
         controller.preDelete(request);
       } else {
@@ -905,13 +906,13 @@ public final class DefaultPersister implements Persister {
    */
   private void saveAssocMany(PersistRequestBean<?> request) {
 
-    EntityBean parentBean = request.getEntityBean();
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
-    SpiTransaction t = request.getTransaction();
+    EntityBean parentBean = request.entityBean();
+    BeanDescriptor<?> desc = request.descriptor();
+    SpiTransaction t = request.transaction();
 
-    EntityBean orphanForRemoval = request.getImportedOrphanForRemoval();
+    EntityBean orphanForRemoval = request.importedOrphanForRemoval();
     if (orphanForRemoval != null) {
-      delete(orphanForRemoval, request.getTransaction(), true);
+      delete(orphanForRemoval, request.transaction(), true);
     }
 
     // exported ones with cascade save
@@ -923,7 +924,7 @@ public final class DefaultPersister implements Persister {
           if (!prop.isSaveRecurseSkippable(detailBean)) {
             t.depth(+1);
             prop.setParentBeanToChild(parentBean, detailBean);
-            saveRecurse(detailBean, t, parentBean, request.getFlags());
+            saveRecurse(detailBean, t, parentBean, request.flags());
             t.depth(-1);
           }
         }
@@ -976,11 +977,11 @@ public final class DefaultPersister implements Persister {
    */
   private void deleteAssocMany(PersistRequestBean<?> request) {
 
-    SpiTransaction t = request.getTransaction();
+    SpiTransaction t = request.transaction();
     t.depth(-1);
 
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
-    EntityBean parentBean = request.getEntityBean();
+    BeanDescriptor<?> desc = request.descriptor();
+    EntityBean parentBean = request.entityBean();
     DeleteMode deleteMode = request.deleteMode();
 
     BeanPropertyAssocOne<?>[] expOnes = desc.propertiesOneExportedDelete();
@@ -1106,7 +1107,7 @@ public final class DefaultPersister implements Persister {
    */
   private void saveAssocOne(PersistRequestBean<?> request) {
 
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
+    BeanDescriptor<?> desc = request.descriptor();
 
     // imported ones with save cascade
     for (BeanPropertyAssocOne<?> prop : desc.propertiesOneImportedSave()) {
@@ -1116,14 +1117,14 @@ public final class DefaultPersister implements Persister {
       }
 
       if (request.isLoadedProperty(prop)) {
-        EntityBean detailBean = prop.getValueAsEntityBean(request.getEntityBean());
+        EntityBean detailBean = prop.getValueAsEntityBean(request.entityBean());
         if (detailBean != null
           && !prop.isSaveRecurseSkippable(detailBean)
           && !prop.isReference(detailBean)
           && !request.isParent(detailBean)) {
-          SpiTransaction t = request.getTransaction();
+          SpiTransaction t = request.transaction();
           t.depth(-1);
-          saveRecurse(detailBean, t, null, request.getFlags());
+          saveRecurse(detailBean, t, null, request.flags());
           t.depth(+1);
         }
       }
@@ -1139,7 +1140,7 @@ public final class DefaultPersister implements Persister {
   private void deleteOrphan(PersistRequestBean<?> request, BeanPropertyAssocOne<?> prop) {
     Object origValue = request.getOrigValue(prop);
     if (origValue instanceof EntityBean) {
-      delete((EntityBean) origValue, request.getTransaction(), true);
+      delete((EntityBean) origValue, request.transaction(), true);
     }
   }
 
@@ -1151,7 +1152,7 @@ public final class DefaultPersister implements Persister {
 
     DeleteUnloadedForeignKeys fkeys = null;
 
-    for (BeanPropertyAssocOne<?> one : request.getBeanDescriptor().propertiesOneImportedDelete()) {
+    for (BeanPropertyAssocOne<?> one : request.descriptor().propertiesOneImportedDelete()) {
       if (!request.isLoadedProperty(one)) {
         // we have cascade Delete on a partially populated bean and
         // this property was not loaded (so we are going to have to fetch it)
@@ -1172,14 +1173,14 @@ public final class DefaultPersister implements Persister {
 
     DeleteMode deleteMode = request.deleteMode();
 
-    for (BeanPropertyAssocOne<?> prop : request.getBeanDescriptor().propertiesOneImportedDelete()) {
+    for (BeanPropertyAssocOne<?> prop : request.descriptor().propertiesOneImportedDelete()) {
       if (deleteMode.isHard() || prop.isTargetSoftDelete()) {
         if (request.isLoadedProperty(prop)) {
-          Object detailBean = prop.getValue(request.getEntityBean());
+          Object detailBean = prop.getValue(request.entityBean());
           if (detailBean != null) {
             EntityBean detail = (EntityBean) detailBean;
             if (prop.hasId(detail)) {
-              deleteRecurse(detail, request.getTransaction(), deleteMode);
+              deleteRecurse(detail, request.transaction(), deleteMode);
             }
           }
         }

ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteIdRequest.java

@@ -9,11 +9,13 @@ final class DeleteIdRequest implements BeanDeleteIdRequest {
 
   private final EbeanServer server;
   private final Transaction transaction;
+  private Class<?> beanType;
   private Object id;
 
-  DeleteIdRequest(SpiEbeanServer server, Transaction transaction, Object id) {
+  DeleteIdRequest(SpiEbeanServer server, Transaction transaction, Class<?> beanType, Object id) {
     this.server = server;
     this.transaction = transaction;
+    this.beanType = beanType;
     this.id = id;
   }
 
@@ -27,12 +29,17 @@ final class DeleteIdRequest implements BeanDeleteIdRequest {
   }
 
   @Override
-  public Transaction getTransaction() {
+  public Transaction transaction() {
     return transaction;
   }
 
   @Override
-  public Object getId() {
+  public Class<?> beanType() {
+    return beanType;
+  }
+
+  @Override
+  public Object id() {
     return id;
   }
 }

ebean-core/src/main/java/io/ebeaninternal/server/persist/DeleteUnloadedForeignKeys.java

@@ -49,10 +49,10 @@ final class DeleteUnloadedForeignKeys {
    */
   void queryForeignKeys() {
 
-    BeanDescriptor<?> descriptor = request.getBeanDescriptor();
+    BeanDescriptor<?> descriptor = request.descriptor();
     SpiQuery<?> q = (SpiQuery<?>) server.createQuery(descriptor.getBeanType());
 
-    Object id = request.getBeanId();
+    Object id = request.beanId();
 
     StringBuilder sb = new StringBuilder(30);
     for (BeanPropertyAssocOne<?> aPropList : propList) {
@@ -67,7 +67,7 @@ final class DeleteUnloadedForeignKeys {
     q.setIncludeSoftDeletes();
     q.where().idEq(id);
 
-    SpiTransaction t = request.getTransaction();
+    SpiTransaction t = request.transaction();
     if (t.isLogSummary()) {
       t.logSummary("-- Ebean fetching foreign key values for delete of " + descriptor.getName() + " id:" + id);
     }
@@ -87,9 +87,9 @@ final class DeleteUnloadedForeignKeys {
         // if bean exists with a unique id then delete it
         if (detailBean != null && prop.hasId((EntityBean) detailBean)) {
           if (deletePermanent) {
-            server.deletePermanent(detailBean, request.getTransaction());
+            server.deletePermanent(detailBean, request.transaction());
           } else {
-            server.delete(detailBean, request.getTransaction());
+            server.delete(detailBean, request.transaction());
           }
         }
       }

ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeCallableSql.java

@@ -56,15 +56,15 @@ final class ExeCallableSql {
 
   private CallableStatement bindStmt(PersistRequestCallableSql request, boolean batchThisRequest) throws SQLException {
     request.startBind(batchThisRequest);
-    SpiCallableSql callableSql = request.getCallableSql();
-    SpiTransaction t = request.getTransaction();
+    SpiCallableSql callableSql = request.callableSql();
+    SpiTransaction t = request.transaction();
 
     String sql = callableSql.getSql();
     BindParams bindParams = callableSql.getBindParams();
 
     // process named parameters if required
     sql = BindParamsParser.parse(bindParams, sql);
-    boolean logSql = request.isLogSql();
+    boolean logSql = request.logSql();
 
     CallableStatement cstmt;
     if (batchThisRequest) {

ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeOrmUpdate.java

@@ -38,7 +38,7 @@ final class ExeOrmUpdate {
         // return -1 to indicate batch mode
         return -1;
       } else {
-        SpiUpdate<?> ormUpdate = request.getOrmUpdate();
+        SpiUpdate<?> ormUpdate = request.ormUpdate();
         if (ormUpdate.getTimeout() > 0) {
           pstmt.setQueryTimeout(ormUpdate.getTimeout());
         }
@@ -49,7 +49,7 @@ final class ExeOrmUpdate {
       }
 
     } catch (SQLException ex) {
-      throw new PersistenceException("Error executing: " + request.getOrmUpdate().getGeneratedSql(), ex);
+      throw new PersistenceException("Error executing: " + request.ormUpdate().getGeneratedSql(), ex);
 
     } finally {
       if (!batchThisRequest) {
@@ -62,14 +62,14 @@ final class ExeOrmUpdate {
    * Convert bean and property names to db table and columns.
    */
   private String translate(PersistRequestOrmUpdate request, String sql) {
-    BeanDescriptor<?> descriptor = request.getBeanDescriptor();
+    BeanDescriptor<?> descriptor = request.descriptor();
     return descriptor.convertOrmUpdateToSql(sql);
   }
 
   private PreparedStatement bindStmt(PersistRequestOrmUpdate request, boolean batchThisRequest) throws SQLException {
     request.startBind(batchThisRequest);
-    SpiUpdate<?> ormUpdate = request.getOrmUpdate();
-    SpiTransaction t = request.getTransaction();
+    SpiUpdate<?> ormUpdate = request.ormUpdate();
+    SpiTransaction t = request.transaction();
 
     String sql = ormUpdate.getUpdateStatement();
 

ebean-core/src/main/java/io/ebeaninternal/server/persist/ExeUpdateSql.java

@@ -74,8 +74,8 @@ final class ExeUpdateSql {
 
   private PreparedStatement bindStmt(PersistRequestUpdateSql request, boolean batchThisRequest) throws SQLException {
     request.startBind(batchThisRequest);
-    SpiSqlUpdate updateSql = request.getUpdateSql();
-    SpiTransaction t = request.getTransaction();
+    SpiSqlUpdate updateSql = request.updateSql();
+    SpiTransaction t = request.transaction();
 
     BindParams bindParams = updateSql.getBindParams();
 

ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBase.java

@@ -30,10 +30,10 @@ abstract class SaveManyBase implements SaveMany {
   SaveManyBase(DefaultPersister persister, boolean insertedParent, BeanPropertyAssocMany<?> many, EntityBean parentBean, PersistRequestBean<?> request) {
     this.persister = persister;
     this.request = request;
-    this.server = request.getServer();
+    this.server = request.server();
     this.many = many;
     this.parentBean = parentBean;
-    this.transaction = request.getTransaction();
+    this.transaction = request.transaction();
     this.value = many.getValue(parentBean);
     this.insertedParent = insertedParent;
     if (!insertedParent) {
@@ -49,7 +49,7 @@ abstract class SaveManyBase implements SaveMany {
   final void preElementCollectionUpdate() {
     if (!insertedParent) {
       request.preElementCollectionUpdate();
-      persister.addToFlushQueue(many.deleteByParentId(request.getBeanId(), null), transaction, 1);
+      persister.addToFlushQueue(many.deleteByParentId(request.beanId(), null), transaction, 1);
     }
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyBeans.java

@@ -186,7 +186,7 @@ public final class SaveManyBeans extends SaveManyBase {
         }
 
         if (!skipSavingThisBean) {
-          persister.saveRecurse(detail, transaction, parentBean, request.getFlags());
+          persister.saveRecurse(detail, transaction, parentBean, request.flags());
           if (many.hasOrderColumn()) {
             // Clear the bean from the PersistenceContext (L1 cache), because the order of referenced beans might have changed
             final BeanDescriptor<?> beanDescriptor = many.getBeanDescriptor();
@@ -225,7 +225,7 @@ public final class SaveManyBeans extends SaveManyBase {
         detailBean = ((Map.Entry<?, ?>) detailBean).getValue();
       }
       if (detailBean instanceof EntityBean) {
-        Object id = targetDescriptor.getId((EntityBean) detailBean);
+        Object id = targetDescriptor.beanId(detailBean);
         if (!isNullOrZero(id)) {
           // remember the Id (other details not in the collection) will be removed
           detailIds.add(id);
@@ -344,7 +344,7 @@ public final class SaveManyBeans extends SaveManyBase {
     }
     if (!(value instanceof BeanCollection<?>)) {
       if (!insertedParent && cascade && isChangedProperty()) {
-        persister.addToFlushQueue(many.deleteByParentId(request.getBeanId(), null), transaction, 0);
+        persister.addToFlushQueue(many.deleteByParentId(request.beanId(), null), transaction, 0);
       }
     } else {
       BeanCollection<?> c = (BeanCollection<?>) value;
@@ -363,7 +363,7 @@ public final class SaveManyBeans extends SaveManyBase {
             EntityBean eb = (EntityBean) removedBean;
             if (eb._ebean_intercept().isOrphanDelete()) {
               // only delete if the bean was loaded meaning that it is known to exist in the DB
-              persister.deleteRequest(persister.createDeleteRemoved(removedBean, transaction, request.getFlags()));
+              persister.deleteRequest(persister.createDeleteRemoved(removedBean, transaction, request.flags()));
             }
           }
         }

ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollection.java

@@ -43,7 +43,7 @@ final class SaveManyElementCollection extends SaveManyBase {
 
   private void saveCollection() {
     SpiSqlUpdate proto = many.insertElementCollection();
-    Object parentId = request.getBeanId();
+    Object parentId = request.beanId();
     for (Object value : collection) {
       final SpiSqlUpdate sqlInsert = proto.copy();
       sqlInsert.setParameter(parentId);

ebean-core/src/main/java/io/ebeaninternal/server/persist/SaveManyElementCollectionMap.java

@@ -45,7 +45,7 @@ final class SaveManyElementCollectionMap extends SaveManyBase {
 
   private void saveCollection() {
     SpiSqlUpdate proto = many.insertElementCollection();
-    Object parentId = request.getBeanId();
+    Object parentId = request.beanId();
     for (Map.Entry<?, ?> entry : entries) {
       final SpiSqlUpdate sqlInsert = proto.copy();
       sqlInsert.setParameter(parentId);

ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteHandler.java

@@ -30,7 +30,7 @@ final class DeleteHandler extends DmlHandler {
   @Override
   public void bind() throws SQLException {
     sql = meta.getSql(persistRequest);
-    SpiTransaction t = persistRequest.getTransaction();
+    SpiTransaction t = persistRequest.transaction();
     PreparedStatement pstmt;
     if (persistRequest.isBatched()) {
       pstmt = getPstmtBatch(t, sql, persistRequest, false);

ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DeleteMeta.java

@@ -40,13 +40,13 @@ final class DeleteMeta extends BaseMeta {
    * Bind the request based on the concurrency mode.
    */
   public void bind(PersistRequestBean<?> persist, DmlHandler bind) throws SQLException {
-    EntityBean bean = persist.getEntityBean();
+    EntityBean bean = persist.entityBean();
     id.dmlBind(bind, bean);
     if (tenantId != null) {
       tenantId.dmlBind(bind, bean);
     }
 
-    if (persist.getConcurrencyMode() == ConcurrencyMode.VERSION) {
+    if (persist.concurrencyMode() == ConcurrencyMode.VERSION) {
       version.dmlBind(bind, bean);
     }
   }
@@ -56,11 +56,11 @@ final class DeleteMeta extends BaseMeta {
    */
   public String getSql(PersistRequestBean<?> request) {
     if (id.isEmpty()) {
-      throw new IllegalStateException("Can not deleteById on " + request.getFullName() + " as no @Id property");
+      throw new IllegalStateException("Can not deleteById on " + request.fullName() + " as no @Id property");
     }
 
     boolean publish = request.isPublish();
-    switch (request.getConcurrencyMode()) {
+    switch (request.concurrencyMode()) {
       case NONE:
         return publish ? sqlNone : sqlDraftNone;
 
@@ -68,7 +68,7 @@ final class DeleteMeta extends BaseMeta {
         return publish ? sqlVersion : sqlDraftVersion;
 
       default:
-        throw new RuntimeException("Invalid mode " + request.getConcurrencyMode());
+        throw new RuntimeException("Invalid mode " + request.concurrencyMode());
     }
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlBeanPersister.java

@@ -71,8 +71,8 @@ final class DmlBeanPersister implements BeanPersister {
     } catch (SQLException e) {
       // log the error to the transaction log
       String msg = "Error[" + StringHelper.removeNewLines(e.getMessage()) + "]";
-      if (request.getTransaction().isLogSummary()) {
-        request.getTransaction().logSummary(msg);
+      if (request.transaction().isLogSummary()) {
+        request.transaction().logSummary(msg);
       }
       throw dbPlatform.translate(msg, e);
     } finally {

ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DmlHandler.java

@@ -40,7 +40,7 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
   DmlHandler(PersistRequestBean<?> persistRequest) {
     this.now = System.currentTimeMillis();
     this.persistRequest = persistRequest;
-    this.transaction = persistRequest.getTransaction();
+    this.transaction = persistRequest.transaction();
     this.logLevelSql = transaction.isLogSql();
     if (logLevelSql) {
       this.bindLog = new StringBuilder(50);
@@ -68,7 +68,7 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
    * Bind to the statement returning the DataBind.
    */
   DataBind bind(PreparedStatement stmt) {
-    return new DataBind(persistRequest.getDataTimeZone(), stmt, transaction.getInternalConnection());
+    return new DataBind(persistRequest.dataTimeZone(), stmt, transaction.getInternalConnection());
   }
 
   /**
@@ -103,7 +103,7 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
     } catch (OptimisticLockException e) {
       // add the SQL and bind values to error message
       String m = e.getMessage() + " sql[" + sql + "] bind[" + bindLog + "]";
-      persistRequest.getTransaction().logSummary("OptimisticLockException:" + m);
+      persistRequest.transaction().logSummary("OptimisticLockException:" + m);
       throw new OptimisticLockException(m, null, e.getEntity());
     }
   }

ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/DocStoreBeanPersister.java

@@ -19,13 +19,13 @@ final class DocStoreBeanPersister implements BeanPersister {
   @Override
   public void insert(PersistRequestBean<?> request) throws PersistenceException {
     //request.setIdValueForDocStore();
-    generatedProperties.preInsert(request.getEntityBean(), request.now());
+    generatedProperties.preInsert(request.entityBean(), request.now());
     request.docStorePersist();
   }
 
   @Override
   public void update(PersistRequestBean<?> request) throws PersistenceException {
-    generatedProperties.preUpdate(request.getEntityBean(), request.now());
+    generatedProperties.preUpdate(request.entityBean(), request.now());
     request.docStorePersist();
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/InsertHandler.java

@@ -47,8 +47,8 @@ public final class InsertHandler extends DmlHandler {
    */
   @Override
   public void bind() throws SQLException {
-    BeanDescriptor<?> desc = persistRequest.getBeanDescriptor();
-    EntityBean bean = persistRequest.getEntityBean();
+    BeanDescriptor<?> desc = persistRequest.descriptor();
+    EntityBean bean = persistRequest.entityBean();
     Object idValue = desc.getId(bean);
     boolean withId = !isNullOrZero(idValue);
 
@@ -67,7 +67,7 @@ public final class InsertHandler extends DmlHandler {
       }
     }
 
-    SpiTransaction t = persistRequest.getTransaction();
+    SpiTransaction t = persistRequest.transaction();
     // get the appropriate sql
     sql = meta.getSql(withId, persistRequest.isPublish());
     PreparedStatement pstmt;

ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateHandler.java

@@ -38,7 +38,7 @@ public final class UpdateHandler extends DmlHandler {
     }
 
     sql = updatePlan.getSql();
-    SpiTransaction t = persistRequest.getTransaction();
+    SpiTransaction t = persistRequest.transaction();
     PreparedStatement pstmt;
     if (persistRequest.isBatched()) {
       pstmt = getPstmtBatch(t, sql, persistRequest, false);

ebean-core/src/main/java/io/ebeaninternal/server/persist/dml/UpdateMeta.java

@@ -30,13 +30,13 @@ final class UpdateMeta extends BaseMeta {
    * Bind the request based on the concurrency mode.
    */
   public void bind(PersistRequestBean<?> persist, DmlHandler bind, SpiUpdatePlan updatePlan) throws SQLException {
-    EntityBean bean = persist.getEntityBean();
+    EntityBean bean = persist.entityBean();
     updatePlan.bindSet(bind, bean);
     id.dmlBind(bind, bean);
     if (tenantId != null) {
       tenantId.dmlBind(bind, bean);
     }
-    if (persist.getConcurrencyMode() == ConcurrencyMode.VERSION) {
+    if (persist.concurrencyMode() == ConcurrencyMode.VERSION) {
       version.dmlBind(bind, bean);
     }
   }
@@ -49,9 +49,9 @@ final class UpdateMeta extends BaseMeta {
   }
 
   private SpiUpdatePlan getDynamicUpdatePlan(PersistRequestBean<?> persistRequest) {
-    String key = persistRequest.getUpdatePlanHash();
+    String key = persistRequest.updatePlanHash();
     // check if we can use a cached UpdatePlan
-    BeanDescriptor<?> beanDescriptor = persistRequest.getBeanDescriptor();
+    BeanDescriptor<?> beanDescriptor = persistRequest.descriptor();
     SpiUpdatePlan updatePlan = beanDescriptor.getUpdatePlan(key);
     if (updatePlan != null) {
       return updatePlan;
@@ -64,9 +64,9 @@ final class UpdateMeta extends BaseMeta {
     set.addToUpdate(persistRequest, list);
     BindableList bindableList = new BindableList(list);
 
-    ConcurrencyMode mode = persistRequest.getConcurrencyMode();
+    ConcurrencyMode mode = persistRequest.concurrencyMode();
     // build the SQL for this update statement
-    String sql = genSql(mode, bindableList, persistRequest.getUpdateTable());
+    String sql = genSql(mode, bindableList, persistRequest.updateTable());
 
     updatePlan = new UpdatePlan(key, mode, sql, bindableList);
     // add the UpdatePlan to the cache

ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableIdEmbedded.java

@@ -90,7 +90,7 @@ final class BindableIdEmbedded implements BindableId {
       throw new PersistenceException(m);
     }
 
-    EntityBean bean = persist.getEntityBean();
+    EntityBean bean = persist.entityBean();
 
     // create the new id
     EntityBean newId = (EntityBean) embId.createEmbeddedId();

ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableOrderColumn.java

@@ -18,7 +18,7 @@ public final class BindableOrderColumn extends BindableProperty {
 
   @Override
   public void addToUpdate(PersistRequestBean<?> request, List<Bindable> list) {
-    int sortOrder = request.getEntityBeanIntercept().getSortOrder();
+    int sortOrder = request.intercept().getSortOrder();
     if (sortOrder > 0) {
       list.add(this);
     }

ebean-core/src/main/java/io/ebeaninternal/server/persist/dmlbind/BindableUnidirectional.java

@@ -54,7 +54,7 @@ public final class BindableUnidirectional implements Bindable {
   @Override
   public void dmlBind(BindableRequest request, EntityBean bean) throws SQLException {
     PersistRequestBean<?> persistRequest = request.getPersistRequest();
-    Object parentBean = persistRequest.getParentBean();
+    Object parentBean = persistRequest.parentBean();
     if (parentBean == null) {
       Class<?> localType = desc.getBeanType();
       Class<?> targetType = unidirectional.getTargetType();

ebean-core/src/main/java/io/ebeaninternal/server/profile/DCountMetric.java

@@ -26,6 +26,7 @@ final class DCountMetric implements CountMetric {
     count.add(value);
   }
 
+  @Override
   public void increment() {
     count.increment();
   }

ebean-core/src/main/java/io/ebeaninternal/server/profile/DProfileLocation.java

@@ -82,6 +82,7 @@ class DProfileLocation implements ProfileLocation {
     }
   }
 
+  @Override
   public void setTraceCount(int traceCount) {
     this.traceCount = traceCount;
   }

ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java

@@ -184,7 +184,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
     this.request = request;
     this.audit = request.isAuditReads();
     this.queryPlan = queryPlan;
-    this.query = request.getQuery();
+    this.query = request.query();
     this.queryMode = query.getMode();
     this.lazyLoadManyProperty = query.getLazyLoadMany();
     this.readOnly = request.isReadOnly();
@@ -202,7 +202,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
     this.sql = queryPlan.getSql();
     this.rawSql = queryPlan.isRawSql();
     this.logWhereSql = queryPlan.getLogWhereSql();
-    this.desc = request.getBeanDescriptor();
+    this.desc = request.descriptor();
     this.predicates = predicates;
     if (lazyLoadManyProperty != null) {
       this.help = NOOP_ADD;
@@ -216,7 +216,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
     if (request.isFindById()) {
       return null;
     } else {
-      SpiQuery.Type manyType = request.getQuery().getType();
+      SpiQuery.Type manyType = request.query().getType();
       if (manyType == null) {
         // subQuery compiled for InQueryExpression
         return null;
@@ -306,7 +306,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
       // cancelled before we started
       query.checkCancelled();
       startNano = System.nanoTime();
-      SpiTransaction t = request.getTransaction();
+      SpiTransaction t = request.transaction();
       profileOffset = t.profileOffset();
       if (query.isRawSql()) {
         ResultSet suppliedResultSet = query.getRawSql().getResultSet();
@@ -370,7 +370,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
    */
   @Override
   public PersistenceContext getPersistenceContext() {
-    return request.getPersistenceContext();
+    return request.persistenceContext();
   }
 
   @Override
@@ -586,19 +586,19 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
   @Override
   public void registerBeanInherit(BeanPropertyAssocOne<?> property, EntityBeanIntercept ebi) {
     String path = getPath(property.getName());
-    request.getGraphContext().register(path, ebi, property);
+    request.loadContext().register(path, ebi, property);
   }
 
   @Override
   public void register(String path, EntityBeanIntercept ebi) {
     path = getPath(path);
-    request.getGraphContext().register(path, ebi);
+    request.loadContext().register(path, ebi);
   }
 
   @Override
   public void register(BeanPropertyAssocMany<?> many, BeanCollection<?> bc) {
     String path = getPath(many.getName());
-    request.getGraphContext().register(path, many, bc);
+    request.loadContext().register(path, many, bc);
   }
 
   /**
@@ -630,7 +630,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
   }
 
   public SpiTransaction getTransaction() {
-    return request.getTransaction();
+    return request.transaction();
   }
 
   /**
@@ -683,7 +683,7 @@ public final class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfi
 
   @Override
   public void profileBean(EntityBeanIntercept ebi, String prefix) {
-    ObjectGraphNode node = request.getGraphContext().getObjectGraphNode(prefix);
+    ObjectGraphNode node = request.loadContext().getObjectGraphNode(prefix);
     ebi.setNodeUsageCollector(new NodeUsageCollector(node, profilingListenerRef));
   }
 

ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilder.java

@@ -88,12 +88,12 @@ final class CQueryBuilder {
    * Build the delete query.
    */
   <T> CQueryUpdate buildUpdateQuery(boolean deleteRequest, OrmQueryRequest<T> request) {
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
     String rootTableAlias = query.getAlias();
     query.setupForDeleteOrUpdate();
 
     CQueryPredicates predicates = new CQueryPredicates(binder, request);
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       // skip building the SqlTree and Sql string
       predicates.prepare(false);
@@ -117,7 +117,7 @@ final class CQueryBuilder {
 
   private <T> String buildDeleteSql(OrmQueryRequest<T> request, String rootTableAlias, CQueryPredicates predicates, SqlTree sqlTree) {
     String alias = alias(rootTableAlias);
-    if (sqlTree.noJoins() && !request.getQuery().hasMaxRowsOrFirstRow()) {
+    if (sqlTree.noJoins() && !request.query().hasMaxRowsOrFirstRow()) {
       if (dbPlatform.isSupportsDeleteTableAlias()) {
         // delete from table <alias> ...
         return aliasReplace(buildSqlDelete("delete", request, predicates, sqlTree).getSql(), alias);
@@ -130,7 +130,7 @@ final class CQueryBuilder {
     }
     // wrap as - delete from table where id in (select id ...)
     String sql = buildSqlDelete(null, request, predicates, sqlTree).getSql();
-    sql = request.getBeanDescriptor().getDeleteByIdInSql() + "in (" + sql + ")";
+    sql = request.descriptor().getDeleteByIdInSql() + "in (" + sql + ")";
     sql = aliasReplace(sql, alias);
     return sql;
   }
@@ -145,7 +145,7 @@ final class CQueryBuilder {
 
   private <T> String buildUpdateSql(OrmQueryRequest<T> request, String rootTableAlias, CQueryPredicates predicates, SqlTree sqlTree) {
     StringBuilder sb = new StringBuilder(200);
-    sb.append("update ").append(request.getBeanDescriptor().getBaseTable());
+    sb.append("update ").append(request.descriptor().getBaseTable());
     if (rootTableAlias != null) {
       sb.append(" ").append(rootTableAlias);
     }
@@ -157,7 +157,7 @@ final class CQueryBuilder {
     }
     // wrap as - update table set ... where id in (select id ...)
     String sql = buildSqlUpdate(null, request, predicates, sqlTree).getSql();
-    sql = updateClause + " " + request.getBeanDescriptor().getWhereIdInSql() + "in (" + sql + ")";
+    sql = updateClause + " " + request.descriptor().getWhereIdInSql() + "in (" + sql + ")";
     sql = aliasReplace(sql, alias(rootTableAlias));
     return sql;
   }
@@ -177,17 +177,17 @@ final class CQueryBuilder {
   }
 
   CQueryFetchSingleAttribute buildFetchAttributeQuery(OrmQueryRequest<?> request) {
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     query.setSingleAttribute();
     if (!query.isIncludeSoftDeletes()) {
-      BeanDescriptor<?> desc = request.getBeanDescriptor();
+      BeanDescriptor<?> desc = request.descriptor();
       if (desc.isSoftDelete()) {
         query.addSoftDeletePredicate(desc.getSoftDeletePredicate(alias(query.getAlias())));
       }
     }
 
     CQueryPredicates predicates = new CQueryPredicates(binder, request);
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       predicates.prepare(false);
       return new CQueryFetchSingleAttribute(request, predicates, queryPlan, query.isCountDistinct());
@@ -208,9 +208,9 @@ final class CQueryBuilder {
    * Build the find ids query.
    */
   <T> CQueryFetchSingleAttribute buildFetchIdsQuery(OrmQueryRequest<T> request) {
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
     query.setSelectId();
-    BeanDescriptor<T> desc = request.getBeanDescriptor();
+    BeanDescriptor<T> desc = request.descriptor();
     if (!query.isIncludeSoftDeletes() && desc.isSoftDelete()) {
       query.addSoftDeletePredicate(desc.getSoftDeletePredicate(alias(query.getAlias())));
     }
@@ -235,7 +235,7 @@ final class CQueryBuilder {
    * Build the row count query.
    */
   <T> CQueryRowCount buildRowCountQuery(OrmQueryRequest<T> request) {
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
     // always set the order by to null for row count query
     query.setOrder(null);
     query.setFirstRow(0);
@@ -252,7 +252,7 @@ final class CQueryBuilder {
     }
 
     CQueryPredicates predicates = new CQueryPredicates(binder, request);
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       // skip building the SqlTree and Sql string
       predicates.prepare(false);
@@ -304,7 +304,7 @@ final class CQueryBuilder {
    * Return true if the query includes an aggregation property.
    */
   private <T> boolean includesAggregation(OrmQueryRequest<T> request, SpiQuery<T> query) {
-    return request.getBeanDescriptor().includesAggregation(query.getDetail());
+    return request.descriptor().includesAggregation(query.getDetail());
   }
 
   private String wrapSelectCount(String sql) {
@@ -321,7 +321,7 @@ final class CQueryBuilder {
    */
   <T> CQuery<T> buildQuery(OrmQueryRequest<T> request) {
     CQueryPredicates predicates = new CQueryPredicates(binder, request);
-    CQueryPlan queryPlan = request.getQueryPlan();
+    CQueryPlan queryPlan = request.queryPlan();
     if (queryPlan != null) {
       // Reuse the query plan so skip generating SqlTree and SQL.
       // We do prepare and bind the new parameters
@@ -340,7 +340,7 @@ final class CQueryBuilder {
     predicates.prepare(true);
 
     // Build the tree structure that represents the query.
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
 
     SqlTree sqlTree = createSqlTree(request, predicates);
     if (query.isAsOfQuery()) {
@@ -358,7 +358,7 @@ final class CQueryBuilder {
       queryPlan = new CQueryPlan(request, res, sqlTree, false, predicates.getLogWhereSql());
     }
 
-    BeanDescriptor<T> desc = request.getBeanDescriptor();
+    BeanDescriptor<T> desc = request.descriptor();
     if (desc.isReadAuditing()) {
       // log the query plan based bean type (i.e. ignoring query disabling for logging the sql/plan)
       desc.getReadAuditLogger().queryPlan(new ReadAuditQueryPlan(desc.getFullName(), queryPlan.getAuditQueryKey(), queryPlan.getSql()));
@@ -401,7 +401,7 @@ final class CQueryBuilder {
    * Create the SqlTree by reading the ResultSetMetaData and mapping table/columns to bean property paths.
    */
   private SqlTree createNativeSqlTree(OrmQueryRequest<?> request, CQueryPredicates predicates) {
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     // parse named parameters returning the final sql to execute
     String sql = predicates.parseBindParams(query.getNativeSql());
     if (query.hasMaxRowsOrFirstRow()) {
@@ -409,9 +409,9 @@ final class CQueryBuilder {
     }
     query.setGeneratedSql(sql);
 
-    Connection connection = request.getTransaction().getConnection();
+    Connection connection = request.transaction().getConnection();
 
-    BeanDescriptor<?> desc = request.getBeanDescriptor();
+    BeanDescriptor<?> desc = request.descriptor();
     try {
       // For SqlServer we need either "selectMethod=cursor" in the connection string or fetch explicitly a cursorable
       // statement here by specifying ResultSet.CONCUR_UPDATABLE
@@ -445,8 +445,8 @@ final class CQueryBuilder {
   }
 
   private SqlTree createRawSqlSqlTree(OrmQueryRequest<?> request, CQueryPredicates predicates) {
-    BeanDescriptor<?> descriptor = request.getBeanDescriptor();
-    ColumnMapping columnMapping = request.getQuery().getRawSql().getColumnMapping();
+    BeanDescriptor<?> descriptor = request.descriptor();
+    ColumnMapping columnMapping = request.query().getRawSql().getColumnMapping();
     PathProperties pathProps = new PathProperties();
 
     // convert list of columns into (tree like) PathProperties
@@ -523,7 +523,7 @@ final class CQueryBuilder {
    * Return the SQL response with row limiting (when not an update statement).
    */
   private SqlLimitResponse buildSql(String selectClause, OrmQueryRequest<?> request, CQueryPredicates predicates, SqlTree select) {
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     if (query.isNativeSql()) {
       return new SqlLimitResponse(query.getGeneratedSql());
     }
@@ -562,7 +562,7 @@ final class CQueryBuilder {
     private BuildReq(String selectClause, OrmQueryRequest<?> request, CQueryPredicates predicates, SqlTree select, boolean updateStatement) {
       this.selectClause = selectClause;
       this.request = request;
-      this.query = request.getQuery();
+      this.query = request.query();
       this.predicates = predicates;
       this.select = select;
       this.updateStatement = updateStatement;
@@ -583,7 +583,7 @@ final class CQueryBuilder {
           sb.append("r1.attribute_, count(*) from (select ");
           if (distinct) {
             sb.append("distinct t0.");
-            sb.append(request.getBeanDescriptor().getIdProperty().getDbColumn()).append(", ");
+            sb.append(request.descriptor().getIdProperty().getDbColumn()).append(", ");
           }
           sb.append(select.getSelectSql()).append(" as attribute_");
         } else {
@@ -652,7 +652,7 @@ final class CQueryBuilder {
     private void appendHistoryAsOfPredicate() {
       if (query.isAsOfBaseTable() && !historySupport.isStandardsBased()) {
         appendAndOrWhere();
-        sb.append(historySupport.getAsOfPredicate(request.getBaseTableAlias()));
+        sb.append(historySupport.getAsOfPredicate(request.baseTableAlias()));
       }
     }
 
@@ -660,7 +660,7 @@ final class CQueryBuilder {
       if (request.isFindById() || query.getId() != null) {
         appendAndOrWhere();
 
-        BeanDescriptor<?> desc = request.getBeanDescriptor();
+        BeanDescriptor<?> desc = request.descriptor();
         String idSql = desc.getIdBinderIdSql(query.getAlias());
         if (idSql.isEmpty()) {
           throw new IllegalStateException("Executing FindById query on entity bean " + desc.getName()

ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryBuilderRawSql.java

@@ -33,7 +33,7 @@ final class CQueryBuilderRawSql {
 
     if (!rsql.isParsed()) {
       String sql = rsql.getUnparsedSql();
-      BindParams bindParams = request.getQuery().getBindParams();
+      BindParams bindParams = request.query().getBindParams();
       if (bindParams != null && bindParams.requiresNamedParamsPrepare()) {
         // convert named parameters into positioned parameters
         sql = BindParamsParser.parse(bindParams, sql);
@@ -46,7 +46,7 @@ final class CQueryBuilderRawSql {
     // build the actual sql String
     String sql = buildMainQuery(orderBy, request, predicates, rsql);
 
-    SpiQuery<?> query = request.getQuery();
+    SpiQuery<?> query = request.query();
     if (query.hasMaxRowsOrFirstRow() && sqlLimiter != null) {
       // wrap with a limit offset or ROW_NUMBER() etc
       return sqlLimiter.limit(new OrmQueryLimitRequest(sql, orderBy, query, dbPlatform, rsql.isDistinct() || query.isDistinct()));
@@ -66,7 +66,7 @@ final class CQueryBuilderRawSql {
     sb.append(" ");
 
     String s = sql.getPreWhere();
-    BindParams bindParams = request.getQuery().getBindParams();
+    BindParams bindParams = request.query().getBindParams();
     if (bindParams != null && bindParams.requiresNamedParamsPrepare()) {
       // convert named parameters into positioned parameters
       // Named Parameters only allowed prior to dynamic where
@@ -77,12 +77,12 @@ final class CQueryBuilderRawSql {
     sb.append(" ");
 
     String dynamicWhere = null;
-    if (request.getQuery().getId() != null) {
+    if (request.query().getId() != null) {
       // need to convert this as well. This avoids the
       // assumption that id has its proper dbColumn assigned
       // which may change if using multiple raw sql statements
       // against the same bean.
-      BeanDescriptor<?> descriptor = request.getBeanDescriptor();
+      BeanDescriptor<?> descriptor = request.descriptor();
       //FIXME: I think this is broken... needs to be logical
       // and then parsed for RawSqlSelect...
       dynamicWhere = descriptor.getIdBinderIdSql(null);

ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java

@@ -79,7 +79,7 @@ public final class CQueryEngine {
   private <T> int executeUpdate(OrmQueryRequest<T> request, CQueryUpdate query) {
     try {
       int rows = query.execute();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         request.logSql(Str.add(query.getGeneratedSql(), "; --bind(", query.getBindLog(), ") --micros(", query.micros() + ") --rows(", rows + ")"));
       }
       return rows;
@@ -101,17 +101,17 @@ public final class CQueryEngine {
   private <A> List<A> findAttributeList(OrmQueryRequest<?> request, CQueryFetchSingleAttribute rcQuery) {
     try {
       List<A> list = (List<A>) rcQuery.findList();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logGeneratedSql(request, rcQuery.getGeneratedSql(), rcQuery.getBindLog(), rcQuery.micros());
       }
-      if (request.isLogSummary()) {
-        request.getTransaction().logSummary(rcQuery.getSummary());
+      if (request.logSummary()) {
+        request.transaction().logSummary(rcQuery.getSummary());
       }
       if (request.isQueryCachePut()) {
         request.addDependentTables(rcQuery.getDependentTables());
         list = Collections.unmodifiableList(list);
         request.putToQueryCache(list);
-        if (Boolean.FALSE.equals(request.getQuery().isReadOnly())) {
+        if (Boolean.FALSE.equals(request.query().isReadOnly())) {
           list = new ArrayList<>(list);
         }
       }
@@ -125,7 +125,7 @@ public final class CQueryEngine {
    * Translate the SQLException into a PersistenceException.
    */
   <T> PersistenceException translate(OrmQueryRequest<T> request, String bindLog, String sql, SQLException e) {
-    SpiTransaction t = request.getTransaction();
+    SpiTransaction t = request.transaction();
     if (t.isLogSummary()) {
       // log the error to the transaction log
       String msg = "ERROR executing query, bindLog[" + bindLog + "] error[" + StringHelper.removeNewLines(e.getMessage()) + "]";
@@ -159,14 +159,14 @@ public final class CQueryEngine {
     request.setCancelableQuery(rcQuery);
     try {
       int count = rcQuery.findCount();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logGeneratedSql(request, rcQuery.getGeneratedSql(), rcQuery.getBindLog(), rcQuery.micros());
       }
-      if (request.isLogSummary()) {
-        request.getTransaction().logSummary(rcQuery.getSummary());
+      if (request.logSummary()) {
+        request.transaction().logSummary(rcQuery.getSummary());
       }
-      if (request.getQuery().isFutureFetch()) {
-        request.getTransaction().end();
+      if (request.query().isFutureFetch()) {
+        request.transaction().end();
       }
       if (request.isQueryCachePut()) {
         request.addDependentTables(rcQuery.getDependentTables());
@@ -194,14 +194,14 @@ public final class CQueryEngine {
         logger.trace("Future fetch already cancelled");
         return null;
       }
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       // first check batch sizes set on query joins
-      int iterateBufferSize = request.getSecondaryQueriesMinBatchSize();
+      int iterateBufferSize = request.secondaryQueriesMinBatchSize();
       if (iterateBufferSize < 1) {
         // not set on query joins so check if batch size set on query itself
-        int queryBatch = request.getQuery().getLazyLoadBatchSize();
+        int queryBatch = request.query().getLazyLoadBatchSize();
         if (queryBatch > 0) {
           iterateBufferSize = queryBatch;
         } else {
@@ -210,7 +210,7 @@ public final class CQueryEngine {
       }
 
       QueryIterator<T> readIterate = cquery.readIterate(iterateBufferSize, request);
-      if (request.isLogSummary()) {
+      if (request.logSummary()) {
         logFindManySummary(cquery);
       }
       if (request.isAuditReads()) {
@@ -235,7 +235,7 @@ public final class CQueryEngine {
    * Execute the find versions query returning version beans.
    */
   public <T> List<Version<T>> findVersions(OrmQueryRequest<T> request) {
-    SpiQuery<T> query = request.getQuery();
+    SpiQuery<T> query = request.query();
     String sysPeriodLower = getSysPeriodLower(query);
     if (query.isVersionsBetween() && !historySupport.isStandardsBased()) {
       query.where().lt(sysPeriodLower, query.getVersionEnd());
@@ -248,7 +248,7 @@ public final class CQueryEngine {
     request.setCancelableQuery(cquery);
     try {
       cquery.prepareBindExecuteQuery();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       List<Version<T>> versions = cquery.readVersions();
@@ -256,7 +256,7 @@ public final class CQueryEngine {
       // is not universally supported, not expect huge list here
       versions.sort(OrderVersionDesc.INSTANCE);
       deriveVersionDiffs(versions, request);
-      if (request.isLogSummary()) {
+      if (request.logSummary()) {
         logFindManySummary(cquery);
       }
       if (request.isAuditReads()) {
@@ -274,7 +274,7 @@ public final class CQueryEngine {
   }
 
   private <T> void deriveVersionDiffs(List<Version<T>> versions, OrmQueryRequest<T> request) {
-    BeanDescriptor<T> descriptor = request.getBeanDescriptor();
+    BeanDescriptor<T> descriptor = request.descriptor();
     if (!versions.isEmpty()) {
       Version<T> current = versions.get(0);
       if (versions.size() > 1) {
@@ -324,7 +324,7 @@ public final class CQueryEngine {
         }
       }
       ResultSet resultSet = cquery.prepareResultSet(fwdOnly);
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       return new SpiResultSet(cquery.getPstmt(), resultSet);
@@ -350,11 +350,11 @@ public final class CQueryEngine {
         logger.trace("Future fetch already cancelled");
         return null;
       }
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       BeanCollection<T> beanCollection = cquery.readCollection();
-      if (request.isLogSummary()) {
+      if (request.logSummary()) {
         logFindManySummary(cquery);
       }
       if (request.isAuditReads()) {
@@ -385,13 +385,13 @@ public final class CQueryEngine {
     request.setCancelableQuery(cquery);
     try {
       cquery.prepareBindExecuteQuery();
-      if (request.isLogSql()) {
+      if (request.logSql()) {
         logSql(cquery);
       }
       if (cquery.readBean()) {
         bean = cquery.next();
       }
-      if (request.isLogSummary()) {
+      if (request.logSummary()) {
         logFindBeanSummary(cquery);
       }
       if (request.isAuditReads()) {
@@ -417,7 +417,7 @@ public final class CQueryEngine {
    * Log the FindById summary to the transaction log.
    */
   private void logFindBeanSummary(CQuery<?> q) {
-    SpiQuery<?> query = q.getQueryRequest().getQuery();
+    SpiQuery<?> query = q.getQueryRequest().query();
     String loadMode = query.getLoadMode();
     String loadDesc = query.getLoadDescription();
     String lazyLoadProp = query.getLazyLoadProperty();
@@ -460,7 +460,7 @@ public final class CQueryEngine {
    * Log the FindMany to the transaction log.
    */
   private void logFindManySummary(CQuery<?> q) {
-    SpiQuery<?> query = q.getQueryRequest().getQuery();
+    SpiQuery<?> query = q.getQueryRequest().query();
     String loadMode = query.getLoadMode();
     String loadDesc = query.getLoadDescription();
     String lazyLoadProp = query.getLazyLoadProperty();

ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryFetchSingleAttribute.java

@@ -50,9 +50,9 @@ final class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent, Ca
   CQueryFetchSingleAttribute(OrmQueryRequest<?> request, CQueryPredicates predicates, CQueryPlan queryPlan, boolean containsCounts) {
     this.request = request;
     this.queryPlan = queryPlan;
-    this.query = request.getQuery();
+    this.query = request.query();
     this.sql = queryPlan.getSql();
-    this.desc = request.getBeanDescriptor();
+    this.desc = request.descriptor();
     this.predicates = predicates;
     this.containsCounts = containsCounts;
     this.reader = queryPlan.getSingleAttributeScalarType();
@@ -105,7 +105,7 @@ final class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent, Ca
   }
 
   private SpiTransaction getTransaction() {
-    return request.getTransaction();
+    return request.transaction();
   }
 
   /**
@@ -140,7 +140,7 @@ final class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent, Ca
     } finally {
       lock.unlock();
     }
-    dataReader = new RsetDataReader(request.getDataTimeZone(), pstmt.executeQuery());
+    dataReader = new RsetDataReader(request.dataTimeZone(), pstmt.executeQuery());
     query.checkCancelled();
   }