[maven-release-plugin] prepare release ebean-11.15.3

Add element collection L2 cache support

.editorconfig

@@ -10,3 +10,4 @@ indent_style = space
 insert_final_newline = true
 trim_trailing_whitespace = true
 spaces_around_operators = true
+max_line_length = 130

.gitignore

@@ -20,3 +20,4 @@ profiling/
 *.ipr
 *.iws
 .idea/
+*uuid.state

.travis.yml

@@ -9,16 +9,27 @@ git:
 
 addons:
   postgresql: "9.6"
+#  apt:
+#    packages:
+#    - mysql-server-5.7
+#    - mysql-client-core-5.7
+#    - mysql-client-5.7
 
 services:
+  - docker
   - postgresql
+  - mysql
 
 before_script:
   - ./.travis/setup_database
+  - mysql -u root -e 'CREATE DATABASE test_ebean;'
+  - mysql -u root -e "CREATE USER 'test_ebean'@'localhost' IDENTIFIED BY 'test';"
+  - mysql -u root -e "GRANT ALL ON test_ebean.* TO 'test_ebean'@'localhost';"
 
 env:
   - EBEAN_DB=h2
   - EBEAN_DB=pg
+#  - EBEAN_DB=mysql
 
 install: true
 

CONFIGURATION.md

@@ -0,0 +1,298 @@
+Overview of ebean.properties file
+=================================
+
+
+### DbMigration options
+
+You can set individual values for different platforms when generating migrations
+
+`dbmigration.platform.<PLATFORM>.databaseSequenceBatchSize`
+For DB's using sequences this is the number of sequence values prefetched.
+ 
+`dbmigration.platform.<PLATFORM>.dbuuid`
+Control, how UUID generation should work - it affects DDL which column type is generated. Possible values:
+- BINARY enforces binary UUID 
+- VARCHAR enforces varchar UUID
+- BINARY_OPTIMIZED enforces binary-optimized UUID (makes sense only with Type1 ID)
+- AUTO_BINARY use binary when platform does not support native UUID
+- AUTO_BINARY_OPTIMIZED use binary-optimized when platform does not support native UUID
+- AUTO_VARCHAR (default) use varchar when platform does not support UUID 
+
+`dbmigration.platform.<PLATFORM>.uuidStoreAsBinary`
+Same as setting dbuuid to BINARY
+
+`dbmigration.platform.<PLATFORM>.geometrySRID`
+The Geometry SRID value (default 4326).
+
+`dbmigration.platform.<PLATFORM>.idType`
+The ID type (IDENTITY, SEQUENCE, GENERATOR, EXTERNAL)
+
+`dbmigration.platform.<PLATFORM>.mapping`
+Adjust the mapping. For example `BOOLEAN=integer(32);BIT=tinyint(3)`
+
+
+`ebean.migration.applyPrefix`
+Set this to "V" to be compatible with FlywayDB.
+
+`ebean.migration.applySuffix`
+Defaults to '.sql'
+
+`ebean.migration.dbusername`
+DB user used to run the DB migration.
+
+`ebean.migration.dbpassword`
+DB password used to run the DB migration.
+
+`ebean.migration.generate`
+Set to true if the DB migration should be generated on server start.
+
+`ebean.migration.generatePendingDrop`
+The version of a pending drop that should be generated as the next migration.
+
+`ebean.migration.includeGeneratedFileComment`
+TODO
+
+`ebean.migration.metaTable`
+For running migration the DB table that holds migration execution status. Default 'db_migration'
+
+`ebean.migration.migrationPath`
+Resource path for the migration xml and sql.
+
+`ebean.migration.modelPath`
+Subdirectory the model xml files go into. Default 'model'
+
+`ebean.migration.modelSuffix`
+Suffix. Default '.model.xml' 
+
+`ebean.migration.name`
+Description text that can be appended to the version to become the ddl script file name
+ 
+`ebean.migration.patchInsertOn`
+migration versions that should be added to history without running.
+
+`ebean.migration.patchResetChecksumOn`
+migration versions that should have their checksum reset and not run.
+Use this if you get a 'Checksum mismatch' error.
+
+`ebean.migration.placeholders`
+A comma and equals delimited placeholders that are substituted in SQL scripts when running migration (used by DB Migration runner only).
+
+`ebean.migration.platform`
+The database platform to generate migration DDL for.
+
+`ebean.migration.run`
+Flag set to true means to run any outstanding migrations on startup.
+
+`ebean.migration.version`
+The migration version name (typically FlywayDb compatible). Example: 1.1.1_2
+
+
+### Ebean UUID options
+
+`ebean.uuidVersion`
+Controls, how the UUIDs are generated. Possible values
+- VERSION4 (default) generate random V4 UUIDs,
+- VERSION1 generate rfc4122 compliant Type 1 UUIDs (requires a state file)
+- VERSION1RND generate fake Type 1 UUIDs
+
+Note, that V1 UUIDs in conjunction with AUTO_BINARY_OPTIMIZED will give you the best index performance, but you MUST understand how this works to avoid collisions.
+
+`ebean.uuidStateFile`
+The state file that is Required to generate V1 UUIDs
+
+
+### DocStoreConfig
+
+`ebean.docstore.active`
+True when the Document store integration is active/on.
+
+`ebean.docstore.allowAllCertificates`
+Set to true such that the client allows connections to invalid/self signed SSL certificates.
+
+`ebean.docstore.bulkBatchSize`
+The default batch size to use for the Bulk API calls.
+
+`ebean.docstore.create`
+When true the Document store should create any document indexes that don't already exist.
+
+`ebean.docstore.dropCreate`
+When true the Document store should drop and re-create document indexes.
+
+`ebean.docstore.generateMapping`
+Set to true means Ebean will generate mapping files on startup.
+
+`ebean.docstore.mappingPath`
+Resource path for the Document store mapping files.
+
+`ebean.docstore.mappingSuffix`
+Suffix used for mapping files.
+
+`ebean.docstore.password`
+ Password credential that be used for authentication to document store.
+ 
+`ebean.docstore.pathToResources`
+Location of resources that mapping files are generated into.
+
+`ebean.docstore.persist`
+The default mode used by indexes. `DEFAULT|IGNORE|QUEUE|UPDATE`
+
+`ebean.docstore.url`
+The URL of the Document store server. For example: http://localhost:9200.
+
+`ebean.docstore.username`
+Credential that be used for authentication to document store.
+
+### Ebean Autotune
+
+`ebean.autoTune.mode`
+The autoTune mode `DEFAULT_OFF|DEFAULT_ON|DEFAULT_ONIFEMPTY`
+
+`ebean.autoTune.profiling`
+TODO
+
+`ebean.autoTune.profilingBase`
+TODO
+
+`ebean.autoTune.profilingFile`
+TODO
+
+`ebean.autoTune.profilingRate`
+TODO
+
+`ebean.autoTune.profilingUpdateFrequency`
+TODO
+
+`ebean.autoTune.queryTuning`
+TODO
+
+`ebean.autoTune.queryTuningAddVersion`
+TODO
+
+`ebean.autoTune.queryTuningFile`
+TODO
+
+`ebean.autoTune.skipGarbageCollectionOnShutdown`
+TODO
+
+`ebean.autoTune.skipProfileReportingOnShutdown`
+TODO
+
+
+### Ebean options
+`ebean.allQuotedIdentifiers`
+Quote all identifiers
+
+`ebean.asOfSysPeriod`
+Column used to support history and 'As of' queries. This column is a timestamp range or equivalent.
+
+`ebean.asOfViewSuffix`
+Suffix appended to the base table to derive the view that contains the union of the base table and the history table in order to support asOf queries.
+
+`ebean.autoCommitMode`
+Set to true if the DataSource uses autoCommit. Indicates that Ebean should use autoCommit friendly Transactions and TransactionManager.
+
+`ebean.autoReadOnlyDataSource`
+When true create a read only DataSource using readOnlyDataSourceConfig defaulting values from dataSourceConfig
+
+`ebean.autostart`
+Should the server start all
+
+`ebean.backgroundExecutorSchedulePoolSize`
+TODO
+
+`ebean.backgroundExecutorShutdownSecs`
+TODO
+
+and some more todos:
+`ebean.batch.mode`
+`ebean.batch.size`
+`ebean.changeLogAsync`
+`ebean.changeLogIncludeInserts`
+`ebean.classes`
+`ebean.collectQueryOrigins`
+`ebean.collectQueryStatsByNode`
+`ebean.currentUserProvider`
+`ebean.dataSourceJndiName`
+`ebean.dataTimeZone`
+`ebean.databaseBooleanFalse`
+`ebean.databaseBooleanTrue`
+`ebean.databasePlatform`
+`ebean.databasePlatformName`
+`ebean.databaseSequenceBatchSize`
+ebean.datasource.h2.adminpassword
+ebean.datasource.h2.adminusername
+`ebean.dbEncrypt`
+`ebean.dbOffline`
+ebean.ddl.createOnly
+ebean.ddl.generate
+ebean.ddl.header
+ebean.ddl.initSql
+ebean.ddl.run
+ebean.ddl.seedSql
+ebean.defaultDeleteMissingChildren
+ebean.defaultOrderById
+ebean.disableClasspathSearch
+ebean.disableL2Cache
+ebean.docStoreOnly
+ebean.docstore.active
+ebean.docstore.allowAllCertificates
+ebean.docstore.bulkBatchSize
+ebean.docstore.create
+ebean.docstore.dropCreate
+ebean.docstore.generateMapping
+ebean.docstore.mappingPath
+ebean.docstore.mappingSuffix
+ebean.docstore.password
+ebean.docstore.pathToResources
+ebean.docstore.persist
+ebean.docstore.url
+ebean.docstore.username
+ebean.encryptDeployManager
+ebean.encryptKeyManager
+ebean.encryptor
+ebean.explicitTransactionBeginMode
+ebean.expressionEqualsWithNullAsNoop
+ebean.expressionNativeIlike
+ebean.geometrySRID
+ebean.historyTableSuffix
+ebean.jdbcFetchSizeFindEach
+ebean.jdbcFetchSizeFindList
+ebean.jodaLocalTimeMode
+ebean.jsonDateTime
+ebean.jsonInclude
+ebean.lazyLoadBatchSize
+ebean.localTimeWithNanos
+ebean.namingConvention.schema
+ebean.namingConvention.sequenceFormat
+ebean.namingConvention.useForeignKeyPrefix
+ebean.namingconvention
+ebean.notifyL2CacheInForeground
+ebean.packages
+ebean.persistBatch
+ebean.persistBatchOnCascade
+ebean.persistBatchSize
+ebean.persistBatching
+ebean.persistenceContextScope
+ebean.profiling
+ebean.profiling.directory
+ebean.profiling.includeProfileIds
+ebean.profiling.minimumMicros
+ebean.profiling.profilesPerFile
+ebean.profiling.verbose
+ebean.queryBatchSize
+ebean.queryPlanTTLSeconds
+ebean.search.packages
+ebean.serverCachePlugin
+ebean.skipCacheAfterWrite
+ebean.slowQueryMillis
+ebean.tenant.catalogProvider
+ebean.tenant.currentTenantProvider
+ebean.tenant.mode
+ebean.tenant.partitionColumn
+ebean.tenant.schemaProvider
+ebean.updateAllPropertiesInBatch
+ebean.updateChangesOnly
+ebean.updatesDeleteMissingChildren
+ebean.useJavaxValidationNotNull
+ebean.useJtaTransactionManager
+

howto-test.md

@@ -48,7 +48,8 @@ Reqirements
 run: `mvn clean test -Ddatasource.default=pg`
 
 Current status: PASS
-Tests run: 1986, Failures: 0, Errors: 0, Skipped: 16
+Tests run: 2166, Failures: 0, Errors: 0, Skipped: 25
+
 
 
 'mysql' platform
@@ -61,8 +62,8 @@ Reqirements
 
 run: `mvn clean test -Ddatasource.default=mysql`
 
-Current status: FAIL
-Tests run: 1986, Failures: 2, Errors: 4, Skipped: 16
+Current status: PASS
+Tests run: 2166, Failures: 0, Errors: 0, Skipped: 33
 
 
 
@@ -76,8 +77,8 @@ Reqires an installed sqlserver - e.g. https://hub.docker.com/r/microsoft/mssql-s
   
 run: `mvn clean test -Ddatasource.default=mssql`
 
-Current status: FAIL
-Tests run: 1986, Failures: 19, Errors: 43, Skipped: 16
+Current status: PASS
+Tests run: 2166, Failures: 0, Errors: 0, Skipped: 39
 
 
 
@@ -107,7 +108,7 @@ Reqires a locally installed DB2 Express-C server.
 run: `mvn clean test -Ddatasource.default=db2 -Pdb2`
 
 Current status: FAIL
-Tests run: 1986, Failures: 33, Errors: 26, Skipped: 16
+Tests run: 2166, Failures: 29, Errors: 58, Skipped: 30
 
 
 'sqlite' platform

pom.xml

@@ -9,7 +9,7 @@
 
   <groupId>io.ebean</groupId>
   <artifactId>ebean</artifactId>
-  <version>11.10.2</version>
+  <version>11.15.3</version>
   <packaging>jar</packaging>
 
   <name>ebean</name>
@@ -17,7 +17,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-11.10.2</tag>
+    <tag>ebean-11.15.3</tag>
   </scm>
 
   <profiles>
@@ -83,6 +83,15 @@
       <scope>provided</scope>
     </dependency>
 
+    <!--
+    Exclude snakeyaml if you desire - it is not strictly required.
+    -->
+    <dependency>
+      <groupId>org.yaml</groupId>
+      <artifactId>snakeyaml</artifactId>
+      <version>1.19</version>
+    </dependency>
+
     <!--
     Class retention Nonnull and Nullable annotations
     to assist with IDE auto-completion with Ebean API
@@ -103,13 +112,13 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>3.6</version>
+      <version>3.11</version>
     </dependency>
 
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-datasource</artifactId>
-      <version>3.1.1</version>
+      <version>3.2.2</version>
     </dependency>
 
     <dependency>
@@ -121,13 +130,13 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-migration</artifactId>
-      <version>11.3.1</version>
+      <version>11.5.1</version>
     </dependency>
 
     <dependency>
       <groupId>org.antlr</groupId>
       <artifactId>antlr4-runtime</artifactId>
-      <version>4.6</version>
+      <version>4.7.1</version>
     </dependency>
 
     <!-- Jackson core used internally by Ebean -->
@@ -191,12 +200,12 @@
       <!--<scope>test</scope>-->
     <!--</dependency>-->
 
-    <!--<dependency>-->
-      <!--<groupId>microsoft</groupId>-->
-      <!--<artifactId>sqlserver-jdbc</artifactId>-->
-      <!--<version>4.2</version>-->
-      <!--<scope>test</scope>-->
-    <!--</dependency>-->
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-docker-run</artifactId>
+      <version>1.5.1</version>
+      <scope>test</scope>
+    </dependency>
 
     <dependency>
       <groupId>ch.qos.logback</groupId>
@@ -215,7 +224,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-agent</artifactId>
-      <version>11.9.1</version>
+      <version>11.11.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -245,7 +254,7 @@
     <dependency>
       <groupId>com.microsoft.sqlserver</groupId>
       <artifactId>mssql-jdbc</artifactId>
-      <version>6.1.3.jre8-preview</version>
+      <version>6.4.0.jre8</version>
       <scope>test</scope>
     </dependency>
 
@@ -288,7 +297,7 @@
       <plugin>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-maven-plugin</artifactId>
-        <version>11.9.1</version>
+        <version>11.11.1</version>
         <executions>
           <execution>
             <id>test</id>
@@ -321,6 +330,11 @@
               <name>datasource.default</name>
               <value>${datasource.default}</value>
             </property>
+            <property>
+              <!-- transfer dbClockDelta parameter -->
+              <name>dbClockDelta</name>
+              <value>${dbClockDelta}</value>
+            </property>
           </systemProperties>
         </configuration>
       </plugin>

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

@@ -0,0 +1,169 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Provides finder functionality for use with "Dependency Injection style" use of Ebean.
+ * <p>
+ * Note that typically users would extend BeanRepository rather than BeanFinder.
+ * </p>
+ * <pre>{@code
+ *
+ * public class CustomerFinder extends BeanFinder<Long,Customer> {
+ *
+ *   @Inject
+ *   public CustomerFinder(EbeanServer server) {
+ *     super(Customer.class, server);
+ *   }
+ *
+ *   // ... add customer specific finders
+ * }
+ *
+ * }</pre>
+ *
+ * @param <I> The ID type
+ * @param <T> The Bean type
+ */
+public abstract class BeanFinder<I,T> {
+
+  protected final EbeanServer server;
+
+  protected final Class<T> type;
+
+  /**
+   * Create with the given bean type and EbeanServer instance.
+   *
+   * @param type The bean type
+   * @param server The EbeanServer instance typically created via Spring factory or equivalent.
+   */
+  protected BeanFinder(Class<T> type, EbeanServer server) {
+    this.type = type;
+    this.server = server;
+  }
+
+  /**
+   * Return the EbeanServer to use.
+   */
+  public EbeanServer db() {
+    return server;
+  }
+
+  /**
+   * Return the current transaction.
+   */
+  public Transaction currentTransaction() {
+    return db().currentTransaction();
+  }
+
+  /**
+   * Flush the JDBC batch on the current transaction.
+   */
+  public void flush() {
+    db().flush();
+  }
+
+  /**
+   * Return typically a different EbeanServer to the default.
+   * <p>
+   * This is equivalent to {@link Ebean#getServer(String)}
+   *
+   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is
+   *               returned.
+   */
+  public EbeanServer db(String server) {
+    return Ebean.getServer(server);
+  }
+
+  /**
+   * Creates an entity reference for this ID.
+   * <p>
+   * Equivalent to {@link EbeanServer#getReference(Class, Object)}
+   */
+  @Nonnull
+  public T ref(I id) {
+    return db().getReference(type, id);
+  }
+
+  /**
+   * Retrieves an entity by ID.
+   * <p>
+   * Equivalent to {@link EbeanServer#find(Class, Object)}
+   */
+  @Nullable
+  public T findById(I id) {
+    return db().find(type, id);
+  }
+
+  /**
+   * Find an entity by ID returning an Optional.
+   */
+  @Nullable
+  public Optional<T> findByIdOrEmpty(I id) {
+    return db().find(type).setId(id).findOneOrEmpty();
+  }
+
+  /**
+   * Delete a bean by Id.
+   * <p>
+   * Equivalent to {@link EbeanServer#delete(Class, Object)}
+   */
+  public void deleteById(I id) {
+    db().delete(type, id);
+  }
+
+  /**
+   * Retrieves all entities of the given type.
+   */
+  @Nonnull
+  public List<T> findAll() {
+    return query().findList();
+  }
+
+  /**
+   * Creates an update query.
+   *
+   * <pre>{@code
+   *
+   *  int rows =
+   *      updateQuery()
+   *      .set("status", Customer.Status.ACTIVE)
+   *      .set("updtime", new Timestamp(System.currentTimeMillis()))
+   *      .where()
+   *        .gt("id", 1000)
+   *        .update();
+   *
+   * }</pre>
+   *
+   * <p>
+   * Equivalent to {@link EbeanServer#update(Class)}
+   */
+  protected UpdateQuery<T> updateQuery() {
+    return db().update(type);
+  }
+
+  /**
+   * Creates a query.
+   * <p>
+   * Equivalent to {@link EbeanServer#find(Class)}
+   */
+  protected Query<T> query() {
+    return db().find(type);
+  }
+
+  /**
+   * Creates a native sql query.
+   */
+  protected Query<T> nativeSql(String nativeSql) {
+    return db().findNative(type, nativeSql);
+  }
+
+  /**
+   * Creates a query using the ORM query language.
+   */
+  protected Query<T> query(String ormQuery) {
+    return db().createQuery(type, ormQuery);
+  }
+}

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

@@ -0,0 +1,178 @@
+package io.ebean;
+
+import io.ebean.bean.EntityBean;
+
+/**
+ * Provides finder functionality for use with "Dependency Injection style" use of Ebean.
+ * <p>
+ * <pre>{@code
+ *
+ * @Repository
+ * public class CustomerRepository extends BeanRepository<Long,Customer> {
+ *
+ *   @Inject
+ *   public CustomerRepository(EbeanServer server) {
+ *     super(Customer.class, server);
+ *   }
+ *
+ *   // ... add customer specific finders and persist logic
+ *
+ *   public List<Customer> findByName(String nameStart) {
+ *     return query().where()
+ *             .istartsWith("name", nameStart)
+ *             .findList();
+ *   }
+ *
+ * }
+ * }</pre>
+ *
+ * @param <I> The ID type
+ * @param <T> The Bean type
+ */
+public abstract class BeanRepository<I, T> extends BeanFinder<I, T> {
+
+  /**
+   * Create with the given bean type and EbeanServer instance.
+   * <p>
+   * Typically users would extend BeanRepository rather than BeanFinder.
+   * </p>
+   * <pre>{@code
+   *
+   *   @Inject
+   *   public CustomerRepository(EbeanServer server) {
+   *     super(Customer.class, server);
+   *   }
+   *
+   * }</pre>
+   *
+   * @param type   The bean type
+   * @param server The EbeanServer instance typically created via Spring factory or equivalent
+   */
+  protected BeanRepository(Class<T> type, EbeanServer server) {
+    super(type, server);
+  }
+
+  /**
+   * Marks the entity bean as dirty.
+   * <p>
+   * This is used so that when a bean that is otherwise unmodified is updated the version
+   * property is updated.
+   * <p>
+   * An unmodified bean that is saved or updated is normally skipped and this marks the bean as
+   * dirty so that it is not skipped.
+   * <p>
+   * <pre>{@code
+   *
+   * Customer customer = customerRepository.byId(id);
+   *
+   * // mark the bean as dirty so that a save() or update() will
+   * // increment the version property
+   *
+   * customerRepository.markAsDirty(customer);
+   * customerRepository.save(customer);
+   *
+   * }</pre>
+   *
+   * @see EbeanServer#markAsDirty(Object)
+   */
+  public void markAsDirty(T bean) {
+    db().markAsDirty(bean);
+  }
+
+  /**
+   * Mark the property as unset or 'not loaded'.
+   * <p>
+   * This would be used to specify a property that we did not wish to include in a stateless update.
+   * </p>
+   * <pre>{@code
+   *
+   *   // populate an entity bean from JSON or whatever
+   *   Customer customer = ...;
+   *
+   *   // mark the email property as 'unset' so that it is not
+   *   // included in a 'stateless update'
+   *   customerRepository.markPropertyUnset(customer, "email");
+   *
+   *   customerRepository.update(customer);
+   *
+   * }</pre>
+   *
+   * @param propertyName the name of the property on the bean to be marked as 'unset'
+   */
+  public void markPropertyUnset(T bean, String propertyName) {
+    ((EntityBean) bean)._ebean_getIntercept().setPropertyLoaded(propertyName, false);
+  }
+
+  /**
+   * Insert or update this entity depending on its state.
+   * <p>
+   * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
+   * insert or an update based on that.
+   *
+   * @see EbeanServer#save(Object)
+   */
+  public void save(T bean) {
+    db().save(bean);
+  }
+
+  /**
+   * Update this entity.
+   *
+   * @see EbeanServer#update(Object)
+   */
+  public void update(T bean) {
+    db().update(bean);
+  }
+
+  /**
+   * Insert this entity.
+   *
+   * @see EbeanServer#insert(Object)
+   */
+  public void insert(T bean) {
+    db().insert(bean);
+  }
+
+  /**
+   * Delete this bean.
+   * <p>
+   * This will return true if the bean was deleted successfully or JDBC batch is being used.
+   * </p>
+   * <p>
+   * If there is no current transaction one will be created and committed for
+   * you automatically.
+   * </p>
+   * <p>
+   * If the Bean does not have a version property (or loaded version property) and
+   * the bean does not exist then this returns false indicating that nothing was
+   * deleted. Note that, if JDBC batch mode is used then this always returns true.
+   * </p>
+   *
+   * @see EbeanServer#delete(Object)
+   */
+  public boolean delete(T bean) {
+    return db().delete(bean);
+  }
+
+  /**
+   * Delete a bean permanently without soft delete.
+   * <p>
+   * This is used when the bean contains a <code>@SoftDelete</code> property and we
+   * want to perform a hard/permanent delete.
+   * </p>
+   *
+   * @see EbeanServer#deletePermanent(Object)
+   */
+  public boolean deletePermanent(T bean) {
+    return db().deletePermanent(bean);
+  }
+
+  /**
+   * Refreshes this entity from the database.
+   *
+   * @see EbeanServer#refresh(Object)
+   */
+  public void refresh(T bean) {
+    db().refresh(bean);
+  }
+}

src/main/java/io/ebean/CountDistinctOrder.java

@@ -0,0 +1,27 @@
+package io.ebean;
+/**
+ * Enumeration to use with {@link Query#setCountDistinct(CountDistinctOrder)}.
+ * @author Roland Praml, FOCONIS AG
+ *
+ */
+public enum CountDistinctOrder {
+  NO_ORDERING,
+  
+  /** order by attribute ascending */
+  ATTR_ASC, 
+  
+  /** order by attribute descending */
+  ATTR_DESC, 
+  
+  /** order by count ascending and attribute ascending */
+  COUNT_ASC_ATTR_ASC,
+  
+  /** order by count ascending and attribute descending */
+  COUNT_ASC_ATTR_DESC,
+  
+  /** order by count descending and attribute ascending */
+  COUNT_DESC_ATTR_ASC,
+  
+  /** order by count descending and attribute descending */
+  COUNT_DESC_ATTR_DESC,
+}

src/main/java/io/ebean/CountedValue.java

@@ -0,0 +1,33 @@
+package io.ebean;
+
+import java.io.Serializable;
+/**
+ * Holds a distinct value with it's count.
+ * (Used with {@link Query#findSingleAttributeList()} and {@link Query#setCountDistinct(CountDistinctOrder)}.)
+ * @author Roland Praml, FOCONIS AG
+ */
+public class CountedValue<A> implements Serializable {
+  private static final long serialVersionUID = -2267971668356749695L;
+
+  private final A value;
+  private final long count;
+
+  public CountedValue(A value, long count) {
+    this.value = value;
+    this.count = count;
+  }
+
+  public long getCount() {
+    return count;
+  }
+  
+  public A getValue() {
+    return value;
+  }
+  
+  @Override
+  public String toString() {
+    return count + ": " + value;
+  }
+  
+}

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

@@ -0,0 +1,133 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * Query for performing native SQL queries that return DTO Bean's.
+ * <p>
+ * These beans are just normal classes. They must have public constructors
+ * and setters.
+ * <p>
+ * Constructors with arguments are used if the number of constructor arguments
+ * matches the number of columns in the resultSet.
+ * </p>
+ * <p>
+ * If the number of columns in the resultSet is greater than the largest constructor
+ * then the largest constructor is used for the first columns and remaining columns
+ * are mapped by setter methods.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ *   // CustomerDto is just a 'bean like' class
+ *   // with public constructor(s) and public setter methods
+ *
+ *   String sql = "select id, name from customer where name like :name and status_code = :status";
+ *
+ *   List<CustomerDto> beans =
+ *     Ebean.findDto(CustomrDto.class, sql)
+ *     .setParameter("name", "Acme%")
+ *     .setParameter("status", "ACTIVE")
+ *     .findList();
+ *
+ * }</pre>
+ */
+public interface DtoQuery<T> {
+
+  /**
+   * Execute the query returning a list.
+   */
+  @Nonnull
+  List<T> findList();
+
+  /**
+   * Execute the query iterating a row at a time.
+   * <p>
+   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
+   * </p>
+   */
+  void findEach(Consumer<T> consumer);
+
+  /**
+   * Execute the query iterating a row at a time with the ability to stop consuming part way through.
+   * <p>
+   * Returning false after processing a row stops the iteration through the query results.
+   * </p>
+   * <p>
+   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
+   * </p>
+   */
+  void findEachWhile(Predicate<T> consumer);
+
+  /**
+   * Execute the query returning a single bean.
+   */
+  @Nullable
+  T findOne();
+
+  /**
+   * Execute the query returning an optional bean.
+   */
+  @Nonnull
+  Optional<T> findOneOrEmpty();
+
+  /**
+   * The same as bind for named parameters.
+   */
+  DtoQuery<T> setParameter(String name, Object value);
+
+  /**
+   * The same as bind for positioned parameters.
+   */
+  DtoQuery<T> setParameter(int position, Object value);
+
+  /**
+   * Set the index of the first row of the results to return.
+   */
+  DtoQuery<T> setFirstRow(int firstRow);
+
+  /**
+   * Set the maximum number of query results to return.
+   */
+  DtoQuery<T> setMaxRows(int maxRows);
+
+  /**
+   * When resultSet columns are not able to be mapped to a bean property then instead of
+   * throwing effectively skip reading that column.
+   */
+  DtoQuery<T> setRelaxedMode();
+
+  /**
+   * Set a label on the query to make it easier to identify queries related to query execution statistics.
+   *
+   * @param label A label that is unique to the DTO bean type.
+   */
+  DtoQuery<T> setLabel(String label);
+
+  /**
+   * Set a timeout on this query.
+   * <p>
+   * This will typically result in a call to setQueryTimeout() on a
+   * preparedStatement. If the timeout occurs an exception will be thrown - this
+   * will be a SQLException wrapped up in a PersistenceException.
+   * </p>
+   *
+   * @param secs the query timeout limit in seconds. Zero means there is no limit.
+   */
+  DtoQuery<T> setTimeout(int secs);
+
+  /**
+   * A hint which for JDBC translates to the Statement.fetchSize().
+   * <p>
+   * Gives the JDBC driver a hint as to the number of rows that should be
+   * fetched from the database when more rows are needed for ResultSet.
+   * </p>
+   */
+  DtoQuery<T> setBufferFetchSizeHint(int bufferFetchSizeHint);
+
+}

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

@@ -3,18 +3,21 @@ package io.ebean;
 import io.ebean.annotation.TxIsolation;
 import io.ebean.cache.ServerCacheManager;
 import io.ebean.config.ServerConfig;
+import io.ebean.plugin.Property;
 import io.ebean.text.csv.CsvReader;
 import io.ebean.text.json.JsonContext;
-import javax.annotation.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -114,6 +117,10 @@ import java.util.concurrent.ConcurrentHashMap;
 public final class Ebean {
   private static final Logger logger = LoggerFactory.getLogger(Ebean.class);
 
+  static {
+    EbeanVersion.getVersion(); // initalizes the version class and logs the version.
+  }
+
   /**
    * Manages creation and cache of EbeanServers.
    */
@@ -131,8 +138,7 @@ public final class Ebean {
     private final ConcurrentHashMap<String, EbeanServer> concMap = new ConcurrentHashMap<>();
 
     /**
-     * Cache for synchronized read, creation and put. Protected by the monitor
-     * object.
+     * Cache for synchronized read, creation and put. Protected by the monitor object.
      */
     private final HashMap<String, EbeanServer> syncMap = new HashMap<>();
 
@@ -146,14 +152,7 @@ public final class Ebean {
     private ServerManager() {
 
       try {
-        // skipDefaultServer is set by EbeanServerFactory
-        // ... when it is creating the primaryServer
-        if (PrimaryServer.isSkip()) {
-          // primary server being created by EbeanServerFactory
-          // ... so we should not try and create it here
-          logger.debug("PrimaryServer.isSkip()");
-
-        } else {
+        if (!PrimaryServer.isSkip()) {
           // look to see if there is a default server defined
           String defaultName = PrimaryServer.getDefaultServerName();
           logger.debug("defaultName:{}", defaultName);
@@ -376,7 +375,7 @@ public final class Ebean {
    * Note that this provides an try finally alternative to using {@link #executeCall(TxScope, Callable)} or
    * {@link #execute(TxScope, Runnable)}.
    * </p>
-   *
+   * <p>
    * <h3>REQUIRES_NEW example:</h3>
    * <pre>{@code
    * // Start a new transaction. If there is a current transaction
@@ -639,6 +638,16 @@ public final class Ebean {
     serverMgr.getDefaultServer().updateAll(beans);
   }
 
+  /**
+   * Merge the bean using the given merge options.
+   *
+   * @param bean    The bean to merge
+   * @param options The options to control the merge
+   */
+  public static void merge(Object bean, MergeOptions options) {
+    serverMgr.getDefaultServer().merge(bean, options);
+  }
+
   /**
    * Save all the beans from a Collection.
    */
@@ -646,6 +655,65 @@ public final class Ebean {
     return serverMgr.getDefaultServer().saveAll(beans);
   }
 
+  /**
+   * This method checks the uniqueness of a bean. I.e. if the save will work. It will return the
+   * properties that violates an unique / primary key. This may be done in an UI save action to
+   * validate if the user has entered correct values.
+   * <p>
+   * Note: This method queries the DB for uniqueness of all indices, so do not use it in a batch update.
+   * <p>
+   * Note: This checks only the root bean!
+   * <p>
+   * <pre>{@code
+   *
+   *   // there is a unique constraint on title
+   *
+   *   Document doc = new Document();
+   *   doc.setTitle("One flew over the cuckoo's nest");
+   *   doc.setBody("clashes with doc1");
+   *
+   *   Set<Property> properties = server().checkUniqueness(doc);
+   *
+   *   if (properties.isEmpty()) {
+   *     // it is unique ... carry on
+   *
+   *   } else {
+   *     // build a user friendly message
+   *     // to return message back to user
+   *
+   *     String uniqueProperties = properties.toString();
+   *
+   *     StringBuilder msg = new StringBuilder();
+   *
+   *     properties.forEach((it)-> {
+   *       Object propertyValue = it.getVal(doc);
+   *       String propertyName = it.getName();
+   *       msg.append(" property["+propertyName+"] value["+propertyValue+"]");
+   *     });
+   *
+   *     // uniqueProperties > [title]
+   *     //       custom msg > property[title] value[One flew over the cuckoo's nest]
+   *
+   *  }
+   *
+   * }</pre>
+   *
+   * @param bean The entity bean to check uniqueness on
+   * @return a set of Properties if constraint validation was detected or empty list.
+   */
+  @Nonnull
+  public static Set<Property> checkUniqueness(Object bean) {
+    return serverMgr.getDefaultServer().checkUniqueness(bean);
+  }
+
+  /**
+   * Same as {@link #checkUniqueness(Object)}. but with given transaction.
+   */
+  @Nonnull
+  public static Set<Property> checkUniqueness(Object bean, Transaction transaction) {
+    return serverMgr.getDefaultServer().checkUniqueness(bean, transaction);
+  }
+
   /**
    * Delete the bean.
    * <p>
@@ -1058,6 +1126,21 @@ public final class Ebean {
     return serverMgr.getDefaultServer().findNative(beanType, nativeSql);
   }
 
+  /**
+   * Create a Query for DTO beans.
+   * <p>
+   * DTO beans are just normal bean like classes with public constructor(s) and setters.
+   * They do not need to be registered with Ebean before use.
+   * </p>
+   *
+   * @param dtoType The type of the DTO bean the rows will be mapped into.
+   * @param sql     The SQL query to execute.
+   * @param <T>     The type of the DTO bean.
+   */
+  public static <T> DtoQuery<T> findDto(Class<T> dtoType, String sql) {
+    return serverMgr.getDefaultServer().findDto(dtoType, sql);
+  }
+
   /**
    * Create an Update query to perform a bulk update.
    * <p>

src/main/java/io/ebean/EbeanServer.java

@@ -4,13 +4,13 @@ import io.ebean.annotation.TxIsolation;
 import io.ebean.cache.ServerCacheManager;
 import io.ebean.config.ServerConfig;
 import io.ebean.meta.MetaInfoManager;
+import io.ebean.plugin.Property;
 import io.ebean.plugin.SpiServer;
 import io.ebean.text.csv.CsvReader;
 import io.ebean.text.json.JsonContext;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-
 import javax.persistence.NonUniqueResultException;
 import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
@@ -424,6 +424,32 @@ public interface EbeanServer {
    */
   <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate);
 
+  /**
+   * Create a Query for DTO beans.
+   * <p>
+   * DTO beans are just normal bean like classes with public constructor(s) and setters.
+   * They do not need to be registered with Ebean before use.
+   * </p>
+   *
+   * @param dtoType The type of the DTO bean the rows will be mapped into.
+   * @param sql     The SQL query to execute.
+   * @param <T>     The type of the DTO bean.
+   */
+  <T> DtoQuery<T> findDto(Class<T> dtoType, String sql);
+
+  /**
+   * Create a named Query for DTO beans.
+   * <p>
+   * DTO beans are just normal bean like classes with public constructor(s) and setters.
+   * They do not need to be registered with Ebean before use.
+   * </p>
+   *
+   * @param dtoType    The type of the DTO bean the rows will be mapped into.
+   * @param namedQuery The name of the query
+   * @param <T>        The type of the DTO bean.
+   */
+  <T> DtoQuery<T> createNamedDtoQuery(Class<T> dtoType, String namedQuery);
+
   /**
    * Create a SqlQuery for executing native sql
    * query statements.
@@ -495,30 +521,44 @@ public interface EbeanServer {
    * etc.
    * </p>
    * <p>
+   * <h3>Using try with resources</h3>
    * <pre>{@code
    *
    *    // start a transaction (stored in a ThreadLocal)
-   *    ebeanServer.beginTransaction();
+   *
+   *    try (Transaction txn = ebeanServer.beginTransaction()) {
+   *
+   * 	    Order order = ebeanServer.find(Order.class,10);
+   * 	    ...
+   * 	    ebeanServer.save(order);
+   *
+   * 	    txn.commit();
+   *    }
+   *
+   * }</pre>
+   * <p>
+   * <h3>Using try finally block</h3>
+   * <pre>{@code
+   *
+   *    // start a transaction (stored in a ThreadLocal)
+   *    Transaction txn = ebeanServer.beginTransaction();
    *    try {
    * 	    Order order = ebeanServer.find(Order.class,10);
    *
    * 	    ebeanServer.save(order);
    *
-   * 	    ebeanServer.commitTransaction();
+   * 	    txn.commit();
    *
    *    } finally {
-   * 	    // rollback if we didn't commit
-   * 	    // i.e. an exception occurred before commitTransaction().
-   * 	    ebeanServer.endTransaction();
+   * 	    txn.end();
    *    }
    *
    * }</pre>
    * <p>
-   * <h3>Transaction options:</h3>
+   * <h3>Transaction options</h3>
    * <pre>{@code
    *
-   *     Transaction txn = ebeanServer.beginTransaction();
-   *     try {
+   *     try (Transaction txn = ebeanServer.beginTransaction()) {
    *       // explicitly turn on/off JDBC batch use
    *       txn.setBatchMode(true);
    *       txn.setBatchSize(50);
@@ -539,10 +579,6 @@ public interface EbeanServer {
    *       ...
    *
    *       txn.commit();
-   *
-   *    } finally {
-   *       // rollback if necessary
-   *       txn.end();
    *    }
    *
    * }</pre>
@@ -572,19 +608,16 @@ public interface EbeanServer {
    * <pre>{@code
    * // Start a new transaction. If there is a current transaction
    * // suspend it until this transaction ends
-   * Transaction txn = server.beginTransaction(TxScope.requiresNew());
-   * try {
+   * try (Transaction txn = server.beginTransaction(TxScope.requiresNew())) {
    *
    *   ...
    *
    *   // commit the transaction
    *   txn.commit();
    *
-   * } finally {
-   *   // end this transaction which:
-   *   //  A) will rollback transaction if it has not been committed already
+   *   // At end this transaction will:
+   *   //  A) will rollback transaction if it has not been committed
    *   //  B) will restore a previously suspended transaction
-   *   txn.end();
    * }
    *
    * }</pre>
@@ -593,20 +626,13 @@ public interface EbeanServer {
    * <pre>{@code
    *
    * // start a new transaction if there is not a current transaction
-   * Transaction txn = server.beginTransaction(TxScope.required());
-   * try {
+   * try (Transaction txn = server.beginTransaction(TxScope.required())) {
    *
    *   ...
    *
    *   // commit the transaction if it was created or
    *   // do nothing if there was already a current transaction
    *   txn.commit();
-   *
-   * } finally {
-   *   // end this transaction which will rollback the transaction
-   *   // if it was created for this try finally scope and has not
-   *   // already been committed
-   *   txn.end();
    * }
    *
    * }</pre>
@@ -1461,6 +1487,61 @@ public interface EbeanServer {
    */
   int saveAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException;
 
+  /**
+   * This method checks the uniqueness of a bean. I.e. if the save will work. It will return the
+   * properties that violates an unique / primary key. This may be done in an UI save action to
+   * validate if the user has entered correct values.
+   * <p>
+   * Note: This method queries the DB for uniqueness of all indices, so do not use it in a batch update.
+   * <p>
+   * Note: This checks only the root bean!
+   * <p>
+   * <pre>{@code
+   *
+   *   // there is a unique constraint on title
+   *
+   *   Document doc = new Document();
+   *   doc.setTitle("One flew over the cuckoo's nest");
+   *   doc.setBody("clashes with doc1");
+   *
+   *   Set<Property> properties = server().checkUniqueness(doc);
+   *
+   *   if (properties.isEmpty()) {
+   *     // it is unique ... carry on
+   *
+   *   } else {
+   *     // build a user friendly message
+   *     // to return message back to user
+   *
+   *     String uniqueProperties = properties.toString();
+   *
+   *     StringBuilder msg = new StringBuilder();
+   *
+   *     properties.forEach((it)-> {
+   *       Object propertyValue = it.getVal(doc);
+   *       String propertyName = it.getName();
+   *       msg.append(" property["+propertyName+"] value["+propertyValue+"]");
+   *     });
+   *
+   *     // uniqueProperties > [title]
+   *     //       custom msg > property[title] value[One flew over the cuckoo's nest]
+   *
+   *  }
+   *
+   * }</pre>
+   *
+   * @param bean The entity bean to check uniqueness on
+   * @return a set of Properties if constraint validation was detected or empty list.
+   */
+  @Nonnull
+  Set<Property> checkUniqueness(Object bean);
+
+  /**
+   * Same as {@link #checkUniqueness(Object)}. but with given transaction.
+   */
+  @Nonnull
+  Set<Property> checkUniqueness(Object bean, Transaction transaction);
+
   /**
    * Marks the entity bean as dirty.
    * <p>
@@ -1547,6 +1628,22 @@ public interface EbeanServer {
    */
   void updateAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException;
 
+  /**
+   * Merge the bean using the given merge options.
+   *
+   * @param bean    The bean to merge
+   * @param options The options to control the merge
+   */
+  void merge(Object bean, MergeOptions options);
+
+  /**
+   * Merge the bean using the given merge options and a transaction.
+   *
+   * @param bean    The bean to merge
+   * @param options The options to control the merge
+   */
+  void merge(Object bean, MergeOptions options, Transaction transaction);
+
   /**
    * Insert the bean.
    * <p>

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

@@ -33,6 +33,10 @@ public class EbeanServerFactory {
 
   private static SpiContainer container;
 
+  static {
+    EbeanVersion.getVersion(); // initalizes the version class and logs the version.
+  }
+
   /**
    * Initialise the container with clustering configuration.
    * <p>
@@ -65,10 +69,8 @@ public class EbeanServerFactory {
 
     EbeanServer server = createInternal(config);
 
-    if (config.isDefaultServer()) {
-      PrimaryServer.setSkip(true);
-    }
     if (config.isRegister()) {
+      PrimaryServer.setSkip(true);
       Ebean.register(server, config.isDefaultServer());
     }
 

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

@@ -0,0 +1,43 @@
+package io.ebean;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+/**
+ * Class to determine the ebean version. (
+ * @author Roland Praml, FOCONIS AG
+ *
+ */
+public class EbeanVersion {
+  private EbeanVersion() {
+    
+  }
+  private static final Logger logger = LoggerFactory.getLogger(EbeanVersion.class);
+  
+  private static String version = "unknown";
+  static {
+    try {
+      Properties prop = new Properties();
+      InputStream in = Ebean.class.getResourceAsStream("/META-INF/maven/io.ebean/ebean/pom.properties");
+      if (in != null) {
+        prop.load(in);
+        in.close();
+        version = prop.getProperty("version");
+      }
+      logger.info("ebean version: {}", version);
+    } catch (IOException e) {
+      logger.warn("Could not determine ebean version: {}", e.getMessage());
+    }
+  }
+  
+  /**
+   * Returns the ebean version (read from /META-INF/maven/io.ebean/ebean/pom.properties)
+   */
+  public static String getVersion() {
+    return version;
+  }
+  
+}

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

@@ -327,6 +327,30 @@ public interface ExpressionFactory {
    */
   Expression allEq(Map<String, Object> propertyMap);
 
+  /**
+   * Add expression for ANY of the given bit flags to be set.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAny(String propertyName, long flags);
+
+  /**
+   * Add expression for ALL of the given bit flags to be set.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAll(String propertyName, long flags);
+
+  /**
+   * Add bitwise AND expression of the given bit flags to compare with the match/mask.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAnd(String propertyName, long flags, long match);
+
   /**
    * Add raw expression with a single parameter.
    * <p>

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

@@ -480,6 +480,36 @@ public interface ExpressionList<T> {
    */
   Query<T> setUseQueryCache(CacheMode useCache);
 
+  /**
+   * Extended version for setDistinct in conjunction with "findSingleAttributeList";
+   * <p>
+   * <pre>{@code
+   *
+   *  List<CountedValue<Order.Status>> orderStatusCount =
+   *
+   *     Ebean.find(Order.class)
+   *      .select("status")
+   *      .where()
+   *      .gt("orderDate", LocalDate.now().minusMonths(3))
+   *
+   *      // fetch as single attribute with a COUNT
+   *      .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC)
+   *      .findSingleAttributeList();
+   *
+   *     for (CountedValue<Order.Status> entry : orderStatusCount) {
+   *       System.out.println(" count:" + entry.getCount()+" orderStatus:" + entry.getValue() );
+   *     }
+   *
+   *   // produces
+   *
+   *   count:3 orderStatus:NEW
+   *   count:1 orderStatus:SHIPPED
+   *   count:1 orderStatus:COMPLETE
+   *
+   * }</pre>
+   */
+  Query<T> setCountDistinct(CountDistinctOrder orderBy);
+
   /**
    * Calls {@link #setUseQueryCache(CacheMode)} with <code>ON</code> or <code>OFF</code>.
    *
@@ -515,6 +545,11 @@ public interface ExpressionList<T> {
    */
   Query<T> setDisableReadAuditing();
 
+  /**
+   * Set a label on the query (to help identify query execution statistics).
+   */
+  Query<T> setLabel(String label);
+
   /**
    * Add expressions to the having clause.
    * <p>
@@ -843,7 +878,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - using a subQuery.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -853,7 +888,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - property has a value in the array of values.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -863,7 +898,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - property has a value in the collection of values.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -961,6 +996,53 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> arrayIsNotEmpty(String propertyName);
 
+  /**
+   * Add expression for ANY of the given bit flags to be set.
+   * <pre>{@code
+   *
+   * where().bitwiseAny("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAny(String propertyName, long flags);
+
+  /**
+   * Add expression for ALL of the given bit flags to be set.
+   * <p>
+   * <pre>{@code
+   *
+   * where().bitwiseAll("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAll(String propertyName, long flags);
+
+  /**
+   * Add bitwise AND expression of the given bit flags to compare with the match/mask.
+   * <p>
+   * <pre>{@code
+   *
+   * // Flags Bulk + Size = Size
+   * // ... meaning Bulk is not set and Size is set
+   *
+   * long selectedFlags = BwFlags.HAS_BULK + BwFlags.HAS_SIZE;
+   * long mask = BwFlags.HAS_SIZE; // Only Size flag set
+   *
+   * where().bitwiseAnd("flags", selectedFlags, mask)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAnd(String propertyName, long flags, long match);
+
   /**
    * Add raw expression with a single parameter.
    * <p>

src/main/java/io/ebean/MergeOptions.java

@@ -0,0 +1,29 @@
+package io.ebean;
+
+import java.util.Set;
+
+/**
+ * Options used to control a merge. Use MergeOptionsBuilder to create an instance.
+ * <p>
+ * Instances of MergeOptions are thread safe and safe to share across threads.
+ */
+public interface MergeOptions {
+
+  /**
+   * Returns true if Id values are supplied by the client.
+   * <p>
+   * This would be the case when for example a mobile creates data in it's own local database
+   * and then sync's. In this case often the id values are UUID.
+   */
+  boolean isClientGeneratedIds();
+
+  /**
+   * Return true if delete permanent should be used and false for 'normal' delete that allows soft deletes.
+   */
+  boolean isDeletePermanent();
+
+  /**
+   * Return the paths included in the merge.
+   */
+  Set<String> paths();
+}

src/main/java/io/ebean/MergeOptionsBuilder.java

@@ -0,0 +1,80 @@
+package io.ebean;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * Builds a MergeOptions which is immutable and thread safe.
+ */
+public class MergeOptionsBuilder {
+
+  private Set<String> paths = new LinkedHashSet<>();
+
+  private boolean clientGeneratedIds;
+
+  private boolean deletePermanent = true;
+
+  /**
+   * Add a path that will included in the merge.
+   *
+   * @param path The path relative to the root type.
+   * @return The builder to chain another addPath() or build().
+   */
+  public MergeOptionsBuilder addPath(String path) {
+    paths.add(path);
+    return this;
+  }
+
+  /**
+   * Set to true if Id values are supplied by the client.
+   * <p>
+   * This would be the case when for example a mobile creates data in it's own local database
+   * and then sync's. In this case often the id values are UUID.
+   */
+  public MergeOptionsBuilder setClientGeneratedIds() {
+    this.clientGeneratedIds = true;
+    return this;
+  }
+
+  /**
+   * Set that deletions should use delete permanent (rather than default which allows soft deletes).
+   */
+  public MergeOptionsBuilder setDeletePermanent() {
+    this.deletePermanent = true;
+    return this;
+  }
+
+  /**
+   * Build and return the MergeOptions instance.
+   */
+  public MOptions build() {
+    return new MOptions(paths, clientGeneratedIds, deletePermanent);
+  }
+
+  private static class MOptions implements MergeOptions {
+
+    private final boolean clientGeneratedIds;
+    private final boolean deletePermanent;
+    private final Set<String> paths;
+
+    private MOptions(Set<String> paths, boolean clientGeneratedIds, boolean deletePermanent) {
+      this.paths = paths;
+      this.clientGeneratedIds = clientGeneratedIds;
+      this.deletePermanent = deletePermanent;
+    }
+
+    public Set<String> paths() {
+      return paths;
+    }
+
+    @Override
+    public boolean isClientGeneratedIds() {
+      return clientGeneratedIds;
+    }
+
+    @Override
+    public boolean isDeletePermanent() {
+      return deletePermanent;
+    }
+  }
+}

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

@@ -158,6 +158,7 @@ public class Pairs {
     return this;
   }
 
+  @Override
   public String toString() {
     return "p0:" + property0 + " p1:" + property1 + " entries:" + entries;
   }
@@ -183,6 +184,7 @@ public class Pairs {
       this.b = b;
     }
 
+    @Override
     public String toString() {
       return "{" + a + "," + b + "}";
     }

src/main/java/io/ebean/PrimaryServer.java

@@ -1,6 +1,6 @@
 package io.ebean;
 
-import io.ebean.config.PropertyMap;
+import io.ebean.config.properties.PropertiesLoader;
 
 import java.util.Properties;
 
@@ -44,7 +44,7 @@ class PrimaryServer {
    */
   static synchronized Properties getProperties() {
     if (globalProperties == null) {
-      globalProperties = PropertyMap.defaultProperties();
+      globalProperties = PropertiesLoader.load();
     }
     if (defaultServerName == null) {
       defaultServerName = determineDefaultServerName();

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

@@ -236,6 +236,14 @@ public interface Query<T> {
    */
   Query<T> asDraft();
 
+  /**
+   * Convert the query to a DTO bean query.
+   * <p>
+   * We effectively use the underlying ORM query to build the SQL and then execute
+   * and map it into DTO beans.
+   */
+  <D> DtoQuery<D> asDto(Class<D> dtoClass);
+
   /**
    * Cancel the query execution if supported by the underlying database and
    * driver.
@@ -828,6 +836,11 @@ public interface Query<T> {
    */
   <A> A findSingleAttribute();
 
+  /**
+   * Return true if this is countDistinct query.
+   */
+  boolean isCountDistinct();
+
   /**
    * Execute the query returning either a single bean or null (if no matching
    * bean is found).
@@ -1272,6 +1285,37 @@ public interface Query<T> {
    */
   Query<T> setDistinct(boolean isDistinct);
 
+  /**
+   * Extended version for setDistinct in conjunction with "findSingleAttributeList";
+   *
+   * <pre>{@code
+   *
+   *  List<CountedValue<Order.Status>> orderStatusCount =
+   *
+   *     Ebean.find(Order.class)
+   *      .select("status")
+   *      .where()
+   *      .gt("orderDate", LocalDate.now().minusMonths(3))
+   *
+   *      // fetch as single attribute with a COUNT
+   *      .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC)
+   *      .findSingleAttributeList();
+   *
+   *     for (CountedValue<Order.Status> entry : orderStatusCount) {
+   *       System.out.println(" count:" + entry.getCount()+" orderStatus:" + entry.getValue() );
+   *     }
+   *
+   *   // produces
+   *
+   *   count:3 orderStatus:NEW
+   *   count:1 orderStatus:SHIPPED
+   *   count:1 orderStatus:COMPLETE
+   *
+   * }</pre>
+   *
+   */
+  Query<T> setCountDistinct(CountDistinctOrder orderBy);
+
   /**
    * Return the first row value.
    */
@@ -1375,6 +1419,15 @@ public interface Query<T> {
    */
   Query<T> setProfileLocation(ProfileLocation profileLocation);
 
+  /**
+   * Set a label on the query.
+   * <p>
+   * This label can be used to help identify query performance metrics but we can also use
+   * profile location enhancement on Finders so for some that would be a better option.
+   * </p>
+   */
+  Query<T> setLabel(String label);
+
   /**
    * Set to true if this query should execute against the doc store.
    * <p>
@@ -1436,9 +1489,12 @@ public interface Query<T> {
   String getGeneratedSql();
 
   /**
+   * Deprecated - migrate to forUpdate().
+   *
    * executed the select with "for update" which should lock the record
    * "on read"
    */
+  @Deprecated
   Query<T> setForUpdate(boolean forUpdate);
 
   /**
@@ -1482,6 +1538,11 @@ public interface Query<T> {
    */
   Class<T> getBeanType();
 
+  /**
+   * Return the type of query being executed.
+   */
+  QueryType getQueryType();
+
   /**
    * Set true if you want to disable lazy loading.
    * <p>
@@ -1499,4 +1560,12 @@ public interface Query<T> {
    */
   Set<String> validate();
 
+  /**
+   * Controls, if paginated queries should always append an 'order by id' statement at the end to
+   * guarantee a deterministic sort result. This may affect performance.
+   * If this is not enabled, and an orderBy is set on the query, it's up to the programmer that
+   * this query provides a deterministic result.
+   */
+  Query<T> orderById(boolean orderById);
+
 }

src/main/java/io/ebean/QueryType.java

@@ -0,0 +1,22 @@
+package io.ebean;
+
+/**
+ * The type of the query being executed.
+ */
+public enum QueryType {
+
+  /**
+   * A find query.
+   */
+  FIND,
+
+  /**
+   * An update query.
+   */
+  UPDATE,
+
+  /**
+   * A delete query.
+   */
+  DELETE
+}

src/main/java/io/ebean/RawSqlBuilder.java

@@ -1,6 +1,7 @@
 package io.ebean;
 
 import java.sql.ResultSet;
+import java.sql.SQLException;
 
 /**
  * Builds RawSql instances from a SQL string and column mappings.
@@ -24,6 +25,13 @@ public interface RawSqlBuilder {
     return XServiceProvider.rawSql().resultSet(resultSet, propertyNames);
   }
 
+  /**
+   * Create and return a SqlRow based on the resultSet with dbTrueValue and binaryOptimizedUUID options.
+   */
+  static SqlRow sqlRow(ResultSet resultSet, final String dbTrueValue, boolean binaryOptimizedUUID) throws SQLException {
+    return XServiceProvider.rawSql().sqlRow(resultSet, dbTrueValue, binaryOptimizedUUID);
+  }
+
   /**
    * Return an unparsed RawSqlBuilder. Unlike a parsed one this query can not be
    * modified - so no additional WHERE or HAVING expressions can be added to

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

@@ -115,6 +115,11 @@ public interface SqlQuery extends Serializable {
    */
   SqlQuery setTimeout(int secs);
 
+  /**
+   * Set a label that can be put on performance metrics that are collected.
+   */
+  SqlQuery setLabel(String label);
+
   /**
    * A hint which for JDBC translates to the Statement.fetchSize().
    * <p>

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

@@ -30,6 +30,35 @@ package io.ebean;
  * String msg = "There were " + modifiedCount + " rows updated";
  *
  * }</pre>
+ * <p>
+ * <h3>Example: Using setNextParameter()</h3>
+ * <pre>{@code
+ *
+ *  String sql = "insert into audit_log (id, description, modified_description) values (?,?,?)";
+ *  SqlUpdate insert = Ebean.createSqlUpdate(sql);
+ *
+ *  try (Transaction txn = Ebean.beginTransaction()) {
+ *    txn.setBatchMode(true);
+ *
+ *    insert.setNextParameter(10000);
+ *    insert.setNextParameter("hello");
+ *    insert.setNextParameter("rob");
+ *    insert.execute();
+ *
+ *    insert.setNextParameter(10001);
+ *    insert.setNextParameter("goodbye");
+ *    insert.setNextParameter("rob");
+ *    insert.execute();
+ *
+ *    insert.setNextParameter(10002);
+ *    insert.setNextParameter("chow");
+ *    insert.setNextParameter("bob");
+ *    insert.execute();
+ *
+ *    txn.commit();
+ *  }
+ *
+ * }</pre>
  *
  * @see Update
  * @see SqlQuery
@@ -54,6 +83,25 @@ public interface SqlUpdate {
    */
   int execute();
 
+  /**
+   * Return the generated key value.
+   */
+  Object getGeneratedKey();
+
+  /**
+   * Execute and return the generated key. This is effectively a short cut for:
+   * <p>
+   * <pre>{@code
+   *
+   *   sqlUpdate.execute();
+   *   Object key = sqlUpdate.getGeneratedKey();
+   *
+   * }</pre>
+   *
+   * @return The generated key value
+   */
+  Object executeGetKey();
+
   /**
    * Return true if eBean should automatically deduce the table modification
    * information and process it.
@@ -88,6 +136,11 @@ public interface SqlUpdate {
    */
   SqlUpdate setLabel(String label);
 
+  /**
+   * Set to true when we want to use getGeneratedKeys with this statement.
+   */
+  SqlUpdate setGetGeneratedKeys(boolean getGeneratedKeys);
+
   /**
    * Return the sql statement.
    */
@@ -113,6 +166,13 @@ public interface SqlUpdate {
    */
   SqlUpdate setTimeout(int secs);
 
+  /**
+   * Set the next positioned parameter.
+   *
+   * @param value The value to bind
+   */
+  SqlUpdate setNextParameter(Object value);
+
   /**
    * Set a parameter via its index position.
    */

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

@@ -152,6 +152,11 @@ public interface Update<T> {
    */
   Update<T> setNullParameter(String name, int jdbcType);
 
+  /**
+   * Set a label meaning performance metrics will be collected for the execution of this update.
+   */
+  Update<T> setLabel(String label);
+
   /**
    * Return the sql that is actually executed.
    */

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

@@ -72,6 +72,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   boolean isSkipSave();
 
+  /**
+   * Return true if the collection holds modifications.
+   */
+  boolean holdsModifications();
+
   /**
    * Return the bean that owns this collection.
    */
@@ -191,6 +196,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   void setModifyListening(ModifyListenMode modifyListenMode);
 
+  /**
+   * Return the current modify listening mode. Can be null for on newly created beans.
+   */
+  ModifyListenMode getModifyListening();
+
   /**
    * Add an object to the additions list.
    * <p>
@@ -227,6 +237,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   void modifyReset();
 
+  /**
+   * Has been modified by an addition or removal.
+   */
+  boolean wasTouched();
+
   /**
    * Return a shallow copy of this collection that is modifiable.
    */

src/main/java/io/ebean/bean/CallStack.java

@@ -43,6 +43,7 @@ public final class CallStack implements Serializable {
     return hc;
   }
 
+  @Override
   public int hashCode() {
     return hc;
   }

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

@@ -52,6 +52,8 @@ public final class EntityBeanIntercept implements Serializable {
    */
   private int state;
 
+  private boolean forceUpdate;
+
   private boolean readOnly;
 
   private boolean dirty;
@@ -90,6 +92,7 @@ public final class EntityBeanIntercept implements Serializable {
   private int lazyLoadProperty = -1;
 
   private Object ownerId;
+  private int sortOrder;
 
   /**
    * Create a intercept with a given entity.
@@ -130,6 +133,20 @@ public final class EntityBeanIntercept implements Serializable {
     this.nodeUsageCollector = usageCollector;
   }
 
+  /**
+   * Return the ownerId (IdClass).
+   */
+  public Object getOwnerId() {
+    return ownerId;
+  }
+
+  /**
+   * Set the ownerId (IdClass).
+   */
+  public void setOwnerId(Object ownerId) {
+    this.ownerId = ownerId;
+  }
+
   /**
    * Return the owning bean for an embedded bean.
    */
@@ -291,6 +308,20 @@ public final class EntityBeanIntercept implements Serializable {
     this.readOnly = readOnly;
   }
 
+  /**
+   * Set the bean to be updated when persisted (for merge).
+   */
+  public void setForceUpdate(boolean forceUpdate) {
+    this.forceUpdate = forceUpdate;
+  }
+
+  /**
+   * Return true if the entity should be updated.
+   */
+  public boolean isUpdate() {
+    return forceUpdate || state == STATE_LOADED;
+  }
+
   /**
    * Return true if the entity has been loaded.
    */
@@ -528,6 +559,16 @@ public final class EntityBeanIntercept implements Serializable {
     }
   }
 
+  /**
+   * Set old value but force it to be set regardless if it already has a value.
+   */
+  private void setOriginalValueForce(int propertyIndex, Object value) {
+    if (origValues == null) {
+      origValues = new Object[owner._ebean_getPropertyNames().length];
+    }
+    origValues[propertyIndex] = value;
+  }
+
   /**
    * For forced update on a 'New' bean set all the loaded properties to changed.
    */
@@ -693,6 +734,9 @@ public final class EntityBeanIntercept implements Serializable {
    * Add and return a dirty property hash recursing into embedded beans.
    */
   private void addDirtyPropertyKey(StringBuilder sb) {
+    if (sortOrder > 0) {
+      sb.append("s,");
+    }
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
       if (changedProps != null && changedProps[i]) {
@@ -897,15 +941,19 @@ public final class EntityBeanIntercept implements Serializable {
 
     if (setDirtyState) {
       setOriginalValue(propertyIndex, origValue);
-      if (!dirty) {
-        dirty = true;
-        if (embeddedOwner != null) {
-          // Cascade dirty state from Embedded bean to parent bean
-          embeddedOwner._ebean_getIntercept().setEmbeddedDirty(embeddedOwnerIndex);
-        }
-        if (nodeUsageCollector != null) {
-          nodeUsageCollector.setModified();
-        }
+      setDirtyStatus();
+    }
+  }
+
+  private void setDirtyStatus() {
+    if (!dirty) {
+      dirty = true;
+      if (embeddedOwner != null) {
+        // Cascade dirty state from Embedded bean to parent bean
+        embeddedOwner._ebean_getIntercept().setEmbeddedDirty(embeddedOwnerIndex);
+      }
+      if (nodeUsageCollector != null) {
+        nodeUsageCollector.setModified();
       }
     }
   }
@@ -1045,9 +1093,25 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Explicitly set an old value.
+   * Explicitly set an old value with force (the old value is forced even it is already set).
    */
   public void setOldValue(int propertyIndex, Object oldValue) {
-    setChangedPropertyValue(propertyIndex, true, oldValue);
+    setChangedProperty(propertyIndex);
+    setOriginalValueForce(propertyIndex, oldValue);
+    setDirtyStatus();
+  }
+
+  /**
+   * Return the sort order value for an order column.
+   */
+  public int getSortOrder() {
+    return sortOrder;
+  }
+
+  /**
+   * Set the sort order value for an order column.
+   */
+  public void setSortOrder(int sortOrder) {
+    this.sortOrder = sortOrder;
   }
 }

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

@@ -6,7 +6,6 @@ import io.ebean.bean.BeanCollection;
 import io.ebean.bean.BeanCollectionLoader;
 import io.ebean.bean.EntityBean;
 
-import javax.persistence.PersistenceException;
 import java.util.Set;
 
 /**
@@ -64,7 +63,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     this.ebeanServerName = loader.getName();
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
-    this.readOnly = ownerBean._ebean_getIntercept().isReadOnly();
+    this.readOnly = ownerBean != null && ownerBean._ebean_getIntercept().isReadOnly();
   }
 
   @Override
@@ -96,13 +95,6 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     if (loader == null) {
       loader = (BeanCollectionLoader) Ebean.getServer(ebeanServerName);
     }
-    if (loader == null) {
-      String msg = "Lazy loading but LazyLoadEbeanServer is null?"
-        + " The LazyLoadEbeanServer needs to be set after deserialization"
-        + " to support lazy loading.";
-      throw new PersistenceException(msg);
-    }
-
     loader.loadMany(this, onlyIds);
     checkEmptyLazyLoad();
   }
@@ -140,6 +132,11 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   // Support for modify additions deletions etc - ManyToMany
   // ---------------------------------------------------------
 
+  @Override
+  public ModifyListenMode getModifyListening() {
+    return modifyListenMode;
+  }
+
   /**
    * set modifyListening to be on or off.
    */
@@ -210,10 +207,16 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   /**
    * Return true if there are underlying additions or removals.
    */
-  boolean holdsModifications() {
+  @Override
+  public boolean holdsModifications() {
     return modifyHolder != null && modifyHolder.hasModifications();
   }
-  
+
+  @Override
+  public boolean wasTouched() {
+    return modifyHolder != null && modifyHolder.wasTouched();
+  }
+
   /**
    * Copies all relevant properties for a clone. See {@link #getShallowCopy()}
    * @param other

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

@@ -28,7 +28,10 @@ class ModifyHolder<E> implements Serializable {
    */
   private Set<E> modifyAdditions = new LinkedHashSet<>();
 
+  private boolean touched;
+
   void reset() {
+    touched = false;
     modifyDeletions = new LinkedHashSet<>();
     modifyAdditions = new LinkedHashSet<>();
   }
@@ -50,6 +53,7 @@ class ModifyHolder<E> implements Serializable {
 
   void modifyAddition(E bean) {
     if (bean != null) {
+      touched = true;
       // If it is to delete then just remove the deletion
       if (!undoDeletion(bean)) {
         // Insert
@@ -65,6 +69,7 @@ class ModifyHolder<E> implements Serializable {
   @SuppressWarnings("unchecked")
   void modifyRemoval(Object bean) {
     if (bean != null) {
+      touched = true;
       // If it is to be added then just remove the addition
       if (!undoAddition(bean)) {
         modifyDeletions.add((E) bean);
@@ -80,6 +85,14 @@ class ModifyHolder<E> implements Serializable {
     return modifyDeletions;
   }
 
+  /**
+   * Return true if the collection was touched in some way. This is still true even if
+   * a bean was removed and then added (which is not held as a modification).
+   */
+  boolean wasTouched() {
+    return touched;
+  }
+
   /**
    * Return true if there additions or removals.
    */

src/main/java/io/ebean/config/AutoConfigure.java

@@ -0,0 +1,18 @@
+package io.ebean.config;
+
+/**
+ * Used to provide some automatic configuration early in the creation of an EbeanServer.
+ */
+public interface AutoConfigure {
+
+  /**
+   * Perform configuration for the ServerConfig prior to properties load.
+   */
+  void preConfigure(ServerConfig serverConfig);
+
+  /**
+   * Provide some configuration the ServerConfig prior to server creation but after properties have been applied.
+   */
+  void postConfigure(ServerConfig serverConfig);
+
+}

src/main/java/io/ebean/config/DbMigrationConfig.java

@@ -1,11 +1,16 @@
 package io.ebean.config;
 
+import io.ebean.EbeanVersion;
 import io.ebean.annotation.Platform;
 import io.ebean.migration.MigrationConfig;
 import io.ebean.migration.MigrationRunner;
+import io.ebean.util.StringHelper;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.Map;
 import java.util.Properties;
 
@@ -116,6 +121,11 @@ public class DbMigrationConfig {
    */
   protected boolean strictMode = true;
 
+  /**
+   * Contains the DDL-header information.
+   */
+  protected String ddlHeader;
+
   /**
    * Return the DB platform to generate migration DDL for.
    * <p>
@@ -387,6 +397,14 @@ public class DbMigrationConfig {
     return patchResetChecksumOn;
   }
 
+  /**
+   * Returns a DDL header prepend for each DDL. E.g. for copyright headers
+   * You can use placeholders like ${version} or ${timestamp} in properties file.
+   */
+  public String getDdlHeader() {
+    return ddlHeader;
+  }
+
   /**
    * Set migration versions that should have their checksum reset and not run.
    * <p>
@@ -447,13 +465,20 @@ public class DbMigrationConfig {
     metaTable = properties.get("migration.metaTable", metaTable);
     runPlaceholders = properties.get("migration.placeholders", runPlaceholders);
 
-    String adminUser = properties.get("datasource." + serverName + ".username", dbUsername);
-    adminUser = properties.get("datasource." + serverName + ".adminusername", adminUser);
+    //Do not set user and pass from "datasource.db.username"
+    //There is a null test in MigrationRunner::getConnection to handle this
+    //String adminUser = properties.get("datasource." + serverName + ".username", dbUsername);
+    String adminUser = properties.get("datasource." + serverName + ".adminusername", dbUsername);
     dbUsername = properties.get("migration.dbusername", adminUser);
 
-    String adminPwd = properties.get("datasource." + serverName + ".password", dbPassword);
-    adminPwd = properties.get("datasource." + serverName + ".adminpassword", adminPwd);
+    //String adminPwd = properties.get("datasource." + serverName + ".password", dbPassword);
+    String adminPwd = properties.get("datasource." + serverName + ".adminpassword", dbPassword);
     dbPassword = properties.get("migration.dbpassword", adminPwd);
+    ddlHeader = properties.get("ddl.header", ddlHeader);
+    if (ddlHeader != null && !ddlHeader.isEmpty()) {
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${version}", EbeanVersion.getVersion());
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${timestamp}", ZonedDateTime.now().format( DateTimeFormatter.ISO_INSTANT ));
+    }
   }
 
   /**

src/main/java/io/ebean/config/DbTypeConfig.java

@@ -1,124 +0,0 @@
-package io.ebean.config;
-
-import io.ebean.config.dbplatform.DbType;
-import io.ebean.config.dbplatform.IdType;
-import io.ebean.annotation.Platform;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Configuration for DB types such as UUID, Geometry etc.
- */
-public class DbTypeConfig {
-
-  /**
-   * The Geometry SRID value (default 4326).
-   */
-  private int geometrySRID = 4326;
-
-  /**
-   * Set for DB's that support both Sequence and Identity (and the default choice is not desired).
-   */
-  private IdType idType;
-
-  /**
-   * Setting to indicate if UUID should be stored as binary(16) or varchar(40) or native DB type (for H2 and Postgres).
-   */
-  private ServerConfig.DbUuid dbUuid = ServerConfig.DbUuid.AUTO_VARCHAR;
-
-  /**
-   * Modify the default mapping of standard types such as default precision for DECIMAL etc.
-   */
-  private List<CustomDbTypeMapping> customDbTypeMappings = new ArrayList<>();
-
-  /**
-   * Return the Geometry SRID.
-   */
-  public int getGeometrySRID() {
-    return geometrySRID;
-  }
-
-  /**
-   * Set the Geometry SRID.
-   */
-  public void setGeometrySRID(int geometrySRID) {
-    this.geometrySRID = geometrySRID;
-  }
-
-  /**
-   * Return the DB type used to store UUID.
-   */
-  public ServerConfig.DbUuid getDbUuid() {
-    return dbUuid;
-  }
-
-  /**
-   * Set the DB type used to store UUID.
-   */
-  public void setDbUuid(ServerConfig.DbUuid dbUuid) {
-    this.dbUuid = dbUuid;
-  }
-
-  /**
-   * Return the IdType to use (or null for the default choice).
-   */
-  public IdType getIdType() {
-    return idType;
-  }
-
-  /**
-   * Set the IdType to use (when the DB supports both SEQUENCE and IDENTITY and the default is not desired).
-   */
-  public void setIdType(IdType idType) {
-    this.idType = idType;
-  }
-
-  /**
-   * Add a custom type mapping.
-   * <p>
-   * <pre>{@code
-   *
-   *   // set the default mapping for BigDecimal.class/decimal
-   *   serverConfig.addCustomMapping(DbType.DECIMAL, "decimal(18,6)");
-   *
-   *   // set the default mapping for String.class/varchar but only for Postgres
-   *   serverConfig.addCustomMapping(DbType.VARCHAR, "text", Platform.POSTGRES);
-   *
-   * }</pre>
-   *
-   * @param type             The DB type this mapping should apply to
-   * @param columnDefinition The column definition that should be used
-   * @param platform         Optionally specify the platform this mapping should apply to.
-   */
-  public void addCustomMapping(DbType type, String columnDefinition, Platform platform) {
-    customDbTypeMappings.add(new CustomDbTypeMapping(type, columnDefinition, platform));
-  }
-
-  /**
-   * Add a custom type mapping that applies to all platforms.
-   * <p>
-   * <pre>{@code
-   *
-   *   // set the default mapping for BigDecimal/decimal
-   *   serverConfig.addCustomMapping(DbType.DECIMAL, "decimal(18,6)");
-   *
-   *   // set the default mapping for String/varchar
-   *   serverConfig.addCustomMapping(DbType.VARCHAR, "text");
-   *
-   * }</pre>
-   *
-   * @param type             The DB type this mapping should apply to
-   * @param columnDefinition The column definition that should be used
-   */
-  public void addCustomMapping(DbType type, String columnDefinition) {
-    customDbTypeMappings.add(new CustomDbTypeMapping(type, columnDefinition));
-  }
-
-  /**
-   * Return the list of custom type mappings.
-   */
-  public List<CustomDbTypeMapping> getCustomTypeMappings() {
-    return customDbTypeMappings;
-  }
-}

src/main/java/io/ebean/config/PlatformConfig.java

@@ -0,0 +1,335 @@
+package io.ebean.config;
+
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.DbType;
+import io.ebean.config.dbplatform.IdType;
+import io.ebean.util.StringHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Configuration for DB types such as UUID, Geometry etc.
+ */
+public class PlatformConfig {
+
+  private boolean allQuotedIdentifiers;
+
+  /**
+   * The database boolean true value (typically either 1, T, or Y).
+   */
+  private String databaseBooleanTrue;
+
+  /**
+   * The database boolean false value (typically either 0, F or N).
+   */
+  private String databaseBooleanFalse;
+
+  /**
+   * For DB's using sequences this is the number of sequence values prefetched.
+   */
+  private int databaseSequenceBatchSize = 20;
+
+  /**
+   * Set for DB's that support both Sequence and Identity (and the default choice is not desired).
+   */
+  private IdType idType;
+
+  /**
+   * The Geometry SRID value (default 4326).
+   */
+  private int geometrySRID = 4326;
+
+  /**
+   * Setting to indicate if UUID should be stored as binary(16) or varchar(40) or native DB type (for H2 and Postgres).
+   */
+  private DbUuid dbUuid = DbUuid.AUTO_VARCHAR;
+
+  /**
+   * Modify the default mapping of standard types such as default precision for DECIMAL etc.
+   */
+  private List<CustomDbTypeMapping> customDbTypeMappings = new ArrayList<>();
+
+  /**
+   * Construct with defaults.
+   */
+  public PlatformConfig() {
+
+  }
+
+  /**
+   * Construct based on given config - typically for DbMigration generation with many platforms.
+   */
+  public PlatformConfig(PlatformConfig platformConfig) {
+    this.databaseBooleanFalse = platformConfig.databaseBooleanFalse;
+    this.databaseBooleanTrue = platformConfig.databaseBooleanTrue;
+    this.databaseSequenceBatchSize = platformConfig.databaseSequenceBatchSize;
+    this.idType = platformConfig.idType;
+    this.geometrySRID = platformConfig.geometrySRID;
+    this.dbUuid = platformConfig.dbUuid;
+  }
+
+  /**
+   * Return true if all DB column and table names should use quoted identifiers.
+   */
+  public boolean isAllQuotedIdentifiers() {
+    return allQuotedIdentifiers;
+  }
+
+  /**
+   * Set to true if all DB column and table names should use quoted identifiers.
+   */
+  public void setAllQuotedIdentifiers(boolean allQuotedIdentifiers) {
+    this.allQuotedIdentifiers = allQuotedIdentifiers;
+  }
+
+  /**
+   * Return a value used to represent TRUE in the database.
+   * <p>
+   * This is used for databases that do not support boolean natively.
+   * </p>
+   * <p>
+   * The value returned is either a Integer or a String (e.g. "1", or "T").
+   * </p>
+   */
+  public String getDatabaseBooleanTrue() {
+    return databaseBooleanTrue;
+  }
+
+  /**
+   * Set the value to represent TRUE in the database.
+   * <p>
+   * This is used for databases that do not support boolean natively.
+   * </p>
+   * <p>
+   * The value set is either a Integer or a String (e.g. "1", or "T").
+   * </p>
+   */
+  public void setDatabaseBooleanTrue(String databaseBooleanTrue) {
+    this.databaseBooleanTrue = databaseBooleanTrue;
+  }
+
+  /**
+   * Return a value used to represent FALSE in the database.
+   */
+  public String getDatabaseBooleanFalse() {
+    return databaseBooleanFalse;
+  }
+
+  /**
+   * Set the value used to represent FALSE in the database.
+   */
+  public void setDatabaseBooleanFalse(String databaseBooleanFalse) {
+    this.databaseBooleanFalse = databaseBooleanFalse;
+  }
+
+  /**
+   * Return the number of DB sequence values that should be preallocated.
+   */
+  public int getDatabaseSequenceBatchSize() {
+    return databaseSequenceBatchSize;
+  }
+
+  /**
+   * Set the number of DB sequence values that should be preallocated.
+   */
+  public void setDatabaseSequenceBatchSize(int databaseSequenceBatchSize) {
+    this.databaseSequenceBatchSize = databaseSequenceBatchSize;
+  }
+
+  /**
+   * Return the Geometry SRID.
+   */
+  public int getGeometrySRID() {
+    return geometrySRID;
+  }
+
+  /**
+   * Set the Geometry SRID.
+   */
+  public void setGeometrySRID(int geometrySRID) {
+    this.geometrySRID = geometrySRID;
+  }
+
+  /**
+   * Return the DB type used to store UUID.
+   */
+  public DbUuid getDbUuid() {
+    return dbUuid;
+  }
+
+  /**
+   * Set the DB type used to store UUID.
+   */
+  public void setDbUuid(DbUuid dbUuid) {
+    this.dbUuid = dbUuid;
+  }
+
+  /**
+   * Return the IdType to use (or null for the default choice).
+   */
+  public IdType getIdType() {
+    return idType;
+  }
+
+  /**
+   * Set the IdType to use (when the DB supports both SEQUENCE and IDENTITY and the default is not desired).
+   */
+  public void setIdType(IdType idType) {
+    this.idType = idType;
+  }
+
+  /**
+   * Add a custom type mapping.
+   * <p>
+   * <pre>{@code
+   *
+   *   // set the default mapping for BigDecimal.class/decimal
+   *   serverConfig.addCustomMapping(DbType.DECIMAL, "decimal(18,6)");
+   *
+   *   // set the default mapping for String.class/varchar but only for Postgres
+   *   serverConfig.addCustomMapping(DbType.VARCHAR, "text", Platform.POSTGRES);
+   *
+   * }</pre>
+   *
+   * @param type             The DB type this mapping should apply to
+   * @param columnDefinition The column definition that should be used
+   * @param platform         Optionally specify the platform this mapping should apply to.
+   */
+  public void addCustomMapping(DbType type, String columnDefinition, Platform platform) {
+    customDbTypeMappings.add(new CustomDbTypeMapping(type, columnDefinition, platform));
+  }
+
+  /**
+   * Add a custom type mapping that applies to all platforms.
+   * <p>
+   * <pre>{@code
+   *
+   *   // set the default mapping for BigDecimal/decimal
+   *   serverConfig.addCustomMapping(DbType.DECIMAL, "decimal(18,6)");
+   *
+   *   // set the default mapping for String/varchar
+   *   serverConfig.addCustomMapping(DbType.VARCHAR, "text");
+   *
+   * }</pre>
+   *
+   * @param type             The DB type this mapping should apply to
+   * @param columnDefinition The column definition that should be used
+   */
+  public void addCustomMapping(DbType type, String columnDefinition) {
+    customDbTypeMappings.add(new CustomDbTypeMapping(type, columnDefinition));
+  }
+
+  /**
+   * Return the list of custom type mappings.
+   */
+  public List<CustomDbTypeMapping> getCustomTypeMappings() {
+    return customDbTypeMappings;
+  }
+
+  public void loadSettings(PropertiesWrapper p) {
+
+    idType = p.getEnum(IdType.class, "idType", idType);
+    databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", databaseSequenceBatchSize);
+    databaseBooleanTrue = p.get("databaseBooleanTrue", databaseBooleanTrue);
+    databaseBooleanFalse = p.get("databaseBooleanFalse", databaseBooleanFalse);
+
+    DbUuid dbUuid = p.getEnum(DbUuid.class, "dbuuid", null);
+    if (dbUuid != null) {
+      setDbUuid(dbUuid);
+    }
+    if (p.getBoolean("uuidStoreAsBinary", false)) {
+      setDbUuid(DbUuid.BINARY);
+    }
+
+    int srid = p.getInt("geometrySRID", 0);
+    if (srid > 0) {
+      setGeometrySRID(srid);
+    }
+
+    // Mapping is specified in the form: BOOLEAN=int(1);BIT=int(1);
+    String mapping = p.get("mapping");
+    if (mapping != null && !mapping.isEmpty()) {
+      Map<String, String> map = StringHelper.delimitedToMap(mapping, ";", "=");
+      for (Entry<String, String> entry : map.entrySet()) {
+        addCustomMapping(DbType.valueOf(entry.getKey()), entry.getValue());
+      }
+    }
+
+    boolean quotedIdentifiers = p.getBoolean("allQuotedIdentifiers", allQuotedIdentifiers);
+    if (quotedIdentifiers != allQuotedIdentifiers) {
+      // potentially also set to use matching naming convention
+      setAllQuotedIdentifiers(quotedIdentifiers);
+    }
+  }
+
+  /**
+   * Specify how UUID is stored.
+   */
+  public enum DbUuid {
+
+
+    /**
+     * Store using native UUID in H2 and Postgres and otherwise fallback to VARCHAR(40).
+     */
+    AUTO_VARCHAR(true, false, false),
+
+    /**
+     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16).
+     */
+    AUTO_BINARY(true, true, false),
+
+    /**
+     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16) with optimized packing.
+     */
+    AUTO_BINARY_OPTIMIZED(true, true, true),
+
+    /**
+     * Store using DB VARCHAR(40).
+     */
+    VARCHAR(false, false, false),
+
+    /**
+     * Store using DB BINARY(16).
+     */
+    BINARY(false, true, false),
+
+    /**
+     * Store using DB BINARY(16).
+     */
+    BINARY_OPTIMIZED(false, true, true);
+
+    boolean nativeType;
+    boolean binary;
+    boolean binaryOptimized;
+
+    DbUuid(boolean nativeType, boolean binary, boolean binaryOptimized) {
+      this.nativeType = nativeType;
+      this.binary = binary;
+      this.binaryOptimized = binaryOptimized;
+    }
+
+    /**
+     * Return true if native UUID type is preferred.
+     */
+    public boolean useNativeType() {
+      return nativeType;
+    }
+
+    /**
+     * Return true if BINARY(16) storage is preferred over VARCHAR(40).
+     */
+    public boolean useBinary() {
+      return binary;
+    }
+
+    /**
+     * Return true, if optimized packing should be used.
+     */
+    public boolean useBinaryOptimized() {
+      return binaryOptimized;
+    }
+  }
+}

src/main/java/io/ebean/config/PropertiesWrapper.java

@@ -10,44 +10,23 @@ public class PropertiesWrapper {
 
   protected final String serverName;
 
-  protected final PropertyMap propertyMap;
+  private final ClassLoadConfig classLoadConfig;
 
   /**
    * Construct with a prefix, serverName and properties.
    */
-  public PropertiesWrapper(String prefix, String serverName, Properties properties) {
+  public PropertiesWrapper(String prefix, String serverName, Properties properties, ClassLoadConfig classLoadConfig) {
     this.serverName = serverName;
     this.prefix = prefix;
-    this.propertyMap = PropertyMapLoader.load(null, properties);
-    this.properties = propertyMap.asProperties();
+    this.properties = properties;
+    this.classLoadConfig = classLoadConfig;
   }
 
   /**
    * Construct without prefix of serverName.
    */
-  public PropertiesWrapper(Properties properties) {
-    this(null, null, properties);
-  }
-
-  /**
-   * Internal copy constructor when changing prefix.
-   */
-  protected PropertiesWrapper(String prefix, String serverName, PropertyMap propertyMap, Properties properties) {
-    this.serverName = serverName;
-    this.prefix = prefix;
-    this.propertyMap = propertyMap;
-    this.properties = properties;
-  }
-
-  /**
-   * Return a PropertiesWrapper instance with a different prefix but same underlying properties.
-   * <p/>
-   * Used when wanting to use "datasource" as the prefix rather than "ebean".
-   * <p/>
-   * The returning instance should only be used in a read only fashion.
-   */
-  public PropertiesWrapper withPrefix(String prefix) {
-    return new PropertiesWrapper(prefix, serverName, propertyMap, properties);
+  public PropertiesWrapper(Properties properties, ClassLoadConfig classLoadConfig) {
+    this(null, null, properties, classLoadConfig);
   }
 
   /**
@@ -57,16 +36,6 @@ public class PropertiesWrapper {
     return serverName;
   }
 
-  /**
-   * Return as Properties with lower case keys and after evaluation and additional properties loading has occurred.
-   * <p>
-   * Ebean has historically ignored the case of keys hence returning the Properties with all the keys lower cased.
-   * </p>
-   */
-  public Properties asPropertiesLowerCase() {
-    return properties;
-  }
-
   /**
    * Get a property with no default value.
    */
@@ -90,17 +59,21 @@ public class PropertiesWrapper {
 
     String value = null;
     if (serverName != null && prefix != null) {
-      value = propertyMap.get(prefix + "." + serverName + "." + key, null);
+      value = internalGet(prefix + "." + serverName + "." + key);
     }
     if (value == null && prefix != null) {
-      value = propertyMap.get(prefix + "." + key, null);
+      value = internalGet(prefix + "." + key);
     }
     if (value == null) {
-      value = propertyMap.get(key, null);
+      value = internalGet(key);
     }
     return value == null ? defaultValue : value;
   }
 
+  private String internalGet(String key) {
+    return properties.getProperty(key);
+  }
+
   /**
    * Return a double property value.
    */
@@ -145,4 +118,30 @@ public class PropertiesWrapper {
     return (level == null) ? defaultValue : Enum.valueOf(enumType, level.toUpperCase());
   }
 
+  /**
+   * Return the instance to use (can be null) for the given plugin.
+   *
+   * @param pluginType the type of plugin
+   * @param key        properties key
+   * @param instance   existing instance
+   */
+  public <T> T createInstance(Class<T> pluginType, String key, T instance) {
+
+    if (instance != null) {
+      return instance;
+    }
+    String classname = get(key, null);
+    return createInstance(pluginType, classname);
+  }
+
+  /**
+   * Return the instance to use (can be null) for the given plugin.
+   *
+   * @param pluginType the type of plugin
+   * @param classname  the implementation class as per properties
+   */
+  @SuppressWarnings("unchecked")
+  public <T> T createInstance(Class<T> pluginType, String classname) {
+    return classname == null ? null : (T) classLoadConfig.newInstance(classname);
+  }
 }

src/main/java/io/ebean/config/PropertyExpression.java

@@ -1,178 +0,0 @@
-package io.ebean.config;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.naming.InitialContext;
-import javax.naming.NamingException;
-
-/**
- * Helper used to evaluate expressions such as ${CATALINA_HOME}.
- * <p>
- * The expressions can contain environment variables, system properties or JNDI
- * properties. JNDI expressions take the form ${jndi:propertyName} where you
- * substitute propertyName with the name of the jndi property you wish to
- * evaluate.
- * </p>
- */
-final class PropertyExpression {
-
-  private static final Logger logger = LoggerFactory.getLogger(PropertyExpression.class);
-
-  /**
-   * Prefix for looking up JNDI Environment variable.
-   */
-  private static final String JAVA_COMP_ENV = "java:comp/env/";
-
-  /**
-   * Used to detect the start of an expression.
-   */
-  private static final String START = "${";
-
-  /**
-   * Used to detect the end of an expression.
-   */
-  private static final String END = "}";
-
-  /**
-   * Specify the PropertyHolder.
-   */
-  private PropertyExpression() {
-  }
-
-  /**
-   * Return the property value evaluating and replacing any expressions such as
-   * ${CATALINA_HOME}.
-   */
-  static String eval(String val, PropertyMap map) {
-    if (val == null) {
-      return null;
-    }
-    int sp = val.indexOf(START);
-    if (sp > -1) {
-      int ep = val.indexOf(END, sp + 1);
-      if (ep > -1) {
-        return eval(val, sp, ep, map);
-      }
-    }
-    return val;
-  }
-
-  /**
-   * Convert the expression using JNDI, Environment variables, System Properties
-   * or existing an property in SystemProperties itself.
-   */
-  private static String evaluateExpression(String exp, PropertyMap map) {
-
-    if (isJndiExpression(exp)) {
-      // JNDI property lookup...
-      String val = getJndiProperty(exp);
-      if (val != null) {
-        return val;
-      }
-    }
-
-    // check Environment Variables first
-    String val = System.getenv(exp);
-    if (val == null) {
-      // then check system properties
-      val = System.getProperty(exp);
-    }
-    if (val == null && map != null) {
-      // then check PropertyMap
-      val = map.get(exp);
-    }
-
-    if (val != null) {
-      return val;
-
-    } else {
-      // unable to evaluate yet... but maybe later based on the order
-      // in which properties are being set/loaded. You can use
-      // GlobalProperties.evaluateExpressions() to get any unresolved
-      // expressions to be evaluated
-      logger.debug("Unable to evaluate expression [{}]", exp);
-      return null;
-    }
-  }
-
-  private static String eval(String val, int sp, int ep, PropertyMap map) {
-
-    StringBuilder sb = new StringBuilder();
-    sb.append(val.substring(0, sp));
-
-    String cal = evalExpression(val, sp, ep, map);
-    sb.append(cal);
-
-    eval(val, ep + 1, sb, map);
-
-    return sb.toString();
-  }
-
-  private static void eval(String val, int startPos, StringBuilder sb, PropertyMap map) {
-    if (startPos < val.length()) {
-      int sp = val.indexOf(START, startPos);
-      if (sp > -1) {
-        // append what is between the last token and the new one (if startPos ==
-        // sp nothing gets added)
-        sb.append(val.substring(startPos, sp));
-        int ep = val.indexOf(END, sp + 1);
-        if (ep > -1) {
-          String cal = evalExpression(val, sp, ep, map);
-          sb.append(cal);
-          eval(val, ep + 1, sb, map);
-          return;
-        }
-      }
-    }
-    // append what is left...
-    sb.append(val.substring(startPos));
-  }
-
-  private static String evalExpression(String val, int sp, int ep, PropertyMap map) {
-    // trim off start and end ${ and }
-    String exp = val.substring(sp + START.length(), ep);
-
-    // evaluate the variable
-    String evaled = evaluateExpression(exp, map);
-    if (evaled != null) {
-      return evaled;
-    } else {
-      // unable to evaluate at this stage (maybe later)
-      return START + exp + END;
-    }
-  }
-
-  private static boolean isJndiExpression(String exp) {
-    return exp.startsWith("JNDI:") || exp.startsWith("jndi:");
-  }
-
-  /**
-   * Returns null if JNDI is not setup or if the property is not found.
-   *
-   * @param key the key of the JNDI Environment property including a JNDI: prefix.
-   */
-  private static String getJndiProperty(String key) {
-
-    try {
-      // remove the JNDI: prefix
-      key = key.substring(5);
-
-      return (String) getJndiObject(key);
-
-    } catch (NamingException ex) {
-      return null;
-    }
-  }
-
-  /**
-   * Similar to getProperty but throws NamingException if JNDI is not setup or
-   * if the property is not found.
-   */
-  private static Object getJndiObject(String key) throws NamingException {
-
-    InitialContext ctx = new InitialContext();
-    return ctx.lookup(JAVA_COMP_ENV + key);
-  }
-
-}

src/main/java/io/ebean/config/PropertyMap.java

@@ -1,168 +0,0 @@
-package io.ebean.config;
-
-import java.io.Serializable;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Properties;
-import java.util.Set;
-
-/**
- * A map like structure of properties.
- * <p/>
- * Handles evaluation of expressions like ${home} and provides convenience methods for int, long and boolean.
- */
-public final class PropertyMap implements Serializable {
-
-  private static final long serialVersionUID = 1L;
-
-  private final LinkedHashMap<String, String> map = new LinkedHashMap<>();
-
-  /**
-   * Return properties loaded from test-ebean.properties.
-   */
-  public static Properties testProperties() {
-    PropertyMap propertyMap = PropertyMapLoader.loadTestProperties();
-    return (propertyMap == null) ? new Properties() : propertyMap.asProperties();
-  }
-
-  public static Properties defaultProperties() {
-    PropertyMap propertyMap = PropertyMapLoader.loadGlobalProperties();
-    return (propertyMap == null) ? new Properties() : propertyMap.asProperties();
-  }
-
-  public static boolean loadTestProperties() {
-    String disable = System.getProperty("disableTestProperties");
-    return (disable == null || !disable.equalsIgnoreCase("true"));
-  }
-
-  @Override
-  public String toString() {
-    return map.toString();
-  }
-
-  /**
-   * Return as standard Properties.
-   */
-  public Properties asProperties() {
-    Properties properties = new Properties();
-    for (Entry<String, String> e : entrySet()) {
-      properties.put(e.getKey(), e.getValue());
-    }
-    return properties;
-  }
-
-  /**
-   * Go through all the properties and evaluate any expressions that have not
-   * been resolved.
-   */
-  public void evaluateProperties() {
-
-    for (Entry<String, String> e : entrySet()) {
-      String key = e.getKey();
-      String val = e.getValue();
-      String eval = eval(val);
-      if (eval != null && !eval.equals(val)) {
-        put(key, eval);
-      }
-    }
-  }
-
-  /**
-   * Returns the value with expressions like ${home} evaluated using system properties and environment variables.
-   */
-  public synchronized String eval(String val) {
-    return PropertyExpression.eval(val, this);
-  }
-
-  /**
-   * Return the boolean property value with a given default.
-   */
-  public synchronized boolean getBoolean(String key, boolean defaultValue) {
-    String value = get(key);
-    if (value == null) {
-      return defaultValue;
-    } else {
-      return Boolean.parseBoolean(value);
-    }
-  }
-
-  /**
-   * Return the int property value with a given default.
-   */
-  public synchronized int getInt(String key, int defaultValue) {
-    String value = get(key);
-    if (value == null) {
-      return defaultValue;
-    } else {
-      return Integer.parseInt(value);
-    }
-  }
-
-  /**
-   * Return the long property value with a given default.
-   */
-  public synchronized long getLong(String key, long defaultValue) {
-    String value = get(key);
-    if (value == null) {
-      return defaultValue;
-    } else {
-      return Long.parseLong(value);
-    }
-  }
-
-  /**
-   * Return the string property value with a given default.
-   */
-  public synchronized String get(String key, String defaultValue) {
-    String value = map.get(key.toLowerCase());
-    return value == null ? defaultValue : value;
-  }
-
-  /**
-   * Return the property value returning null if there is no value defined.
-   */
-  public synchronized String get(String key) {
-    return map.get(key.toLowerCase());
-  }
-
-  /**
-   * Put all evaluating any expressions in the values.
-   */
-  public synchronized void putEvalAll(Map<String, String> keyValueMap) {
-
-    for (Map.Entry<String, String> entry : keyValueMap.entrySet()) {
-      putEval(entry.getKey(), entry.getValue());
-    }
-  }
-
-  /**
-   * Put a single key value evaluating any expressions in the value.
-   */
-  public synchronized String putEval(String key, String value) {
-    value = PropertyExpression.eval(value, this);
-    return map.put(key.toLowerCase(), value);
-  }
-
-  /**
-   * Put a single key value with no expression evaluation.
-   */
-  public synchronized String put(String key, String value) {
-    return map.put(key.toLowerCase(), value);
-  }
-
-  /**
-   * Remove an entry.
-   */
-  public synchronized String remove(String key) {
-    return map.remove(key.toLowerCase());
-  }
-
-  /**
-   * Return the entries.
-   */
-  public synchronized Set<Entry<String, String>> entrySet() {
-    return map.entrySet();
-  }
-
-}

src/main/java/io/ebean/config/PropertyMapLoader.java

@@ -1,163 +0,0 @@
-package io.ebean.config;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Map;
-import java.util.Properties;
-
-/**
- * Helper used to load the ebean.properties into a PropertyMap.
- */
-final class PropertyMapLoader {
-
-  private static final Logger logger = LoggerFactory.getLogger(PropertyMapLoader.class);
-
-  private static final Pattern OTHER_PROPS_REPLACE = Pattern.compile("\\", Pattern.LITERAL);
-
-  /**
-   * Load the <code>test-ebean.properties</code>.
-   */
-  public static PropertyMap loadTestProperties() {
-    if (!PropertyMap.loadTestProperties()) {
-      return new PropertyMap();
-    }
-    return load(null, "test-ebean.properties");
-  }
-
-  /**
-   * Load the ebean.properties (and test-ebean.properties if present).
-   */
-  public static PropertyMap loadGlobalProperties() {
-
-    boolean loadTestProperties = false;
-    String fileName = System.getenv("EBEAN_PROPS_FILE");
-    if (fileName == null) {
-      fileName = System.getProperty("ebean.props.file");
-      if (fileName == null) {
-        loadTestProperties = PropertyMap.loadTestProperties();
-        fileName = "ebean.properties";
-      }
-    }
-
-    PropertyMap map = load(null, fileName);
-    if (loadTestProperties) {
-      // load test properties if present in classpath
-      map = load(map, "test-ebean.properties");
-    }
-    return map;
-  }
-
-  /**
-   * Load the file returning the property map.
-   *
-   * @param p        an existing property map to load into.
-   * @param fileName the name of the properties file to load.
-   */
-  public static PropertyMap load(PropertyMap p, String fileName) {
-
-    InputStream is = findInputStream(fileName);
-    if (is == null) {
-      return p;
-    } else {
-      return load(p, is);
-    }
-  }
-
-  /**
-   * Load the InputStream returning the property map.
-   *
-   * @param p  an existing property map to load into.
-   * @param in the InputStream of the properties file to load.
-   */
-  public static PropertyMap load(PropertyMap p, InputStream in) {
-
-    Properties props = new Properties();
-    try {
-      props.load(in);
-      in.close();
-      return load(p, props);
-
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  public static PropertyMap load(PropertyMap p, Properties props) {
-
-    if (p == null) {
-      p = new PropertyMap();
-    }
-
-    // put values in initially without any evaluation
-    for (Map.Entry<Object, Object> entry : props.entrySet()) {
-      String key = ((String) entry.getKey()).toLowerCase();
-      String val = ((String) entry.getValue());
-      if (val != null) {
-        val = val.trim();
-      }
-      p.put(key, val);
-    }
-
-    p.evaluateProperties();
-
-    String otherProps = p.remove("load.properties");
-    if (otherProps == null) {
-      otherProps = p.remove("load.properties.override");
-    }
-    if (otherProps != null) {
-      otherProps = OTHER_PROPS_REPLACE.matcher(otherProps).replaceAll(Matcher.quoteReplacement("/"));
-      InputStream is = findInputStream(otherProps);
-      if (is != null) {
-        logger.debug("loading properties from {}", otherProps);
-        load(p, is);
-      } else {
-        logger.error("load.properties " + otherProps + " not found.");
-      }
-    }
-
-    return p;
-  }
-
-  /**
-   * Find the input stream given the file name.
-   */
-  private static InputStream findInputStream(String fileName) {
-
-    if (fileName == null) {
-      throw new NullPointerException("fileName is null?");
-    }
-
-    try {
-      File f = new File(fileName);
-
-      if (f.exists()) {
-        logger.debug("{} found in file system", fileName);
-        return new FileInputStream(f);
-      } else {
-        InputStream in = findInClassPath(fileName);
-        if (in != null) {
-          logger.debug("{} found in classpath", fileName);
-        }
-        return in;
-      }
-
-    } catch (FileNotFoundException ex) {
-      // already made the check so this
-      // should never be thrown
-      throw new RuntimeException(ex);
-    }
-  }
-
-  private static InputStream findInClassPath(String fileName) {
-    return Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);
-  }
-
-}

src/main/java/io/ebean/config/ServerConfig.java

@@ -12,6 +12,8 @@ import io.ebean.cache.ServerCachePlugin;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.DbEncrypt;
 import io.ebean.config.dbplatform.DbType;
+import io.ebean.config.dbplatform.IdType;
+import io.ebean.config.properties.PropertiesLoader;
 import io.ebean.event.BeanFindController;
 import io.ebean.event.BeanPersistController;
 import io.ebean.event.BeanPersistListener;
@@ -181,11 +183,6 @@ public class ServerConfig {
    */
   private DatabasePlatform databasePlatform;
 
-  /**
-   * For DB's using sequences this is the number of sequence values prefetched.
-   */
-  private int databaseSequenceBatchSize = 20;
-
   /**
    * JDBC fetchSize hint when using findList.  Defaults to 0 leaving it up to the JDBC driver.
    */
@@ -286,7 +283,7 @@ public class ServerConfig {
   /**
    * When true create a read only DataSource using readOnlyDataSourceConfig defaulting values from dataSourceConfig.
    * I believe this will default to true in some future release (as it has a nice performance benefit).
-   *
+   * <p>
    * autoReadOnlyDataSource is an unfortunate name for this config option but I haven't come up with a better one.
    */
   private boolean autoReadOnlyDataSource;
@@ -323,18 +320,6 @@ public class ServerConfig {
    */
   private String dataSourceJndiName;
 
-  /**
-   * The database boolean true value (typically either 1, T, or Y).
-   */
-  private String databaseBooleanTrue;
-
-  /**
-   * The database boolean false value (typically either 0, F or N).
-   */
-  private String databaseBooleanFalse;
-
-  private boolean allQuotedIdentifiers;
-
   /**
    * The naming convention.
    */
@@ -361,9 +346,19 @@ public class ServerConfig {
   private boolean updatesDeleteMissingChildren = true;
 
   /**
-   * Database type configuration.
+   * Database platform configuration.
    */
-  private DbTypeConfig dbTypeConfig = new DbTypeConfig();
+  private PlatformConfig platformConfig = new PlatformConfig();
+
+  /**
+   * The UUID version to use.
+   */
+  private UuidVersion uuidVersion = UuidVersion.VERSION4;
+
+  /**
+   * The UUID state file (for Version 1 UUIDs).
+   */
+  private String uuidStateFile = "ebean-uuid.state";
 
   private List<IdGenerator> idGenerators = new ArrayList<>();
   private List<BeanFindController> findControllers = new ArrayList<>();
@@ -463,6 +458,19 @@ public class ServerConfig {
    */
   private boolean disableL2Cache;
 
+
+  /**
+   * Should the javax.validation.constraints.NotNull enforce a notNull column in DB.
+   * If set to false, use io.ebean.annotation.NotNull or Column(nullable=true).
+   */
+  private boolean useJavaxValidationNotNull = true;
+
+  /**
+   * Generally we want to perform L2 cache notification in the background and not impact
+   * the performance of executing transactions.
+   */
+  private boolean notifyL2CacheInForeground;
+
   /**
    * The time in millis used to determine when a query is alerted for being slow.
    */
@@ -473,9 +481,18 @@ public class ServerConfig {
    */
   private SlowQueryListener slowQueryListener;
 
-
   private ProfilingConfig profilingConfig = new ProfilingConfig();
 
+  /**
+   * Controls the default order by id setting of queries. See {@link Query#orderById(boolean)}
+   */
+  private boolean defaultOrderById = false;
+
+  /**
+   * The mappingLocations for searching xml mapping.
+   */
+  private List<String> mappingLocations = new ArrayList<>();
+
   /**
    * Construct a Server Configuration for programmatically creating an EbeanServer.
    */
@@ -511,6 +528,21 @@ public class ServerConfig {
     this.slowQueryListener = slowQueryListener;
   }
 
+
+  /**
+   * Sets the default orderById setting for queries.
+   */
+  public void setDefaultOrderById(boolean defaultOrderById) {
+    this.defaultOrderById = defaultOrderById;
+  }
+
+  /**
+   * Returns the default orderById setting for queries.
+   */
+  public boolean isDefaultOrderById() {
+    return defaultOrderById;
+  }
+
   /**
    * Put a service object into configuration such that it can be passed to a plugin.
    * <p>
@@ -897,7 +929,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseSequenceBatchSize(int databaseSequenceBatchSize) {
-    this.databaseSequenceBatchSize = databaseSequenceBatchSize;
+    platformConfig.setDatabaseSequenceBatchSize(databaseSequenceBatchSize);
   }
 
   /**
@@ -1079,14 +1111,14 @@ public class ServerConfig {
    * Return the Geometry SRID.
    */
   public int getGeometrySRID() {
-    return dbTypeConfig.getGeometrySRID();
+    return platformConfig.getGeometrySRID();
   }
 
   /**
    * Set the Geometry SRID.
    */
   public void setGeometrySRID(int geometrySRID) {
-    dbTypeConfig.setGeometrySRID(geometrySRID);
+    platformConfig.setGeometrySRID(geometrySRID);
   }
 
   /**
@@ -1376,15 +1408,21 @@ public class ServerConfig {
    * Return true if all DB column and table names should use quoted identifiers.
    */
   public boolean isAllQuotedIdentifiers() {
-    return allQuotedIdentifiers;
+    return platformConfig.isAllQuotedIdentifiers();
   }
 
   /**
    * Set to true if all DB column and table names should use quoted identifiers.
    */
   public void setAllQuotedIdentifiers(boolean allQuotedIdentifiers) {
-    this.allQuotedIdentifiers = allQuotedIdentifiers;
-    if (allQuotedIdentifiers && namingConvention instanceof UnderscoreNamingConvention) {
+    platformConfig.setAllQuotedIdentifiers(allQuotedIdentifiers);
+    if (allQuotedIdentifiers) {
+      adjustNamingConventionForAllQuoted();
+    }
+  }
+
+  private void adjustNamingConventionForAllQuoted() {
+    if (namingConvention instanceof UnderscoreNamingConvention) {
       // we need to use matching naming convention
       this.namingConvention = new MatchingNamingConvention();
     }
@@ -1599,7 +1637,7 @@ public class ServerConfig {
    * </p>
    */
   public String getDatabaseBooleanTrue() {
-    return databaseBooleanTrue;
+    return platformConfig.getDatabaseBooleanTrue();
   }
 
   /**
@@ -1612,7 +1650,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseBooleanTrue(String databaseTrue) {
-    this.databaseBooleanTrue = databaseTrue;
+    platformConfig.setDatabaseBooleanTrue(databaseTrue);
   }
 
   /**
@@ -1625,7 +1663,7 @@ public class ServerConfig {
    * </p>
    */
   public String getDatabaseBooleanFalse() {
-    return databaseBooleanFalse;
+    return platformConfig.getDatabaseBooleanFalse();
   }
 
   /**
@@ -1638,14 +1676,14 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseBooleanFalse(String databaseFalse) {
-    this.databaseBooleanFalse = databaseFalse;
+    this.platformConfig.setDatabaseBooleanFalse(databaseFalse);
   }
 
   /**
    * Return the number of DB sequence values that should be preallocated.
    */
   public int getDatabaseSequenceBatchSize() {
-    return databaseSequenceBatchSize;
+    return platformConfig.getDatabaseSequenceBatchSize();
   }
 
   /**
@@ -1664,7 +1702,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseSequenceBatch(int databaseSequenceBatchSize) {
-    this.databaseSequenceBatchSize = databaseSequenceBatchSize;
+    this.platformConfig.setDatabaseSequenceBatchSize(databaseSequenceBatchSize);
   }
 
   /**
@@ -1691,7 +1729,7 @@ public class ServerConfig {
    * that you don't have access to.
    * </p>
    * <p>
-   * Values are oracle, h2, postgres, mysql, mssqlserver2005.
+   * Values are oracle, h2, postgres, mysql, sqlserver16, sqlserver17.
    * </p>
    */
   public void setDatabasePlatformName(String databasePlatformName) {
@@ -1716,6 +1754,20 @@ public class ServerConfig {
     this.databasePlatform = databasePlatform;
   }
 
+  /**
+   * Return the preferred DB platform IdType.
+   */
+  public IdType getIdType() {
+    return platformConfig.getIdType();
+  }
+
+  /**
+   * Set the preferred DB platform IdType.
+   */
+  public void setIdType(IdType idType) {
+    this.platformConfig.setIdType(idType);
+  }
+
   /**
    * Return the EncryptKeyManager.
    */
@@ -1826,15 +1878,50 @@ public class ServerConfig {
   /**
    * Return the configuration for DB types (such as UUID and custom mappings).
    */
-  public DbTypeConfig getDbTypeConfig() {
-    return dbTypeConfig;
+  public PlatformConfig getPlatformConfig() {
+    return platformConfig;
+  }
+
+  /**
+   * Set the configuration for DB platform (such as UUID and custom mappings).
+   */
+  public void setPlatformConfig(PlatformConfig platformConfig) {
+    this.platformConfig = platformConfig;
   }
 
   /**
    * Set the DB type used to store UUID.
    */
-  public void setDbUuid(DbUuid dbUuid) {
-    this.dbTypeConfig.setDbUuid(dbUuid);
+  public void setDbUuid(PlatformConfig.DbUuid dbUuid) {
+    this.platformConfig.setDbUuid(dbUuid);
+  }
+
+  /**
+   * Returns the UUID version mode.
+   */
+  public UuidVersion getUuidVersion() {
+    return uuidVersion;
+  }
+
+  /**
+   * Sets the UUID version mode.
+   */
+  public void setUuidVersion(UuidVersion uuidVersion) {
+    this.uuidVersion = uuidVersion;
+  }
+
+  /**
+   * Return the UUID state file.
+   */
+  public String getUuidStateFile() {
+    return uuidStateFile;
+  }
+
+  /**
+   * Set the UUID state file.
+   */
+  public void setUuidStateFile(String uuidStateFile) {
+    this.uuidStateFile = uuidStateFile;
   }
 
   /**
@@ -1874,6 +1961,16 @@ public class ServerConfig {
     this.durationWithNanos = durationWithNanos;
   }
 
+  /**
+   * Set to true to run DB migrations on server start.
+   * <p>
+   * This is the same as serverConfig.getMigrationConfig().setRunMigration(). We have added this method here
+   * as it is often the only thing we need to configure for migrations.
+   */
+  public void setRunMigration(boolean runMigration){
+    migrationConfig.setRunMigration(runMigration);
+  }
+
   /**
    * Set to true to generate the "create all" DDL on startup.
    * <p>
@@ -2262,7 +2359,7 @@ public class ServerConfig {
    * @param platform         Optionally specify the platform this mapping should apply to.
    */
   public void addCustomMapping(DbType type, String columnDefinition, Platform platform) {
-    dbTypeConfig.addCustomMapping(type, columnDefinition, platform);
+    platformConfig.addCustomMapping(type, columnDefinition, platform);
   }
 
   /**
@@ -2282,7 +2379,7 @@ public class ServerConfig {
    * @param columnDefinition The column definition that should be used
    */
   public void addCustomMapping(DbType type, String columnDefinition) {
-    dbTypeConfig.addCustomMapping(type, columnDefinition);
+    platformConfig.addCustomMapping(type, columnDefinition);
   }
 
   /**
@@ -2551,7 +2648,8 @@ public class ServerConfig {
    * Load settings from ebean.properties.
    */
   public void loadFromProperties() {
-    loadFromProperties(PropertyMap.defaultProperties());
+    this.properties = PropertiesLoader.load();
+    configureFromProperties();
   }
 
   /**
@@ -2559,24 +2657,46 @@ public class ServerConfig {
    */
   public void loadFromProperties(Properties properties) {
     // keep the properties used for configuration so that these are available for plugins
-    this.properties = properties;
-    PropertiesWrapper p = new PropertiesWrapper("ebean", name, properties);
-    loadSettings(p);
+    this.properties = PropertiesLoader.eval(properties);
+    configureFromProperties();
   }
 
   /**
+   * Load the settings from the given properties
+   */
+  private void configureFromProperties() {
+    List<AutoConfigure> autoConfigures = autoConfiguration();
+    loadSettings(new PropertiesWrapper("ebean", name, properties, classLoadConfig));
+    for (AutoConfigure autoConfigure : autoConfigures) {
+      autoConfigure.postConfigure(this);
+    }
+  }
+
+  /**
+   * Use a 'plugin' to provide automatic configuration. Intended for automatic testing
+   * configuration with Docker containers via ebean-test-config.
+   */
+  private List<AutoConfigure> autoConfiguration() {
+    List<AutoConfigure> list = new ArrayList<>();
+    for (AutoConfigure autoConfigure : serviceLoad(AutoConfigure.class)) {
+      autoConfigure.preConfigure(this);
+      list.add(autoConfigure);
+    }
+    return list;
+  }
+
+  /**
+   * Deprecated - this does nothing now, we always try to read test configuration.
+   * <p>
    * Load settings from test-ebean.properties and do nothing if the properties is not found.
    * <p>
    * This is typically used when test-ebean.properties is put into the test class path and used
    * to configure Ebean for running tests.
    * </p>
    */
+  @Deprecated
   public void loadTestProperties() {
-    Properties properties = PropertyMap.testProperties();
-    if (!properties.isEmpty()) {
-      PropertiesWrapper p = new PropertiesWrapper("ebean", name, properties);
-      loadSettings(p);
-    }
+    // do nothing now ... as we always try to read test configuration and that should only
   }
 
   /**
@@ -2586,34 +2706,6 @@ public class ServerConfig {
     return properties;
   }
 
-  /**
-   * Return the instance to use (can be null) for the given plugin.
-   *
-   * @param properties the properties
-   * @param pluginType the type of plugin
-   * @param key        properties key
-   * @param instance   existing instance
-   */
-  protected <T> T createInstance(PropertiesWrapper properties, Class<T> pluginType, String key, T instance) {
-
-    if (instance != null) {
-      return instance;
-    }
-    String classname = properties.get(key, null);
-    return createInstance(pluginType, classname);
-  }
-
-  /**
-   * Return the instance to use (can be null) for the given plugin.
-   *
-   * @param pluginType the type of plugin
-   * @param classname  the implementation class as per properties
-   */
-  @SuppressWarnings("unchecked")
-  protected <T> T createInstance(Class<T> pluginType, String classname) {
-    return classname == null ? null : (T) classLoadConfig.newInstance(classname);
-  }
-
   /**
    * loads the data source settings to preserve existing behaviour. IMHO, if someone has set the datasource config already,
    * they don't want the settings to be reloaded and reset. This allows a descending class to override this behaviour and prevent it
@@ -2623,6 +2715,7 @@ public class ServerConfig {
    */
   protected void loadDataSourceSettings(PropertiesWrapper p) {
     dataSourceConfig.loadSettings(p.properties, name);
+    readOnlyDataSourceConfig.loadSettings(p.properties, name);
   }
 
   /**
@@ -2646,11 +2739,9 @@ public class ServerConfig {
 
     profilingConfig.loadSettings(p, name);
     migrationConfig.loadSettings(p, name);
-
-    boolean quotedIdentifiers = p.getBoolean("allQuotedIdentifiers", allQuotedIdentifiers);
-    if (quotedIdentifiers != allQuotedIdentifiers) {
-      // potentially also set to use matching naming convention
-      setAllQuotedIdentifiers(quotedIdentifiers);
+    platformConfig.loadSettings(p);
+    if (platformConfig.isAllQuotedIdentifiers()) {
+      adjustNamingConventionForAllQuoted();
     }
     namingConvention = createNamingConvention(p, namingConvention);
     if (namingConvention != null) {
@@ -2671,36 +2762,31 @@ public class ServerConfig {
     }
     loadDocStoreSettings(p);
 
-    int srid = p.getInt("geometrySRID", 0);
-    if (srid > 0) {
-      dbTypeConfig.setGeometrySRID(srid);
-    }
-
     queryPlanTTLSeconds = p.getInt("queryPlanTTLSeconds", queryPlanTTLSeconds);
     slowQueryMillis = p.getLong("slowQueryMillis", slowQueryMillis);
     docStoreOnly = p.getBoolean("docStoreOnly", docStoreOnly);
     disableL2Cache = p.getBoolean("disableL2Cache", disableL2Cache);
+    notifyL2CacheInForeground = p.getBoolean("notifyL2CacheInForeground", notifyL2CacheInForeground);
     explicitTransactionBeginMode = p.getBoolean("explicitTransactionBeginMode", explicitTransactionBeginMode);
     autoCommitMode = p.getBoolean("autoCommitMode", autoCommitMode);
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
+    useJavaxValidationNotNull = p.getBoolean("useJavaxValidationNotNull", useJavaxValidationNotNull);
     autoReadOnlyDataSource = p.getBoolean("autoReadOnlyDataSource", autoReadOnlyDataSource);
 
     backgroundExecutorSchedulePoolSize = p.getInt("backgroundExecutorSchedulePoolSize", backgroundExecutorSchedulePoolSize);
     backgroundExecutorShutdownSecs = p.getInt("backgroundExecutorShutdownSecs", backgroundExecutorShutdownSecs);
     disableClasspathSearch = p.getBoolean("disableClasspathSearch", disableClasspathSearch);
-    currentUserProvider = createInstance(p, CurrentUserProvider.class, "currentUserProvider", currentUserProvider);
-    databasePlatform = createInstance(p, DatabasePlatform.class, "databasePlatform", databasePlatform);
-    encryptKeyManager = createInstance(p, EncryptKeyManager.class, "encryptKeyManager", encryptKeyManager);
-    encryptDeployManager = createInstance(p, EncryptDeployManager.class, "encryptDeployManager", encryptDeployManager);
-    encryptor = createInstance(p, Encryptor.class, "encryptor", encryptor);
-    dbEncrypt = createInstance(p, DbEncrypt.class, "dbEncrypt", dbEncrypt);
+    currentUserProvider = p.createInstance(CurrentUserProvider.class, "currentUserProvider", currentUserProvider);
+    databasePlatform = p.createInstance(DatabasePlatform.class, "databasePlatform", databasePlatform);
+    encryptKeyManager = p.createInstance(EncryptKeyManager.class, "encryptKeyManager", encryptKeyManager);
+    encryptDeployManager = p.createInstance(EncryptDeployManager.class, "encryptDeployManager", encryptDeployManager);
+    encryptor = p.createInstance(Encryptor.class, "encryptor", encryptor);
+    dbEncrypt = p.createInstance(DbEncrypt.class, "dbEncrypt", dbEncrypt);
     dbOffline = p.getBoolean("dbOffline", dbOffline);
-    serverCachePlugin = createInstance(p, ServerCachePlugin.class, "serverCachePlugin", serverCachePlugin);
+    serverCachePlugin = p.createInstance(ServerCachePlugin.class, "serverCachePlugin", serverCachePlugin);
 
-    if (packages != null) {
-      String packagesProp = p.get("search.packages", p.get("packages", null));
-      packages = getSearchJarsPackages(packagesProp);
-    }
+    String packagesProp = p.get("search.packages", p.get("packages", null));
+    packages = getSearchList(packagesProp, packages);
 
     collectQueryStatsByNode = p.getBoolean("collectQueryStatsByNode", collectQueryStatsByNode);
     collectQueryOrigins = p.getBoolean("collectQueryOrigins", collectQueryOrigins);
@@ -2736,18 +2822,12 @@ public class ServerConfig {
     dataSourceJndiName = p.get("dataSourceJndiName", dataSourceJndiName);
     jdbcFetchSizeFindEach = p.getInt("jdbcFetchSizeFindEach", jdbcFetchSizeFindEach);
     jdbcFetchSizeFindList = p.getInt("jdbcFetchSizeFindList", jdbcFetchSizeFindList);
-    databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", databaseSequenceBatchSize);
-    databaseBooleanTrue = p.get("databaseBooleanTrue", databaseBooleanTrue);
-    databaseBooleanFalse = p.get("databaseBooleanFalse", databaseBooleanFalse);
     databasePlatformName = p.get("databasePlatformName", databasePlatformName);
+    defaultOrderById = p.getBoolean("defaultOrderById", defaultOrderById);
+
+    uuidVersion = p.getEnum(UuidVersion.class, "uuidVersion", uuidVersion);
+    uuidStateFile = p.get("uuidStateFile", uuidStateFile);
 
-    DbUuid dbUuid = p.getEnum(DbUuid.class, "dbuuid", null);
-    if (dbUuid != null) {
-      dbTypeConfig.setDbUuid(dbUuid);
-    }
-    if (p.getBoolean("uuidStoreAsBinary", false)) {
-      dbTypeConfig.setDbUuid(DbUuid.BINARY);
-    }
     localTimeWithNanos = p.getBoolean("localTimeWithNanos", localTimeWithNanos);
     jodaLocalTimeMode = p.get("jodaLocalTimeMode", jodaLocalTimeMode);
 
@@ -2768,12 +2848,30 @@ public class ServerConfig {
     ddlInitSql = p.get("ddl.initSql", ddlInitSql);
     ddlSeedSql = p.get("ddl.seedSql", ddlSeedSql);
 
+    // read tenant-configuration from config:
+    // tenant.mode = NONE | DB | SCHEMA | CATALOG | PARTITION
+    String mode = p.get("tenant.mode");
+    if (mode != null) {
+      for (TenantMode value : TenantMode.values()) {
+        if (value.name().equalsIgnoreCase(mode)) {
+          tenantMode = value;
+          break;
+        }
+      }
+    }
+
+    currentTenantProvider = p.createInstance(CurrentTenantProvider.class, "tenant.currentTenantProvider", currentTenantProvider);
+    tenantCatalogProvider = p.createInstance(TenantCatalogProvider.class, "tenant.catalogProvider", tenantCatalogProvider);
+    tenantSchemaProvider = p.createInstance(TenantSchemaProvider.class, "tenant.schemaProvider", tenantSchemaProvider);
+    tenantPartitionColumn = p.get("tenant.partitionColumn", tenantPartitionColumn);
     classes = getClasses(p);
+
+    String mappingsProp = p.get("mappingLocations", null);
+    mappingLocations = getSearchList(mappingsProp, mappingLocations);
   }
 
   private NamingConvention createNamingConvention(PropertiesWrapper properties, NamingConvention namingConvention) {
-
-    NamingConvention nc = createInstance(properties, NamingConvention.class, "namingconvention", null);
+    NamingConvention nc = properties.createInstance(NamingConvention.class, "namingconvention", null);
     return (nc != null) ? nc : namingConvention;
   }
 
@@ -2806,17 +2904,17 @@ public class ServerConfig {
     return classes;
   }
 
-  private List<String> getSearchJarsPackages(String searchPackages) {
+  private List<String> getSearchList(String searchNames, List<String> defaultValue) {
 
-    if (searchPackages != null) {
-      String[] entries = StringHelper.splitNames(searchPackages);
+    if (searchNames != null) {
+      String[] entries = StringHelper.splitNames(searchNames);
 
       List<String> hitList = new ArrayList<>(entries.length);
       Collections.addAll(hitList, entries);
 
       return hitList;
     } else {
-      return new ArrayList<>();
+      return defaultValue;
     }
   }
 
@@ -2900,6 +2998,44 @@ public class ServerConfig {
     this.disableL2Cache = disableL2Cache;
   }
 
+  /**
+   * Returns if we use javax.validation.constraints.NotNull
+   */
+  public boolean isUseJavaxValidationNotNull() {
+    return useJavaxValidationNotNull;
+  }
+
+  /**
+   * Controls if Ebean should ignore <code>&x64;javax.validation.contstraints.NotNull</code>
+   * with respect to generating a <code>NOT NULL</code> column.
+   * <p>
+   * Normally when Ebean sees javax NotNull annotation it means that column is defined as NOT NULL.
+   * Set this to <code>false</code> and the javax NotNull annotation is effectively ignored (and
+   * we instead use Ebean's own NotNull annotation or JPA Column(nullable=false) annotation.
+   */
+  public void setUseJavaxValidationNotNull(boolean useJavaxValidationNotNull) {
+    this.useJavaxValidationNotNull = useJavaxValidationNotNull;
+  }
+
+  /**
+   * Return true if L2 cache notification should run in the foreground.
+   */
+  public boolean isNotifyL2CacheInForeground() {
+    return notifyL2CacheInForeground;
+  }
+
+  /**
+   * Set this to true to run L2 cache notification in the foreground.
+   * <p>
+   * In general we don't want to do that as when we use a distributed cache (like Ignite, Hazelcast etc)
+   * we are making network calls and we prefer to do this in background and not impact the response time
+   * of the executing transaction.
+   * </p>
+   */
+  public void setNotifyL2CacheInForeground(boolean notifyL2CacheInForeground) {
+    this.notifyL2CacheInForeground = notifyL2CacheInForeground;
+  }
+
   /**
    * Return the query plan time to live.
    */
@@ -2926,50 +3062,56 @@ public class ServerConfig {
   }
 
   /**
-   * Specify how UUID is stored.
+   * Create a new PlatformConfig based of the one held but with overridden properties by reading
+   * properties with the given path and prefix.
+   * <p>
+   * Typically used in Db Migration generation for many platform targets that might have different
+   * configuration for IdType, UUID, quoted identifiers etc.
+   * </p>
+   *
+   * @param propertiesPath The properties path used for loading and setting properties
+   * @param platformPrefix The prefix used for loading and setting properties
+   * @return A copy of the PlatformConfig with overridden properties
    */
-  public enum DbUuid {
+  public PlatformConfig newPlatformConfig(String propertiesPath, String platformPrefix) {
 
-    /**
-     * Store using native UUID in H2 and Postgres and otherwise fallback to VARCHAR(40).
-     */
-    AUTO_VARCHAR(true, false),
+    PropertiesWrapper p = new PropertiesWrapper(propertiesPath, platformPrefix, properties, classLoadConfig);
 
-    /**
-     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16).
-     */
-    AUTO_BINARY(true, true),
+    PlatformConfig config = new PlatformConfig(platformConfig);
+    config.loadSettings(p);
+    return config;
+  }
 
-    /**
-     * Store using DB VARCHAR(40).
-     */
-    VARCHAR(false, false),
-
-    /**
-     * Store using DB BINARY(16).
-     */
-    BINARY(false, true);
-
-    boolean nativeType;
-    boolean binary;
-
-    DbUuid(boolean nativeType, boolean binary) {
-      this.nativeType = nativeType;
-      this.binary = binary;
+  /**
+   * Add a mapping location to search for xml mapping via class path search.
+   */
+  public void addMappingLocation(String mappingLocation) {
+    if (mappingLocations == null) {
+      mappingLocations = new ArrayList<>();
     }
+    mappingLocations.add(mappingLocation);
+  }
 
-    /**
-     * Return true if native UUID type is preferred.
-     */
-    public boolean useNativeType() {
-      return nativeType;
-    }
+  /**
+   * Return mapping locations to search for xml mapping via class path search.
+   */
+  public List<String> getMappingLocations() {
+    return mappingLocations;
+  }
 
-    /**
-     * Return true if BINARY(16) storage is preferred over VARCHAR(40).
-     */
-    public boolean useBinary() {
-      return binary;
-    }
+  /**
+   * Set mapping locations to search for xml mapping via class path search.
+   * <p>
+   * This is only used if classes have not been explicitly specified.
+   * </p>
+   */
+  public void setMappingLocations(List<String> mappingLocations) {
+    this.mappingLocations = mappingLocations;
+  }
+
+  public enum UuidVersion {
+    VERSION4,
+    VERSION1,
+    VERSION1RND
   }
 }

src/main/java/io/ebean/config/TenantMode.java

@@ -8,32 +8,40 @@ public enum TenantMode {
   /**
    * No multi-tenancy.
    */
-  NONE(false),
+  NONE(false, true),
 
   /**
    * Each Tenant has their own Database (javax.sql.DataSource)
    */
-  DB(true),
+  DB(true, false),
 
   /**
    * Each Tenant has their own Database schema.
    */
-  SCHEMA(true),
+  SCHEMA(true, false),
 
   /**
    * Each Tenant has their own Database but with in connection pool
    */
-  CATALOG(true),
+  CATALOG(true, false),
 
   /**
    * Tenants share tables but have a discriminator/partition column that partitions the data.
    */
-  PARTITION(false);
+  PARTITION(false, true),
 
+  /**
+   * Each Tenant has their own Database (javax.sql.DataSource), and there is also one master-database
+   * (that holds configuration e.g.)
+   */
+  DB_WITH_MASTER(true, true);
+  
   boolean dynamicDataSource;
+  boolean ddlEnabled;
 
-  TenantMode(boolean dynamicDataSource) {
+  TenantMode(boolean dynamicDataSource, boolean ddlEnabled) {
     this.dynamicDataSource = dynamicDataSource;
+    this.ddlEnabled = ddlEnabled;
   }
 
   /**
@@ -42,4 +50,12 @@ public enum TenantMode {
   public boolean isDynamicDataSource() {
     return dynamicDataSource;
   }
+  
+  /**
+   * Returns true, if DDL is enabled.
+   */
+  public boolean isDdlEnabled() {
+    return ddlEnabled;
+  }
+ 
 }

src/main/java/io/ebean/config/UnderscoreNamingConvention.java

@@ -112,39 +112,7 @@ public class UnderscoreNamingConvention extends AbstractNamingConvention {
    * Convert and return the string to underscore from camel case.
    */
   protected String toUnderscoreFromCamel(String camelCase) {
-
-    int lastUpper = -1;
-    StringBuilder sb = new StringBuilder(camelCase.length() + 4);
-    for (int i = 0; i < camelCase.length(); i++) {
-      char c = camelCase.charAt(i);
-
-      if ('_' == c) {
-        // Underscores should just be passed through
-        sb.append(c);
-        lastUpper = i;
-      } else if (Character.isDigit(c)) {
-        if (i > lastUpper + 1 && !digitsCompressed) {
-          sb.append("_");
-        }
-        sb.append(c);
-        lastUpper = i;
-
-      } else if (Character.isUpperCase(c)) {
-        if (i > lastUpper + 1) {
-          sb.append("_");
-        }
-        sb.append(Character.toLowerCase(c));
-        lastUpper = i;
-
-      } else {
-        sb.append(c);
-      }
-    }
-    String ret = sb.toString();
-    if (forceUpperCase) {
-      ret = ret.toUpperCase();
-    }
-    return ret;
+    return CamelCaseHelper.toUnderscoreFromCamel(camelCase, digitsCompressed, forceUpperCase);
   }
 
   /**

src/main/java/io/ebean/config/dbplatform/DatabasePlatform.java

@@ -5,7 +5,8 @@ import io.ebean.Query;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Platform;
 import io.ebean.config.CustomDbTypeMapping;
-import io.ebean.config.DbTypeConfig;
+import io.ebean.config.PlatformConfig;
+import io.ebean.util.JdbcClose;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -98,6 +99,10 @@ public class DatabasePlatform {
    */
   protected DbIdentity dbIdentity = new DbIdentity();
 
+  protected boolean sequenceBatchMode = true;
+
+  protected int sequenceBatchSize = 20;
+
   /**
    * The history support for this database platform.
    */
@@ -140,9 +145,25 @@ public class DatabasePlatform {
   private static final char BACK_TICK = '`';
 
   /**
-   * The like clause. Can be overridden to disable default escape character.
+   * The non-escaped like clause (to stop slash being escaped on some platforms).
+   * Used for the 'raw like' expression but not for startsWith, endsWith and contains expressions.
    */
-  protected String likeClause = "like ?";
+  protected String likeClauseRaw = "like ? escape''";
+
+  /**
+   * Escaped like clause for startsWith, endsWith and contains.
+   */
+  protected String likeClauseEscaped = "like ? escape'|'";
+
+  /**
+   * Escape character used for startsWith, endsWith and contains.
+   */
+  protected char likeEscapeChar = '|';
+
+  /**
+   * Characters escaped for startsWith, endsWith and contains.
+   */
+  protected char[] likeSpecialCharacters = { '%', '_', '|' };
 
   protected DbEncrypt dbEncrypt;
 
@@ -177,8 +198,6 @@ public class DatabasePlatform {
 
   protected SqlExceptionTranslator exceptionTranslator = new SqlCodeTranslator();
 
-  protected char[] specialLikeCharacters = { '%', '_', '\\' };
-
   /**
    * Instantiates a new database platform.
    */
@@ -192,10 +211,19 @@ public class DatabasePlatform {
     return exceptionTranslator.translate(message, e);
   }
 
+  /**
+   * Configure the platform given the server configuration.
+   */
+  public void configure(PlatformConfig config) {
+    this.sequenceBatchSize = config.getDatabaseSequenceBatchSize();
+    configureIdType(config.getIdType());
+    configure(config, config.isAllQuotedIdentifiers());
+  }
+
   /**
    * Configure UUID Storage etc based on ServerConfig settings.
    */
-  public void configure(DbTypeConfig config, boolean allQuotedIdentifiers) {
+  protected void configure(PlatformConfig config, boolean allQuotedIdentifiers) {
     this.allQuotedIdentifiers = allQuotedIdentifiers;
     addGeoTypes(config.getGeometrySRID());
     configureIdType(config.getIdType());
@@ -249,6 +277,20 @@ public class DatabasePlatform {
     return platform.name().toLowerCase();
   }
 
+  /**
+   * Return true if we are using Sequence batch mode rather than STEP.
+   */
+  public boolean isSequenceBatchMode() {
+    return sequenceBatchMode;
+  }
+
+  /**
+   * Set to false to not use sequence batch mode but instead STEP mode.
+   */
+  public void setSequenceBatchMode(boolean sequenceBatchMode) {
+    this.sequenceBatchMode = sequenceBatchMode;
+  }
+
   /**
    * Return true if this database platform supports native ILIKE expression.
    */
@@ -290,10 +332,10 @@ public class DatabasePlatform {
    * @param be        the BackgroundExecutor that can be used to load the sequence if
    *                  desired
    * @param ds        the DataSource
+   * @param stepSize  the sequence allocation size as defined by mapping (defaults to 50)
    * @param seqName   the name of the sequence
-   * @param batchSize the number of sequences that should be loaded
    */
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
+  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, int stepSize, String seqName) {
     return null;
   }
 
@@ -339,6 +381,13 @@ public class DatabasePlatform {
     this.historySupport = historySupport;
   }
 
+  /**
+   * So no except for Postgres and CockroachDB.
+   */
+  public boolean isNativeArrayType() {
+    return false;
+  }
+
   /**
    * Return true if the DB supports native UUID.
    */
@@ -475,6 +524,13 @@ public class DatabasePlatform {
     this.forwardOnlyHintOnFindIterate = forwardOnlyHintOnFindIterate;
   }
 
+  /**
+   * Normally not needed - overridden in CockroachPlatform.
+   */
+  public boolean isDdlCommitOnCreateIndex() {
+    return false;
+  }
+
   /**
    * Return the DB identity/sequence features for this platform.
    *
@@ -572,6 +628,14 @@ public class DatabasePlatform {
     return sql;
   }
 
+  /**
+   * For update hint on the FROM clause (SQL server only).
+   */
+  public String fromForUpdate(Query.ForUpdate forUpdateMode) {
+    // return null except for sql server
+    return null;
+  }
+
   protected String withForUpdate(String sql, Query.ForUpdate forUpdateMode) {
     // silently assume the database does not support the "for update" clause.
     logger.info("it seems your database does not support the 'for update' clause");
@@ -583,8 +647,8 @@ public class DatabasePlatform {
    * <p>
    * This may include an escape clause to disable a default escape character.
    */
-  public String getLikeClause() {
-    return likeClause;
+  public String getLikeClause(boolean rawLikeExpression) {
+    return rawLikeExpression ? likeClauseRaw : likeClauseEscaped;
   }
 
   /**
@@ -604,18 +668,7 @@ public class DatabasePlatform {
     try {
       return tables.next();
     } finally {
-      close(tables);
-    }
-  }
-
-  /**
-   * Close the resultSet.
-   */
-  protected void close(ResultSet resultSet) {
-    try {
-      resultSet.close();
-    } catch (SQLException e) {
-      logger.error("Error closing resultSet", e);
+      JdbcClose.close(tables);
     }
   }
 
@@ -627,7 +680,7 @@ public class DatabasePlatform {
     for (int i = 0; i < value.length(); i++) {
       char ch = value.charAt(i);
       boolean escaped = false;
-      for (char escapeChar: specialLikeCharacters) {
+      for (char escapeChar: likeSpecialCharacters) {
         if (ch == escapeChar) {
           if (sb == null) {
             sb = new StringBuilder(value.substring(0, i));
@@ -649,6 +702,6 @@ public class DatabasePlatform {
   }
 
   protected void escapeLikeCharacter(char ch, StringBuilder sb) {
-    sb.append('\\').append(ch);
+    sb.append(likeEscapeChar).append(ch);
   }
 }

src/main/java/io/ebean/config/dbplatform/DbPlatformType.java

@@ -126,27 +126,33 @@ public class DbPlatformType implements ExtraDbTypes {
 
     StringBuilder sb = new StringBuilder();
     sb.append(name);
-
     if (canHaveLength || !strict) {
-      // see if there is a precision/scale to add (or not)
-      int len = deployLength != 0 ? deployLength : defaultLength;
-      if (len == Integer.MAX_VALUE) {
-        sb.append("(max)"); // TODO: this is sqlserver specific
-      } else if (len > 0) {
-        sb.append("(");
-        sb.append(len);
-        int scale = deployScale != 0 ? deployScale : defaultScale;
-        if (scale > 0) {
-          sb.append(",");
-          sb.append(scale);
-        }
-        sb.append(")");
-      }
+      renderLengthScale(deployLength, deployScale, sb);
     }
 
     return sb.toString();
   }
 
+  /**
+   * Render the length and scale part of the column definition.
+   */
+  protected void renderLengthScale(int deployLength, int deployScale, StringBuilder sb) {
+    // see if there is a precision/scale to add (or not)
+    int len = deployLength != 0 ? deployLength : defaultLength;
+    if (len == Integer.MAX_VALUE) {
+      sb.append("(max)"); // TODO: this is sqlserver specific
+    } else if (len > 0) {
+      sb.append("(");
+      sb.append(len);
+      int scale = deployScale != 0 ? deployScale : defaultScale;
+      if (scale > 0) {
+        sb.append(",");
+        sb.append(scale);
+      }
+      sb.append(")");
+    }
+  }
+
   /**
    * Create a copy of the type with a new default length.
    */

src/main/java/io/ebean/config/dbplatform/DbPlatformTypeMapping.java

@@ -1,6 +1,6 @@
 package io.ebean.config.dbplatform;
 
-import io.ebean.config.ServerConfig;
+import io.ebean.config.PlatformConfig;
 
 import java.util.EnumMap;
 import java.util.Map;
@@ -10,8 +10,23 @@ import java.util.Map;
  */
 public class DbPlatformTypeMapping {
 
+  /**
+   * Boolean type used for logical model.
+   */
+  private static class BooleanLogicalType extends DbPlatformType {
+    BooleanLogicalType() {
+      super("boolean", false);
+    }
+    @Override
+    protected void renderLengthScale(int deployLength, int deployScale, StringBuilder sb) {
+      // do not have length - even if platform boolean type does like integer(1)
+    }
+  }
+
   private static DbPlatformTypeLookup lookup = new DbPlatformTypeLookup();
 
+  private static final DbPlatformType BOOLEAN_LOGICAL = new BooleanLogicalType();
+
   private static final DbPlatformType UUID_NATIVE = new DbPlatformType("uuid", false);
   @SuppressWarnings("unused")
   private static final DbPlatformType UUID_PLACEHOLDER = new DbPlatformType("uuidPlaceholder");
@@ -51,7 +66,7 @@ public class DbPlatformTypeMapping {
    */
   private void loadDefaults(boolean logicalTypes) {
 
-    put(DbType.BOOLEAN);
+    put(DbType.BOOLEAN, BOOLEAN_LOGICAL);
     put(DbType.BIT);
     put(DbType.INTEGER);
     put(DbType.BIGINT);
@@ -104,8 +119,8 @@ public class DbPlatformTypeMapping {
       put(DbType.JSONCLOB, JSON_CLOB_PLACEHOLDER);
       put(DbType.JSONBLOB, JSON_BLOB_PLACEHOLDER);
       put(DbType.JSONVARCHAR, JSON_VARCHAR_PLACEHOLDER);
-      // use reasonable default of varchar(40) - ideally set via DatabasePlatform.configure(DbTypeConfig)
-      put(DbType.UUID, get(DbType.VARCHAR).withLength(40));
+      // default to native UUID and override on platform configure()
+      put(DbType.UUID, UUID_NATIVE);
     }
   }
 
@@ -183,9 +198,9 @@ public class DbPlatformTypeMapping {
   /**
    * Map the UUID appropriately based on native DB support and ServerConfig.DbUuid.
    */
-  public void config(boolean nativeUuidType, ServerConfig.DbUuid dbUuid) {
+  public void config(boolean nativeUuidType, PlatformConfig.DbUuid dbUuid) {
     if (nativeUuidType && dbUuid.useNativeType()) {
-      put(DbType.UUID, UUID_NATIVE);
+      // native UUID already set by default
     } else if (dbUuid.useBinary()) {
       put(DbType.UUID, get(DbType.BINARY).withLength(16));
     } else {

src/main/java/io/ebean/config/dbplatform/SequenceBatchIdGenerator.java

@@ -0,0 +1,57 @@
+package io.ebean.config.dbplatform;
+
+import io.ebean.BackgroundExecutor;
+
+import javax.sql.DataSource;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Database sequence based IdGenerator using Sequence Step 1 but batch fetch many sequence values.
+ */
+public abstract class SequenceBatchIdGenerator extends SequenceIdGenerator {
+
+  /**
+   * Construct where batchSize is the sequence step size.
+   *
+   */
+  public SequenceBatchIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
+    super(be, ds, seqName, batchSize);
+  }
+
+  /**
+   * If allocateSize is large load some sequences in a background thread.
+   * <p>
+   * For example, when inserting a bean with a cascade on a OneToMany with many
+   * beans Ebean can call this to ensure .
+   * </p>
+   */
+  @Override
+  public void preAllocateIds(int requestSize) {
+    if (allocationSize > 1 && requestSize > allocationSize) {
+      // only bother if allocateSize is bigger than
+      // the normal loading batchSize
+      if (requestSize > 100) {
+        // max out at 100 for now
+        requestSize = 100;
+      }
+      loadInBackground(requestSize);
+    }
+  }
+
+  /**
+   * Add the next set of Ids as the next value plus all the following numbers up to the step size.
+   */
+  @Override
+  protected List<Long> readIds(ResultSet resultSet, int loadSize) throws SQLException {
+
+    List<Long> newIds = new ArrayList<>(loadSize);
+    while (resultSet.next()) {
+      newIds.add(resultSet.getLong(1));
+    }
+    return newIds;
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/SequenceIdGenerator.java

@@ -2,6 +2,7 @@ package io.ebean.config.dbplatform;
 
 import io.ebean.BackgroundExecutor;
 import io.ebean.Transaction;
+import io.ebean.util.JdbcClose;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -12,13 +13,15 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Database sequence based IdGenerator.
  */
 public abstract class SequenceIdGenerator implements PlatformIdGenerator {
 
-  private static final Logger logger = LoggerFactory.getLogger(SequenceIdGenerator.class);
+  protected static final Logger logger = LoggerFactory.getLogger("io.ebean.SEQ");
 
   /**
    * Used to synchronise the idList access.
@@ -41,18 +44,18 @@ public abstract class SequenceIdGenerator implements PlatformIdGenerator {
 
   protected final ArrayList<Long> idList = new ArrayList<>(50);
 
-  protected final int batchSize;
+  protected final int allocationSize;
 
-  protected int currentlyBackgroundLoading;
+  protected boolean currentlyBackgroundLoading;
 
   /**
    * Construct given a dataSource and sql to return the next sequence value.
    */
-  public SequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
+  protected SequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int allocationSize) {
     this.backgroundExecutor = be;
     this.dataSource = ds;
     this.seqName = seqName;
-    this.batchSize = batchSize;
+    this.allocationSize = allocationSize;
   }
 
   public abstract String getSql(int batchSize);
@@ -81,26 +84,8 @@ public abstract class SequenceIdGenerator implements PlatformIdGenerator {
    * </p>
    */
   @Override
-  public void preAllocateIds(int allocateSize) {
-    if (batchSize > 1 && allocateSize > batchSize) {
-      // only bother if allocateSize is bigger than
-      // the normal loading batchSize
-      if (allocateSize > 100) {
-        // max out at 100 for now
-        allocateSize = 100;
-      }
-      loadLargeAllocation(allocateSize);
-    }
-  }
-
-  /**
-   * Called by preAllocateIds when we know that a large number of Id's is going
-   * to be needed shortly.
-   */
-  protected void loadLargeAllocation(final int allocateSize) {
-    // preAllocateIds was called with a relatively large batchSize
-    // so we will just go ahead and load those anyway in background
-    backgroundExecutor.execute(() -> loadMoreIds(allocateSize, null));
+  public void preAllocateIds(int requestSize) {
+    // do nothing by default
   }
 
   /**
@@ -113,80 +98,80 @@ public abstract class SequenceIdGenerator implements PlatformIdGenerator {
   public Object nextId(Transaction t) {
     synchronized (monitor) {
 
-      if (idList.isEmpty()) {
-        loadMoreIds(batchSize, t);
-      }
-      Long nextId = idList.remove(0);
-
-      if (batchSize > 1) {
-        if (idList.size() <= batchSize / 2) {
-          loadBatchInBackground();
-        }
+      int size = idList.size();
+      if (size > 0) {
+        maybeLoadMoreInBackground(size);
+      } else {
+        loadMore(allocationSize);
       }
 
-      return nextId;
+      return idList.remove(0);
     }
   }
 
-  /**
-   * Load another batch of Id's using a background thread.
-   */
-  protected void loadBatchInBackground() {
-
-    // single threaded processing...
-    synchronized (backgroundLoadMonitor) {
-
-      if (currentlyBackgroundLoading > 0) {
-        // skip as already background loading
-        logger.debug("... skip background sequence load (another load in progress)");
-        return;
+  private void maybeLoadMoreInBackground(int currentSize) {
+    if (allocationSize > 1) {
+      if (currentSize <= allocationSize / 2) {
+        loadInBackground(allocationSize);
       }
-
-      currentlyBackgroundLoading = batchSize;
-
-      backgroundExecutor.execute(() -> {
-        loadMoreIds(batchSize, null);
-        synchronized (backgroundLoadMonitor) {
-          currentlyBackgroundLoading = 0;
-        }
-      });
     }
   }
 
-  protected void loadMoreIds(final int numberToLoad, Transaction t) {
-
-    ArrayList<Long> newIds = getMoreIds(numberToLoad, t);
-
-    if (logger.isDebugEnabled()) {
-      logger.debug("... seq:" + seqName + " loaded:" + numberToLoad + " ids:" + newIds);
-    }
-
+  private void loadMore(int requestSize) {
+    List<Long> newIds = getMoreIds(requestSize);
     synchronized (monitor) {
       idList.addAll(newIds);
     }
   }
 
+  /**
+   * Load another batch of Id's using a background thread.
+   */
+  protected void loadInBackground(final int requestSize) {
+
+    // single threaded processing...
+    synchronized (backgroundLoadMonitor) {
+      if (currentlyBackgroundLoading) {
+        // skip as already background loading
+        logger.debug("... skip background sequence load (another load in progress)");
+        return;
+      }
+
+      currentlyBackgroundLoading = true;
+
+      backgroundExecutor.execute(() -> {
+        loadMore(requestSize);
+        synchronized (backgroundLoadMonitor) {
+          currentlyBackgroundLoading = false;
+        }
+      });
+    }
+  }
+
+  /**
+   * Read the resultSet returning the list of Id values.
+   */
+  protected abstract List<Long> readIds(ResultSet resultSet, int loadSize) throws SQLException;
+
   /**
    * Get more Id's by executing a query and reading the Id's returned.
    */
-  protected ArrayList<Long> getMoreIds(int loadSize, Transaction t) {
+  protected List<Long> getMoreIds(int requestSize) {
 
-    String sql = getSql(loadSize);
+    String sql = getSql(requestSize);
 
-    ArrayList<Long> newIds = new ArrayList<>(loadSize);
-
-    boolean useTxnConnection = t != null;
-
-    Connection c = null;
-    PreparedStatement pstmt = null;
-    ResultSet rset = null;
+    Connection connection = null;
+    PreparedStatement statement = null;
+    ResultSet resultSet = null;
     try {
-      c = useTxnConnection ? t.getConnection() : dataSource.getConnection();
+      connection = dataSource.getConnection();
 
-      pstmt = c.prepareStatement(sql);
-      rset = pstmt.executeQuery();
-      while (rset.next()) {
-        newIds.add(rset.getLong(1));
+      statement = connection.prepareStatement(sql);
+      resultSet = statement.executeQuery();
+
+      List<Long> newIds = readIds(resultSet, requestSize);
+      if (logger.isTraceEnabled()) {
+        logger.trace("seq:{} loaded:{} sql:{}", seqName, newIds.size(), sql);
       }
       if (newIds.isEmpty()) {
         throw new PersistenceException("Always expecting more than 1 row from " + sql);
@@ -197,46 +182,24 @@ public abstract class SequenceIdGenerator implements PlatformIdGenerator {
     } catch (SQLException e) {
       if (e.getMessage().contains("Database is already closed")) {
         String msg = "Error getting SEQ when DB shutting down " + e.getMessage();
-        logger.info(msg);
+        logger.error(msg);
         System.out.println(msg);
-        return newIds;
+        return Collections.emptyList();
       } else {
         throw new PersistenceException("Error getting sequence nextval", e);
       }
     } finally {
-      if (useTxnConnection) {
-        closeResources(null, pstmt, rset);
-      } else {
-        closeResources(c, pstmt, rset);
-      }
+      closeResources(connection, statement, resultSet);
     }
   }
 
   /**
    * Close the JDBC resources.
    */
-  protected void closeResources(Connection c, PreparedStatement pstmt, ResultSet rset) {
-    try {
-      if (rset != null) {
-        rset.close();
-      }
-    } catch (SQLException e) {
-      logger.error("Error closing ResultSet", e);
-    }
-    try {
-      if (pstmt != null) {
-        pstmt.close();
-      }
-    } catch (SQLException e) {
-      logger.error("Error closing PreparedStatement", e);
-    }
-    try {
-      if (c != null) {
-        c.close();
-      }
-    } catch (SQLException e) {
-      logger.error("Error closing Connection", e);
-    }
+  private void closeResources(Connection connection, PreparedStatement statement, ResultSet resultSet) {
+    JdbcClose.close(resultSet);
+    JdbcClose.close(statement);
+    JdbcClose.close(connection);
   }
 
 }

src/main/java/io/ebean/config/dbplatform/SequenceStepIdGenerator.java

@@ -0,0 +1,39 @@
+package io.ebean.config.dbplatform;
+
+import io.ebean.BackgroundExecutor;
+
+import javax.sql.DataSource;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Database sequence based IdGenerator using Sequence Step (e.g. step 50).
+ */
+public abstract class SequenceStepIdGenerator extends SequenceIdGenerator {
+
+  /**
+   * Construct with stepSize (typically 50).
+   */
+  protected SequenceStepIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int stepSize) {
+    super(be, ds, seqName, stepSize);
+  }
+
+  /**
+   * Add the next set of Ids as the next value plus all the following numbers up to the step size.
+   */
+  @Override
+  protected List<Long> readIds(ResultSet resultSet, int ignoreRequestSize) throws SQLException {
+
+    List<Long> newIds = new ArrayList<>(allocationSize);
+    if (resultSet.next()) {
+      long start = resultSet.getLong(1);
+      for (int i = 0; i < allocationSize; i++) {
+        newIds.add(start + i);
+      }
+    }
+    return newIds;
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/SimpleSequenceIdGenerator.java

@@ -1,6 +1,7 @@
 package io.ebean.config.dbplatform;
 
 import io.ebean.Transaction;
+import io.ebean.util.JdbcClose;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -82,27 +83,9 @@ public class SimpleSequenceIdGenerator implements PlatformIdGenerator {
   }
 
   private void closeResources(ResultSet rset, PreparedStatement pstmt, Connection c) {
-    try {
-      if (rset != null) {
-        rset.close();
-      }
-    } catch (SQLException e) {
-      logger.error("Error closing ResultSet", e);
-    }
-    try {
-      if (pstmt != null) {
-        pstmt.close();
-      }
-    } catch (SQLException e) {
-      logger.error("Error closing PreparedStatement", e);
-    }
-    try {
-      if (c != null) {
-        c.close();
-      }
-    } catch (SQLException e) {
-      logger.error("Error closing Connection", e);
-    }
+    JdbcClose.close(rset);
+    JdbcClose.close(pstmt);
+    JdbcClose.close(c);
   }
 
 }

src/main/java/io/ebean/config/dbplatform/cockroach/CockroachPlatform.java

@@ -0,0 +1,28 @@
+package io.ebean.config.dbplatform.cockroach;
+
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.postgres.PostgresPlatform;
+
+/**
+ * CockroachDB based platform.
+ */
+public class CockroachPlatform extends PostgresPlatform {
+
+  public CockroachPlatform() {
+    super();
+    this.platform = Platform.COCKROACH;
+    // no like escape clause supported
+    this.likeSpecialCharacters = new char[]{'%', '_'};
+    this.likeClauseRaw = "like ?";
+    this.likeClauseEscaped = "like ?";
+  }
+
+  /**
+   * Needs a commit after create index such that alter table add foreign key ... succeeds.
+   */
+  @Override
+  public boolean isDdlCommitOnCreateIndex() {
+    return true;
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/db2/DB2Platform.java

@@ -26,10 +26,7 @@ public class DB2Platform extends DatabasePlatform {
 
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsSequence(true);
-    
-    this.likeClause = "like ? escape '|'";
-    this.specialLikeCharacters = new char[] { '%', '_', '|' };
-    
+
     this.exceptionTranslator =
       new SqlErrorCodes()
         .addAcquireLock("40001","57033") // key -911/-913
@@ -49,19 +46,14 @@ public class DB2Platform extends DatabasePlatform {
     persistBatchOnCascade = PersistBatch.NONE;
   }
 
-  @Override
-  protected void escapeLikeCharacter(char ch, StringBuilder sb) {
-    sb.append('|').append(ch);
-  }
   /**
    * Return a DB2 specific sequence IdGenerator that supports batch fetching
    * sequence values.
    */
   @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be,
-                                                       DataSource ds, String seqName, int batchSize) {
+  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, int stepSize, String seqName) {
 
-    return new DB2SequenceIdGenerator(be, ds, seqName, batchSize);
+    return new DB2SequenceIdGenerator(be, ds, seqName, sequenceBatchSize);
   }
 
 }

src/main/java/io/ebean/config/dbplatform/db2/DB2SequenceIdGenerator.java

@@ -1,14 +1,14 @@
 package io.ebean.config.dbplatform.db2;
 
 import io.ebean.BackgroundExecutor;
-import io.ebean.config.dbplatform.SequenceIdGenerator;
+import io.ebean.config.dbplatform.SequenceBatchIdGenerator;
 
 import javax.sql.DataSource;
 
 /**
  * DB2 specific sequence Id Generator.
  */
-public class DB2SequenceIdGenerator extends SequenceIdGenerator {
+public class DB2SequenceIdGenerator extends SequenceBatchIdGenerator {
 
   private final String baseSql;
   private final String unionBaseSql;

src/main/java/io/ebean/config/dbplatform/h2/H2Platform.java

@@ -46,10 +46,8 @@ public class H2Platform extends DatabasePlatform {
    * sequence values.
    */
   @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds,
-                                                       String seqName, int batchSize) {
-
-    return new H2SequenceIdGenerator(be, ds, seqName, batchSize);
+  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, int stepSize, String seqName) {
+    return new H2SequenceIdGenerator(be, ds, seqName, sequenceBatchSize);
   }
 
   @Override

src/main/java/io/ebean/config/dbplatform/h2/H2SequenceIdGenerator.java

@@ -1,14 +1,14 @@
 package io.ebean.config.dbplatform.h2;
 
 import io.ebean.BackgroundExecutor;
-import io.ebean.config.dbplatform.SequenceIdGenerator;
+import io.ebean.config.dbplatform.SequenceBatchIdGenerator;
 
 import javax.sql.DataSource;
 
 /**
  * H2 specific sequence Id Generator.
  */
-public class H2SequenceIdGenerator extends SequenceIdGenerator {
+public class H2SequenceIdGenerator extends SequenceBatchIdGenerator {
 
   private final String baseSql;
   private final String unionBaseSql;

src/main/java/io/ebean/config/dbplatform/hsqldb/HsqldbPlatform.java

@@ -31,9 +31,8 @@ public class HsqldbPlatform extends DatabasePlatform {
   }
 
   @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
-
-    return new H2SequenceIdGenerator(be, ds, seqName, batchSize);
+  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, int stepSize, String seqName) {
+    return new H2SequenceIdGenerator(be, ds, seqName, sequenceBatchSize);
   }
 
 }

src/main/java/io/ebean/config/dbplatform/mysql/MySqlPlatform.java

@@ -1,16 +1,13 @@
 package io.ebean.config.dbplatform.mysql;
 
-import io.ebean.BackgroundExecutor;
 import io.ebean.Query;
 import io.ebean.annotation.Platform;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.DbPlatformType;
 import io.ebean.config.dbplatform.DbType;
 import io.ebean.config.dbplatform.IdType;
-import io.ebean.config.dbplatform.PlatformIdGenerator;
 import io.ebean.config.dbplatform.SqlErrorCodes;
 
-import javax.sql.DataSource;
 import java.sql.Types;
 
 /**
@@ -38,6 +35,11 @@ public class MySqlPlatform extends DatabasePlatform {
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsIdentity(true);
     this.dbIdentity.setSupportsSequence(false);
+    
+    this.dbDefaultValue.setNow("now(6)"); // must have same precision as TIMESTAMP
+    this.dbDefaultValue.setFalse("0");
+    this.dbDefaultValue.setTrue("1");
+
 
     this.exceptionTranslator =
       new SqlErrorCodes()
@@ -49,14 +51,14 @@ public class MySqlPlatform extends DatabasePlatform {
     this.openQuote = "`";
     this.closeQuote = "`";
     // use pipe for escaping as it depends if mysql runs in no_backslash_escapes or not.
-    this.likeClause = "like binary ? escape '|'";
-    this.specialLikeCharacters = new char[] { '%', '_', '|' };
+    this.likeClauseRaw = "like binary ? escape ''";
+    this.likeClauseEscaped = "like binary ? escape '|'";
 
     this.forwardOnlyHintOnFindIterate = true;
     this.booleanDbType = Types.BIT;
 
-    dbTypeMap.put(DbType.BIT, new DbPlatformType("tinyint(1) default 0"));
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("tinyint(1) default 0"));
+    dbTypeMap.put(DbType.BIT, new DbPlatformType("tinyint(1)"));
+    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("tinyint(1)"));
     dbTypeMap.put(DbType.TIMESTAMP, new DbPlatformType("datetime(6)"));
     dbTypeMap.put(DbType.CLOB, new MySqlClob());
     dbTypeMap.put(DbType.BLOB, new MySqlBlob());
@@ -64,24 +66,10 @@ public class MySqlPlatform extends DatabasePlatform {
     dbTypeMap.put(DbType.VARBINARY, new DbPlatformType("varbinary", 255));
   }
 
-  /**
-   * Return null in case there is a sequence annotation.
-   */
-  @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be,
-                                                       DataSource ds, String seqName, int batchSize) {
-
-    return null;
-  }
-
   @Override
   protected String withForUpdate(String sql, Query.ForUpdate forUpdateMode) {
     // NOWAIT and SKIP LOCKED currently not supported with MySQL
     return sql + " for update";
   }
 
-  @Override
-  protected void escapeLikeCharacter(char ch, StringBuilder sb) {
-    sb.append('|').append(ch);
-  }
 }

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

@@ -35,10 +35,12 @@ public class OraclePlatform extends DatabasePlatform {
     dbIdentity.setSupportsIdentity(true);
     dbIdentity.setSupportsGetGeneratedKeys(true);
 
-    this.treatEmptyStringsAsNull = true;
+    this.dbDefaultValue.setFalse("0");
+    this.dbDefaultValue.setTrue("1");
+    this.dbDefaultValue.setNow("current_timestamp");
 
-    this.likeClause = "like ? escape '|'";
-    this.specialLikeCharacters = new char[] { '%', '_', '|' };
+    this.treatEmptyStringsAsNull = true;
+    this.likeClauseRaw = "like ?";
 
     this.exceptionTranslator =
       new SqlErrorCodes()
@@ -51,7 +53,7 @@ public class OraclePlatform extends DatabasePlatform {
     this.closeQuote = "\"";
 
     booleanDbType = Types.INTEGER;
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("number(1) default 0"));
+    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("number(1)"));
 
     dbTypeMap.put(DbType.INTEGER, new DbPlatformType("number", 10));
     dbTypeMap.put(DbType.BIGINT, new DbPlatformType("number", 19));
@@ -72,9 +74,8 @@ public class OraclePlatform extends DatabasePlatform {
   }
 
   @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
-
-    return new OracleSequenceIdGenerator(be, ds, seqName, batchSize);
+  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, int stepSize, String seqName) {
+    return new OracleSequenceIdGenerator(be, ds, seqName, sequenceBatchSize);
   }
 
   @Override
@@ -89,8 +90,4 @@ public class OraclePlatform extends DatabasePlatform {
     }
   }
 
-  @Override
-  protected void escapeLikeCharacter(char ch, StringBuilder sb) {
-    sb.append('|').append(ch);
-  }
 }

src/main/java/io/ebean/config/dbplatform/oracle/OracleSequenceIdGenerator.java

@@ -1,14 +1,14 @@
 package io.ebean.config.dbplatform.oracle;
 
 import io.ebean.BackgroundExecutor;
-import io.ebean.config.dbplatform.SequenceIdGenerator;
+import io.ebean.config.dbplatform.SequenceBatchIdGenerator;
 
 import javax.sql.DataSource;
 
 /**
  * Oracle specific sequence Id Generator.
  */
-public class OracleSequenceIdGenerator extends SequenceIdGenerator {
+public class OracleSequenceIdGenerator extends SequenceBatchIdGenerator {
 
   private final String baseSql;
 

src/main/java/io/ebean/config/dbplatform/postgres/PostgresPlatform.java

@@ -39,6 +39,8 @@ public class PostgresPlatform extends DatabasePlatform {
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsSequence(true);
 
+    this.dbDefaultValue.setNow("current_timestamp");
+
     this.exceptionTranslator =
       new SqlErrorCodes()
         .addAcquireLock("55P03")
@@ -86,13 +88,21 @@ public class PostgresPlatform extends DatabasePlatform {
     return new DbPlatformType("geometry(" + type + "," + srid + ")");
   }
 
+  /**
+   * So we can generate varchar[], int[], uuid[] column definitions and use the associated scalar types.
+   */
+  @Override
+  public boolean isNativeArrayType() {
+    return true;
+  }
+
   /**
    * Create a Postgres specific sequence IdGenerator.
    */
   @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
+  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, int stepSize, String seqName) {
 
-    return new PostgresSequenceIdGenerator(be, ds, seqName, batchSize);
+    return new PostgresSequenceIdGenerator(be, ds, seqName, sequenceBatchSize);
   }
 
   @Override

src/main/java/io/ebean/config/dbplatform/postgres/PostgresSequenceIdGenerator.java

@@ -1,14 +1,14 @@
 package io.ebean.config.dbplatform.postgres;
 
 import io.ebean.BackgroundExecutor;
-import io.ebean.config.dbplatform.SequenceIdGenerator;
+import io.ebean.config.dbplatform.SequenceBatchIdGenerator;
 
 import javax.sql.DataSource;
 
 /**
  * Postgres specific sequence Id Generator.
  */
-public class PostgresSequenceIdGenerator extends SequenceIdGenerator {
+public class PostgresSequenceIdGenerator extends SequenceBatchIdGenerator {
 
   private final String baseSql;
 

src/main/java/io/ebean/config/dbplatform/sqlanywhere/SqlAnywherePlatform.java

@@ -27,7 +27,7 @@ public class SqlAnywherePlatform extends DatabasePlatform {
     this.dbIdentity.setSelectLastInsertedIdTemplate("select @@IDENTITY as X");
     this.dbIdentity.setSupportsIdentity(true);
 
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("bit default 0"));
+    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("bit"));
     dbTypeMap.put(DbType.BIGINT, new DbPlatformType("numeric", 19));
     dbTypeMap.put(DbType.REAL, new DbPlatformType("float(16)"));
     dbTypeMap.put(DbType.DOUBLE, new DbPlatformType("float(32)"));

src/main/java/io/ebean/config/dbplatform/sqlite/SQLitePlatform.java

@@ -19,12 +19,21 @@ public class SQLitePlatform extends DatabasePlatform {
     this.dbIdentity.setSelectLastInsertedIdTemplate("select last_insert_rowid()");
 
     this.booleanDbType = Types.INTEGER;
+    this.likeClauseRaw = "like ?";
+    this.likeClauseEscaped = "like ?";
+    this.dbDefaultValue.setFalse("0");
+    this.dbDefaultValue.setTrue("1");
+    this.dbDefaultValue.setNow("CURRENT_TIMESTAMP");
 
-    dbTypeMap.put(DbType.BIT, new DbPlatformType("int default 0"));
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("int default 0"));
+    dbTypeMap.put(DbType.BIT, new DbPlatformType("int"));
+    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("int"));
     dbTypeMap.put(DbType.BIGINT, new DbPlatformType("integer"));
     dbTypeMap.put(DbType.SMALLINT, new DbPlatformType("integer"));
+  }
 
+  @Override
+  protected void escapeLikeCharacter(char ch, StringBuilder sb) {
+    sb.append(ch);
   }
 
 }

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServer16Platform.java

@@ -0,0 +1,26 @@
+package io.ebean.config.dbplatform.sqlserver;
+
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.DbPlatformType;
+import io.ebean.config.dbplatform.DbType;
+import io.ebean.config.dbplatform.IdType;
+
+/**
+ * Microsoft SQL Server platform that has non-UTF8 types (char, varchar, text) and default to Identity rather than Sequence.
+ */
+public class SqlServer16Platform extends SqlServerBasePlatform {
+
+  public SqlServer16Platform() {
+    super();
+    this.platform = Platform.SQLSERVER16;
+    // default to use Identity rather than sequences
+    this.dbIdentity.setIdType(IdType.IDENTITY);
+
+    // non-utf8 column types
+    dbTypeMap.put(DbType.CHAR, new DbPlatformType("char", 1));
+    dbTypeMap.put(DbType.VARCHAR, new DbPlatformType("varchar", 255));
+    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("text"));
+    dbTypeMap.put(DbType.CLOB, new DbPlatformType("text"));
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServer17Platform.java

@@ -0,0 +1,20 @@
+package io.ebean.config.dbplatform.sqlserver;
+
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.DbPlatformType;
+import io.ebean.config.dbplatform.DbType;
+
+/**
+ * Microsoft SQL Server platform - NVarchar UTF types and Sequence preference.
+ */
+public class SqlServer17Platform extends SqlServerBasePlatform {
+
+  public SqlServer17Platform() {
+    super();
+    this.platform = Platform.SQLSERVER17;
+    this.columnAliasPrefix = null;
+    this.nativeUuidType = true;
+    this.dbTypeMap.put(DbType.UUID, new DbPlatformType("uniqueidentifier", false));
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServer2005Platform.java

@@ -3,7 +3,7 @@ package io.ebean.config.dbplatform.sqlserver;
 /**
  * SQL Server platform using the older ROW_NUMBER() mechanism.
  */
-public class SqlServer2005Platform extends SqlServerPlatform {
+public class SqlServer2005Platform extends SqlServer16Platform {
 
   public SqlServer2005Platform() {
     this.sqlLimiter = new SqlServer2005SqlLimiter();

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServerBasePlatform.java

@@ -0,0 +1,125 @@
+package io.ebean.config.dbplatform.sqlserver;
+
+import io.ebean.BackgroundExecutor;
+import io.ebean.Query;
+import io.ebean.annotation.PersistBatch;
+import io.ebean.annotation.Platform;
+import io.ebean.config.PlatformConfig;
+import io.ebean.config.dbplatform.DatabasePlatform;
+import io.ebean.config.dbplatform.DbPlatformType;
+import io.ebean.config.dbplatform.DbType;
+import io.ebean.config.dbplatform.IdType;
+import io.ebean.config.dbplatform.PlatformIdGenerator;
+import io.ebean.config.dbplatform.SqlErrorCodes;
+
+import javax.sql.DataSource;
+import java.sql.Types;
+
+/**
+ * Base Microsoft SQL Server platform - NVarchar UTF types and Sequence preference by default.
+ */
+abstract class SqlServerBasePlatform extends DatabasePlatform {
+
+  SqlServerBasePlatform() {
+    super();
+    this.platform = Platform.SQLSERVER;
+    // disable persistBatchOnCascade mode for
+    // SQL Server unless we are using sequences
+    this.persistBatchOnCascade = PersistBatch.NONE;
+    this.idInExpandedForm = true;
+    this.selectCountWithAlias = true;
+    this.sqlLimiter = new SqlServerSqlLimiter();
+    this.basicSqlLimiter = new SqlServerBasicSqlLimiter();
+    this.historySupport = new SqlServerHistorySupport();
+    this.dbIdentity.setIdType(IdType.SEQUENCE);
+    this.dbIdentity.setSupportsGetGeneratedKeys(true);
+    this.dbIdentity.setSupportsIdentity(true);
+    this.dbIdentity.setSupportsSequence(true);
+    this.sequenceBatchMode = false;
+
+    this.exceptionTranslator =
+      new SqlErrorCodes()
+        .addAcquireLock("1222")
+        .addDuplicateKey("2601", "2627")
+        .addDataIntegrity("544", "547", "8114", "8115")
+        .build();
+
+    this.openQuote = "[";
+    this.closeQuote = "]";
+    this.likeSpecialCharacters = new char[]{'%', '_', '['};
+    this.likeClauseRaw = "like ? collate Latin1_General_BIN";
+    this.likeClauseEscaped = "like ? collate Latin1_General_BIN";
+
+    booleanDbType = Types.INTEGER;
+    this.dbDefaultValue.setFalse("0");
+    this.dbDefaultValue.setTrue("1");
+    this.dbDefaultValue.setNow("SYSUTCDATETIME()");
+    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("bit"));
+
+    dbTypeMap.put(DbType.INTEGER, new DbPlatformType("integer", false));
+    dbTypeMap.put(DbType.BIGINT, new DbPlatformType("numeric", 19));
+    dbTypeMap.put(DbType.REAL, new DbPlatformType("float(16)"));
+    dbTypeMap.put(DbType.DOUBLE, new DbPlatformType("float(32)"));
+    dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint"));
+    dbTypeMap.put(DbType.DECIMAL, new DbPlatformType("numeric", 28));
+
+
+    dbTypeMap.put(DbType.DATE, new DbPlatformType("date"));
+    dbTypeMap.put(DbType.TIME, new DbPlatformType("time"));
+    dbTypeMap.put(DbType.TIMESTAMP, new DbPlatformType("datetime2"));
+
+    // UTF8 aware types - overwritten in SqlServer16 platform
+    dbTypeMap.put(DbType.CHAR, new DbPlatformType("nchar", 1));
+    dbTypeMap.put(DbType.VARCHAR, new DbPlatformType("nvarchar", 255));
+    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
+    dbTypeMap.put(DbType.CLOB, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
+
+    dbTypeMap.put(DbType.JSON, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
+    dbTypeMap.put(DbType.JSONB, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
+
+    dbTypeMap.put(DbType.BLOB, new DbPlatformType("image"));
+    dbTypeMap.put(DbType.LONGVARBINARY, new DbPlatformType("image"));
+  }
+
+  @Override
+  public void configure(PlatformConfig config) {
+    super.configure(config);
+    if (dbIdentity.getIdType() == IdType.SEQUENCE) {
+      this.persistBatchOnCascade = PersistBatch.ALL;
+    }
+  }
+
+  @Override
+  protected void escapeLikeCharacter(char ch, StringBuilder sb) {
+    sb.append('[').append(ch).append(']');
+  }
+
+  /**
+   * Create a Postgres specific sequence IdGenerator.
+   */
+  @Override
+  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, int stepSize, String seqName) {
+    return new SqlServerStepSequence(be, ds, seqName, stepSize);
+  }
+
+  /**
+   * For update is part of the FROM clause on the base table for sql server.
+   */
+  @Override
+  public String fromForUpdate(Query.ForUpdate forUpdateMode) {
+    switch (forUpdateMode) {
+      case SKIPLOCKED:
+        return "with (updlock,readpast)";
+      case NOWAIT:
+        return "with (updlock,nowait)";
+      default:
+        return "with (updlock)";
+    }
+  }
+
+  @Override
+  protected String withForUpdate(String sql, Query.ForUpdate forUpdateMode) {
+    // for update are hints on from clause of base table
+    return sql;
+  }
+}

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServerBasicSqlLimiter.java

@@ -13,7 +13,7 @@ public class SqlServerBasicSqlLimiter implements BasicSqlLimiter {
     StringBuilder sb = new StringBuilder(50 + dbSql.length());
     sb.append(dbSql);
     if (!dbSql.toLowerCase().contains("order by")) {
-      sb.append(" order by 1 ");
+      sb.append(" order by 1");
     }
     sb.append(" ").append("offset");
     sb.append(" ").append(firstRow).append(" rows");

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServerPlatform.java

@@ -1,73 +0,0 @@
-package io.ebean.config.dbplatform.sqlserver;
-
-import io.ebean.annotation.PersistBatch;
-import io.ebean.annotation.Platform;
-import io.ebean.config.dbplatform.DatabasePlatform;
-import io.ebean.config.dbplatform.DbPlatformType;
-import io.ebean.config.dbplatform.DbType;
-import io.ebean.config.dbplatform.IdType;
-import io.ebean.config.dbplatform.SqlErrorCodes;
-
-import java.sql.Types;
-
-/**
- * Microsoft SQL Server platform.
- */
-public class SqlServerPlatform extends DatabasePlatform {
-
-  public SqlServerPlatform() {
-    super();
-    this.platform = Platform.SQLSERVER;
-    // effectively disable persistBatchOnCascade mode for SQL Server
-    // due to lack of support for getGeneratedKeys in batch mode
-    this.persistBatchOnCascade = PersistBatch.NONE;
-    this.idInExpandedForm = true;
-    this.selectCountWithAlias = true;
-    this.sqlLimiter = new SqlServerSqlLimiter();
-    this.basicSqlLimiter = new SqlServerBasicSqlLimiter();
-    this.historySupport = new SqlServerHistorySupport();
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(true);
-    this.dbIdentity.setSupportsIdentity(true);
-
-    this.exceptionTranslator =
-      new SqlErrorCodes()
-        .addAcquireLock("1222")
-        .addDuplicateKey("2601", "2627")
-        .addDataIntegrity("544", "8114", "8115")
-        .build();
-
-    this.openQuote = "[";
-    this.closeQuote = "]";
-    this.specialLikeCharacters = new char[]{'%', '_', '['};
-    this.likeClause = "like ? COLLATE Latin1_General_BIN";
-
-    booleanDbType = Types.INTEGER;
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("bit default 0"));
-
-    dbTypeMap.put(DbType.INTEGER, new DbPlatformType("integer", false));
-    dbTypeMap.put(DbType.BIGINT, new DbPlatformType("numeric", 19));
-    dbTypeMap.put(DbType.REAL, new DbPlatformType("float(16)"));
-    dbTypeMap.put(DbType.DOUBLE, new DbPlatformType("float(32)"));
-    dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint"));
-    dbTypeMap.put(DbType.DECIMAL, new DbPlatformType("numeric", 28));
-
-    dbTypeMap.put(DbType.BLOB, new DbPlatformType("image"));
-    dbTypeMap.put(DbType.CLOB, new DbPlatformType("text"));
-    dbTypeMap.put(DbType.LONGVARBINARY, new DbPlatformType("image"));
-    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("text"));
-
-    dbTypeMap.put(DbType.DATE, new DbPlatformType("date"));
-    dbTypeMap.put(DbType.TIME, new DbPlatformType("time"));
-    dbTypeMap.put(DbType.TIMESTAMP, new DbPlatformType("datetime2"));
-
-    dbTypeMap.put(DbType.JSON, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
-    dbTypeMap.put(DbType.JSONB, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
-
-  }
-
-  @Override
-  protected void escapeLikeCharacter(char ch, StringBuilder sb) {
-    sb.append('[').append(ch).append(']');
-  }
-}

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServerStepSequence.java

@@ -0,0 +1,24 @@
+package io.ebean.config.dbplatform.sqlserver;
+
+import io.ebean.BackgroundExecutor;
+import io.ebean.config.dbplatform.SequenceStepIdGenerator;
+
+import javax.sql.DataSource;
+
+public class SqlServerStepSequence extends SequenceStepIdGenerator {
+
+  private final String nextSql;
+
+  /**
+   * Construct where batchSize is the sequence step size.
+   */
+  public SqlServerStepSequence(BackgroundExecutor be, DataSource ds, String seqName, int stepSize) {
+    super(be, ds, seqName, stepSize);
+    this.nextSql = "select next value for "+seqName;
+  }
+
+  @Override
+  public String getSql(int batchSize) {
+    return nextSql;
+  }
+}

src/main/java/io/ebean/config/properties/LoadContext.java

@@ -0,0 +1,97 @@
+package io.ebean.config.properties;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+/**
+ * Manages the underlying map of properties we are gathering.
+ */
+class LoadContext {
+
+	private static final Logger log = LoggerFactory.getLogger(LoadContext.class);
+
+  /**
+   * Map we are loading the properties into.
+   */
+	private final Map<String, String> map = new LinkedHashMap<>();
+
+  /**
+   * Names of resources/files that were loaded.
+   */
+	private final Set<String> loadedResources = new LinkedHashSet<>();
+
+  /**
+   * Return the input stream (maybe null) for the given source.
+   */
+	InputStream resource(String resourcePath, Loader.Source source) {
+
+    InputStream is = null;
+    if (source == Loader.Source.RESOURCE) {
+      is = getClass().getResourceAsStream("/" + resourcePath);
+      if (is != null) {
+        loadedResources.add(resourcePath);
+      }
+    } else {
+      File file = new File(resourcePath);
+      if (file.exists()) {
+        try {
+          is = new FileInputStream(file);
+          loadedResources.add("file:"+resourcePath);
+        } catch (FileNotFoundException e) {
+          throw new IllegalStateException(e);
+        }
+      }
+    }
+
+		return is;
+	}
+
+  /**
+   * Add a property entry.
+   */
+	void put(String key, String val) {
+	  if (val != null) {
+	    val = val.trim();
+    }
+		map.put(key, val);
+	}
+
+  /**
+   * Evaluate all the expressions and return as a Properties object.
+   */
+	Properties eval() {
+
+		log.info("loaded properties from {}", loadedResources);
+
+		Properties properties = new Properties();
+
+		for (Map.Entry<String, String> entry : map.entrySet()) {
+			String key = entry.getKey();
+			String value = PropertyEval.eval(entry.getValue());
+			properties.setProperty(key, value);
+		}
+
+		return properties;
+	}
+
+  /**
+   * Read the special properties that can point to an external properties source.
+   */
+  String indirectLocation() {
+    String indirectLocation = map.get("load.properties");
+    if (indirectLocation == null) {
+      indirectLocation = map.get("load.properties.override");
+    }
+    return indirectLocation;
+  }
+}

src/main/java/io/ebean/config/properties/Loader.java

@@ -0,0 +1,170 @@
+package io.ebean.config.properties;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.Properties;
+
+/**
+ * Loads the configuration from known/expected locations.
+ * <p>
+ * Defines the loading order of resources and files.
+ * </p>
+ */
+class Loader {
+
+	private static final Logger log = LoggerFactory.getLogger(Loader.class);
+
+	enum Source {
+	  RESOURCE,
+    FILE
+  }
+
+  private final LoadContext loadContext = new LoadContext();
+
+  private YamlLoader yamlLoader;
+
+	Loader() {
+    String skipYaml = System.getProperty("ebeanSkipYaml");
+    if (!"true".equals(skipYaml)) {
+      try {
+        Class<?> exists = Class.forName("org.yaml.snakeyaml.Yaml");
+        if (exists != null) {
+          yamlLoader = new YamlLoader(loadContext);
+        }
+      } catch (Exception e) {
+        // ignored
+      }
+    }
+  }
+
+  /**
+   * Load the configuration with the expected ordering.
+   */
+	void load() {
+
+    loadMain(Source.RESOURCE);
+    // external file configuration overrides the resources configuration
+    loadMain(Source.FILE);
+
+		loadViaSystemProperty();
+		loadViaIndirection();
+
+		// test configuration (if found) overrides main configuration
+    // we should only find these resources when running tests
+		loadTest();
+	}
+
+  /**
+   * Load test configuration.
+   */
+  private void loadTest() {
+    loadProperties("application-test.properties", Source.RESOURCE);
+    loadYaml("application-test.yml", Source.RESOURCE);
+    loadProperties("test-ebean.properties", Source.RESOURCE);
+  }
+
+  /**
+   * Load configuration defined by a <em>load.properties</em> entry in properties file.
+   */
+  private void loadViaIndirection() {
+
+    String location = loadContext.indirectLocation();
+    if (location != null) {
+      location = PropertyEval.eval(location);
+      loadWithExtensionCheck(location);
+    }
+  }
+
+  /**
+   * Load the main configuration for the given source.
+   */
+  private void loadMain(Source source) {
+    loadYaml("application.yml", source);
+    loadProperties("application.properties", source);
+    loadProperties("ebean.properties", source);
+  }
+
+  private void loadViaSystemProperty() {
+	  String fileName = System.getenv("EBEAN_PROPS_FILE");
+    if (fileName == null) {
+      fileName = System.getProperty("ebean.props.file");
+      if (fileName != null) {
+        loadWithExtensionCheck(fileName);
+      }
+    }
+  }
+
+  void loadWithExtensionCheck(String fileName) {
+    if (fileName.endsWith("yml")) {
+      loadYaml(fileName, Source.FILE);
+    } else if (fileName.endsWith("properties")) {
+      loadProperties(fileName, Source.FILE);
+    } else {
+      throw new IllegalArgumentException("Expecting only yml or properties file but got [" + fileName + "]");
+    }
+  }
+
+  /**
+   * Evaluate all the configuration entries and return as properties.
+   */
+  Properties eval() {
+		return loadContext.eval();
+	}
+
+	void loadYaml(String resourcePath, Source source) {
+		if (yamlLoader != null) {
+		  try {
+			  yamlLoader.load(resource(resourcePath, source));
+      } catch (Exception e) {
+        log.warn("Failed to read yml from:" + resourcePath, e);
+      }
+		}
+	}
+
+	void loadProperties(String resourcePath, Source source) {
+		InputStream is = resource(resourcePath, source);
+		if (is != null) {
+			loadProperties(is);
+		}
+	}
+
+	private InputStream resource(String resourcePath, Source source) {
+		return loadContext.resource(resourcePath, source);
+	}
+
+	private void loadProperties(InputStream is) {
+
+		if (is != null) {
+			try {
+				Properties properties = new Properties();
+				properties.load(is);
+				put(properties);
+			} catch (IOException e) {
+				throw new RuntimeException("Failed to load properties?", e);
+			} finally {
+				close(is);
+			}
+		}
+	}
+
+	private void put(Properties properties) {
+		Enumeration<?> enumeration = properties.propertyNames();
+		while (enumeration.hasMoreElements()) {
+			String key = (String) enumeration.nextElement();
+			String property = properties.getProperty(key);
+			loadContext.put(key, property);
+		}
+	}
+
+	private void close(InputStream is) {
+		try {
+			is.close();
+		} catch (IOException e) {
+			log.warn("Error closing input stream for properties", e);
+		}
+	}
+}

src/main/java/io/ebean/config/properties/PropertiesLoader.java

@@ -0,0 +1,74 @@
+package io.ebean.config.properties;
+
+import java.util.Enumeration;
+import java.util.Properties;
+
+/**
+ * Loads and evaluates properties and yml configuration.
+ */
+public class PropertiesLoader {
+
+  private static Properties properties;
+
+  /**
+   * Provides properties by reading known locations.
+   * <p>
+   * <h3>Main configuration</h3>
+   * <p>
+   * <p>Firstly loads from main resources</p>
+   * <pre>
+   *   - application.properties
+   *   - application.yml
+   *   - ebean.properties
+   * </pre>
+   * <p>
+   * <p>Then loads from local files</p>
+   * <pre>
+   *   - application.properties
+   *   - application.yml
+   *   - ebean.properties
+   * </pre>
+   * <p>
+   * <p>Then loads from environment variable <em>EBEAN_PROPS_FILE</em></p>
+   * <p>Then loads from system property <em>ebean.props.file</em></p>
+   * <p>Then loads from <em>load.properties</em></p>
+   * <p>
+   * <h3>Test configuration</h3>
+   * <p>
+   * Once the main configuration is read it will try to read common test configuration.
+   * This will only be successful if the test resources are available (i.e. running tests).
+   * </p>
+   * <p>Loads from test resources</p>
+   * <pre>
+   *   - application-test.properties
+   *   - application-test.yml
+   *   - test-ebean.properties
+   * </pre>
+   */
+  public static synchronized Properties load() {
+
+    if (properties == null) {
+      Loader loader = new Loader();
+      loader.load();
+      properties = loader.eval();
+    }
+
+    return properties;
+  }
+
+  /**
+   * Return a copy of the properties with 'eval' run on all the values.
+   * This resolves expressions like ${HOME} etc.
+   */
+  public static Properties eval(Properties properties) {
+    Properties evalCopy = new Properties();
+
+    Enumeration<?> names = properties.propertyNames();
+    while (names.hasMoreElements()) {
+      String name = (String)names.nextElement();
+      String value = PropertyEval.eval(properties.getProperty(name));
+      evalCopy.setProperty(name, value);
+    }
+    return evalCopy;
+  }
+}

src/main/java/io/ebean/config/properties/PropertyEval.java

@@ -0,0 +1,202 @@
+package io.ebean.config.properties;
+
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+
+/**
+ * Helper used to evaluate expressions such as ${CATALINA_HOME}.
+ * <p>
+ * The expressions can contain environment variables, system properties or JNDI
+ * properties. JNDI expressions take the form ${jndi:propertyName} where you
+ * substitute propertyName with the name of the jndi property you wish to
+ * evaluate.
+ * </p>
+ */
+final class PropertyEval {
+
+	/**
+	 * Prefix for looking up JNDI Environment variable.
+	 */
+	private static final String JAVA_COMP_ENV = "java:comp/env/";
+
+	/**
+	 * Used to detect the start of an expression.
+	 */
+	private static final String START = "${";
+
+	/**
+	 * Used to detect the end of an expression.
+	 */
+	private static final String END = "}";
+
+	/**
+	 * Specify the PropertyHolder.
+	 */
+	private PropertyEval() {
+	}
+
+	/**
+	 * Return the property value evaluating and replacing any expressions such as
+	 * ${CATALINA_HOME}.
+	 */
+	static String eval(String val) {
+		if (val == null) {
+			return null;
+		}
+		int sp = val.indexOf(START);
+		if (sp > -1) {
+			int ep = val.indexOf(END, sp + 1);
+			if (ep > -1) {
+				return eval(val, sp, ep);
+			}
+		}
+		return val;
+	}
+
+	/**
+	 * Convert the expression using JNDI, Environment variables, System Properties
+	 * or existing an property in SystemProperties itself.
+	 */
+	private static String evaluateExpression(String exp) {
+
+		if (isJndiExpression(exp)) {
+			// JNDI property lookup...
+			String val = getJndiProperty(exp);
+			if (val != null) {
+				return val;
+			}
+		}
+		String val = System.getProperty(exp);
+		if (val == null) {
+			val = System.getenv(exp);
+		}
+		return val;
+	}
+
+	private static String eval(String val, int sp, int ep) {
+
+		return new EvalBuffer(val, sp, ep).process();
+	}
+
+
+	private static boolean isJndiExpression(String exp) {
+		return exp.startsWith("JNDI:") || exp.startsWith("jndi:");
+	}
+
+	/**
+	 * Returns null if JNDI is not setup or if the property is not found.
+	 *
+	 * @param key the key of the JNDI Environment property including a JNDI: prefix.
+	 */
+	private static String getJndiProperty(String key) {
+
+		try {
+			// remove the JNDI: prefix
+			key = key.substring(5);
+			return (String) getJndiObject(key);
+		} catch (NamingException ex) {
+			return null;
+		}
+	}
+
+	/**
+	 * Similar to getProperty but throws NamingException if JNDI is not setup or
+	 * if the property is not found.
+	 */
+	private static Object getJndiObject(String key) throws NamingException {
+
+		InitialContext ctx = new InitialContext();
+		return ctx.lookup(JAVA_COMP_ENV + key);
+	}
+
+
+	private static class EvalBuffer {
+
+		private final StringBuilder buf = new StringBuilder();
+		private final String original;
+		private int position;
+		private int start;
+		private int end;
+
+		private String expression;
+		private String defaultValue;
+
+		EvalBuffer(String val, int start, int ep) {
+			this.original = val;
+			this.start = start;
+			this.end = ep;
+			this.position = 0;
+			moveToStart();
+		}
+
+		void moveToStart() {
+			if (start > position) {
+				buf.append(original.substring(position, start));
+				position = start;
+			}
+		}
+
+		void parseForDefault() {
+			int colonPos = original.lastIndexOf(':', end);
+			if (colonPos > start) {
+				expression = original.substring(start + START.length(), colonPos);
+				defaultValue = original.substring(colonPos + 1, end);
+			} else {
+				expression = original.substring(start + START.length(), end);
+			}
+		}
+
+		void evaluate() {
+			String eval = evaluateExpression(expression);
+			if (eval != null) {
+				buf.append(eval);
+			} else {
+				if (defaultValue != null) {
+					buf.append(defaultValue);
+				} else {
+					buf.append(START).append(expression).append(END);
+				}
+			}
+		}
+
+		String end() {
+			if (end < original.length() - 1) {
+				buf.append(original.substring(end + 1));
+			}
+			return buf.toString();
+		}
+
+		boolean next() {
+			if (end < original.length()) {
+				int startPos = original.indexOf(START, end + 1);
+				if (startPos > -1) {
+					int endPos = original.indexOf(END, startPos + 1);
+					if (endPos > -1) {
+						if (startPos > end + 1) {
+							buf.append(original.substring(end + 1, startPos));
+						}
+						this.start = startPos;
+						this.end = endPos;
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+
+		private void evalNext() {
+			parseForDefault();
+			evaluate();
+		}
+
+		String process() {
+			evalNext();
+			while (next()) {
+				evalNext();
+			}
+			return end();
+		}
+
+	}
+
+}

src/main/java/io/ebean/config/properties/YamlLoader.java

@@ -0,0 +1,58 @@
+package io.ebean.config.properties;
+
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.InputStream;
+import java.util.Map;
+
+/**
+ * Loads configuration from Yml into the load context.
+ * <p>
+ * Note that this ignores 'lists' so just reads 'maps' and scalar values.
+ * </p>
+ */
+class YamlLoader {
+
+  private final Yaml yaml = new Yaml();
+
+  private final LoadContext loadContext;
+
+  YamlLoader(LoadContext loadContext) {
+    this.loadContext = loadContext;
+  }
+
+  @SuppressWarnings("unchecked")
+  void load(InputStream is) {
+    if (is != null) {
+      for (Object map : yaml.loadAll(is)) {
+        loadMap((Map<String, Object>)map, null);
+      }
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  void loadMap(Map<String, Object> map, String path) {
+
+    for (Map.Entry<String, Object> entry : map.entrySet()) {
+      String key = entry.getKey();
+      if (path != null) {
+        key = path + "." + key;
+      }
+      Object val = entry.getValue();
+      if (val instanceof Map) {
+        loadMap((Map<String, Object>) val, key);
+      } else  {
+        addScalar(key, val);
+      }
+    }
+  }
+
+  private void addScalar(String key, Object val) {
+    if (val instanceof String) {
+      loadContext.put(key, (String) val);
+    } else if (val instanceof Number || val instanceof Boolean) {
+      loadContext.put(key, val.toString());
+    }
+  }
+
+}

src/main/java/io/ebean/dbmigration/DbMigration.java

@@ -102,6 +102,14 @@ public interface DbMigration {
    */
   void addPlatform(Platform platform, String prefix);
 
+  /**
+   * Add an additional databasePlatform to write the migration DDL.
+   * <p>
+   * Use this when you want to add preconfigured database platforms.
+   * </p>
+   */
+  void addDatabasePlatform(DatabasePlatform databasePlatform, String prefix);
+
   /**
    * Generate the next migration xml file and associated apply and rollback sql scripts.
    * <p>

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

@@ -0,0 +1,26 @@
+package io.ebean.event;
+
+import io.ebean.EbeanServer;
+import io.ebean.Transaction;
+
+/**
+ * A request to delete a bean by Id value.
+ */
+public interface BeanDeleteIdRequest {
+
+  /**
+   * Return the server processing the request.
+   */
+  EbeanServer getEbeanServer();
+
+  /**
+   * Return the Transaction associated with this request.
+   */
+  Transaction getTransaction();
+
+  /**
+   * Returns the Id value of the bean being deleted.
+   */
+  Object getId();
+
+}

src/main/java/io/ebean/event/BeanPersistAdapter.java

@@ -87,4 +87,11 @@ public abstract class BeanPersistAdapter implements BeanPersistController {
   public void postSoftDelete(BeanPersistRequest<?> request) {
   }
 
+  /**
+   * Does nothing by default.
+   */
+  @Override
+  public void preDelete(BeanDeleteIdRequest request) {
+
+  }
 }

src/main/java/io/ebean/event/BeanPersistController.java

@@ -92,6 +92,11 @@ public interface BeanPersistController {
    */
   boolean preSoftDelete(BeanPersistRequest<?> request);
 
+  /**
+   * Prior to a delete by id perform some action.
+   */
+  void preDelete(BeanDeleteIdRequest request);
+
   /**
    * Called after the insert was performed.
    */

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

@@ -0,0 +1,43 @@
+package io.ebean.meta;
+
+/**
+ * An abstract MetricVisitor that handles the boolean flags - reset, collectTransactionMetrics and collectQueryMetrics.
+ */
+public abstract class AbstractMetricVisitor implements MetricVisitor {
+
+  private final boolean reset;
+  private final boolean collectTransactionMetrics;
+  private final boolean collectQueryMetrics;
+
+  public AbstractMetricVisitor(boolean reset, boolean collectTransactionMetrics, boolean collectQueryMetrics) {
+    this.reset = reset;
+    this.collectTransactionMetrics = collectTransactionMetrics;
+    this.collectQueryMetrics = collectQueryMetrics;
+  }
+
+  @Override
+  public boolean isReset() {
+    return reset;
+  }
+
+  @Override
+  public boolean isCollectTransactionMetrics() {
+    return collectTransactionMetrics;
+  }
+
+  @Override
+  public boolean isCollectQueryMetrics() {
+    return collectQueryMetrics;
+  }
+
+  @Override
+  public void visitStart() {
+    // do nothing by default
+  }
+
+  @Override
+  public void visitEnd() {
+    // do nothing by default
+  }
+}
+

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

@@ -0,0 +1,64 @@
+package io.ebean.meta;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A simple MetricVisitor that can collect the desired metrics into lists.
+ */
+public class BasicMetricVisitor extends AbstractMetricVisitor {
+
+  private final List<MetaTimedMetric> timed = new ArrayList<>();
+  private final List<MetaQueryMetric> dtoQuery = new ArrayList<>();
+  private final List<MetaOrmQueryMetric> ormQuery = new ArrayList<>();
+
+  /**
+   * Construct to reset and collect everything.
+   */
+  public BasicMetricVisitor() {
+    super(true, true, true);
+  }
+
+  /**
+   * Construct specifying reset and what to collect.
+   */
+  public BasicMetricVisitor(boolean reset, boolean collectTransactionMetrics, boolean collectQueryMetrics) {
+    super(reset, collectTransactionMetrics, collectQueryMetrics);
+  }
+
+  /**
+   * Return timed metrics for Transactions, labelled SqlQuery, labelled SqlUpdate.
+   */
+  public List<MetaTimedMetric> getTimedMetrics() {
+    return timed;
+  }
+
+  /**
+   * Return the DTO query metrics.
+   */
+  public List<MetaQueryMetric> getDtoQueryMetrics() {
+    return dtoQuery;
+  }
+
+  /**
+   * Return the ORM query metrics.
+   */
+  public List<MetaOrmQueryMetric> getOrmQueryMetrics() {
+    return ormQuery;
+  }
+
+  @Override
+  public void visitTimed(MetaTimedMetric metric) {
+    timed.add(metric);
+  }
+
+  @Override
+  public void visitQuery(MetaQueryMetric metric) {
+    dtoQuery.add(metric);
+  }
+
+  @Override
+  public void visitOrmQuery(MetaOrmQueryMetric metric) {
+    ormQuery.add(metric);
+  }
+}

src/main/java/io/ebean/meta/MetaInfoManager.java

@@ -8,18 +8,20 @@ import java.util.List;
 public interface MetaInfoManager {
 
   /**
-   * Collect and return the transaction execution metrics.
+   * Visit the metrics resetting and collecting/reporting as desired.
    */
-  List<MetaTimedMetric> collectTransactionStatistics(boolean reset);
+  void visitMetrics(MetricVisitor visitor);
 
   /**
-   * Collect and return the non-empty query plan statistics for all the beans.
-   * <p>
-   * Note that this excludes the query plan statistics where there has been no
-   * executions (since the last collection with reset).
-   * </p>
+   * Run a visit collecting all the metrics and returning BasicMetricVisitor
+   * which holds all the metrics in simple lists.
    */
-  List<MetaQueryPlanStatistic> collectQueryPlanStatistics(boolean reset);
+  BasicMetricVisitor visitBasic();
+
+  /**
+   * Just reset all the metrics. Maybe only useful for testing purposes.
+   */
+  void resetAllMetrics();
 
   /**
    * Collect and return the ObjectGraphNode statistics.
@@ -31,6 +33,6 @@ public interface MetaInfoManager {
    *
    * @param reset Set to true to reset the underlying statistics after collection.
    */
-  List<MetaObjectGraphNodeStats> collectNodeStatistics(boolean reset);
+  List<MetaOrmQueryNode> collectNodeStatistics(boolean reset);
 
 }

src/main/java/io/ebean/meta/MetaOrmQueryMetric.java

@@ -0,0 +1,42 @@
+package io.ebean.meta;
+
+import io.ebean.ProfileLocation;
+
+import java.util.List;
+
+/**
+ * Query execution statistics for Orm queries.
+ */
+public interface MetaOrmQueryMetric extends MetaQueryMetric {
+
+  /**
+   * Return the profile location.
+   */
+  ProfileLocation getProfileLocation();
+
+  /**
+   * Return true if this query plan was tuned by AutoTune.
+   */
+  boolean isAutoTuned();
+
+  /**
+   * Return a string representation of the query plan hash.
+   */
+  String getQueryPlanHash();
+
+  /**
+   * Return the time of the last query executed using this plan.
+   */
+  long getLastQueryTime();
+
+  /**
+   * Return the 'origin' points and paths that resulted in the query being
+   * executed and the associated number of times the query was executed via that
+   * path.
+   * <p>
+   * This includes direct and lazy loading paths.
+   * </p>
+   */
+  List<MetaOrmQueryOrigin> getOrigins();
+
+}

src/main/java/io/ebean/meta/MetaOrmQueryNode.java

@@ -8,10 +8,8 @@ import io.ebean.bean.ObjectGraphNode;
  * These statistics can be used to identify origin queries that result in lots
  * of lazy loading.
  * </p>
- *
- * @see MetaInfoManager#collectNodeStatistics(boolean)
  */
-public interface MetaObjectGraphNodeStats {
+public interface MetaOrmQueryNode {
 
   /**
    * Return the ObjectGraphNode which has the origin point and relative path.

src/main/java/io/ebean/meta/MetaOrmQueryOrigin.java

@@ -9,11 +9,8 @@ import io.ebean.bean.ObjectGraphNode;
  * This basically points to the bit of original code and query that results in
  * this query directly or via lazy loading.
  * </p>
- *
- * @see MetaQueryPlanStatistic
- * @see MetaInfoManager#collectQueryPlanStatistics(boolean)
  */
-public interface MetaQueryPlanOriginCount {
+public interface MetaOrmQueryOrigin {
 
   /**
    * The 'origin' and path which this query belongs to.

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

@@ -0,0 +1,23 @@
+package io.ebean.meta;
+
+/**
+ * Query execution metrics.
+ */
+public interface MetaQueryMetric extends MetaTimedMetric {
+
+  /**
+   * The type of entity or DTO bean.
+   */
+  Class<?> getType();
+
+  /**
+   * The label for the query (can be null).
+   */
+  String getLabel();
+
+  /**
+   * The actual SQL of the query.
+   */
+  String getSql();
+
+}

src/main/java/io/ebean/meta/MetaQueryPlanStatistic.java

@@ -1,98 +0,0 @@
-package io.ebean.meta;
-
-import io.ebean.ProfileLocation;
-
-import java.util.List;
-
-/**
- * Query execution statistics Meta data.
- *
- * @see MetaInfoManager#collectQueryPlanStatistics(boolean)
- */
-public interface MetaQueryPlanStatistic {
-
-  /**
-   * Return the bean type this query plan is for.
-   */
-  Class<?> getBeanType();
-
-  /**
-   * Return the profile location.
-   */
-  ProfileLocation getProfileLocation();
-
-  /**
-   * Return true if this query plan was tuned by AutoTune.
-   */
-  boolean isAutoTuned();
-
-  /**
-   * Return a string representation of the query plan hash.
-   */
-  String getQueryPlanHash();
-
-  /**
-   * Return the sql executed.
-   */
-  String getSql();
-
-  /**
-   * Return the total number of queries executed.
-   */
-  long getExecutionCount();
-
-  /**
-   * Return the total number of beans loaded by the queries.
-   * <p>
-   * This excludes background fetching.
-   * </p>
-   */
-  long getTotalLoadedBeans();
-
-  /**
-   * Return the total time taken by executions of this query.
-   */
-  long getTotalTimeMicros();
-
-  /**
-   * Return the max execution time for this query.
-   */
-  long getMaxTimeMicros();
-
-  /**
-   * Return the time collection started (or was last reset).
-   */
-  long getCollectionStart();
-
-  /**
-   * Return the time of the last query executed using this plan.
-   */
-  long getLastQueryTime();
-
-  /**
-   * Return the average query execution time in microseconds.
-   * <p>
-   * This excludes background fetching.
-   * </p>
-   */
-  long getAvgTimeMicros();
-
-  /**
-   * Return the average number of bean loaded per query.
-   * <p>
-   * This excludes background fetching.
-   * </p>
-   */
-  long getAvgLoadedBeans();
-
-  /**
-   * Return the 'origin' points and paths that resulted in the query being
-   * executed and the associated number of times the query was executed via that
-   * path.
-   * <p>
-   * This includes direct and lazy loading paths.
-   * </p>
-   */
-  List<MetaQueryPlanOriginCount> getOrigins();
-
-}

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

@@ -6,6 +6,11 @@ package io.ebean.meta;
  */
 public interface MetaTimedMetric {
 
+  /**
+   * Return the metric type.
+   */
+  MetricType getMetricType();
+
   /**
    * Return the metric name.
    */
@@ -27,17 +32,24 @@ public interface MetaTimedMetric {
   long getCount();
 
   /**
-   * Return the total execution time.
+   * Return the total execution time in micros.
    */
   long getTotal();
 
   /**
-   * Return the max execution time.
+   * Return the max execution time in micros.
    */
   long getMax();
 
   /**
-   * Return the mean execution time.
+   * Return the mean execution time in micros.
    */
   long getMean();
+
+  /**
+   * Return the total beans or rows processed or loaded.
+   *
+   * This will be 0 if the metric isn't a query plan (like transaction execution statistics).
+   */
+  long getBeanCount();
 }

src/main/java/io/ebean/meta/MetricType.java

@@ -0,0 +1,30 @@
+package io.ebean.meta;
+
+/**
+ * The type of Metric.
+ */
+public enum MetricType {
+
+  /**
+   * Transactions.
+   */
+  TXN,
+
+  /**
+   * ORM queries.
+   */
+  ORM,
+
+  /**
+   * DTO queries.
+   */
+  DTO,
+
+  /**
+   * SQL queries with a label will have metrics collected.
+   * <p>
+   * SqlQuery and SqlUpdate without a label have no metrics collected.
+   */
+  SQL
+
+}

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

@@ -0,0 +1,48 @@
+package io.ebean.meta;
+
+/**
+ * Defines visitor to read and report the transaction and query metrics.
+ */
+public interface MetricVisitor {
+
+  /**
+   * Return true if the metrics should be reset.
+   */
+  boolean isReset();
+
+  /**
+   * Return true if we should visit the transaction metrics.
+   */
+  boolean isCollectTransactionMetrics();
+
+  /**
+   * Return true if we should visit the ORM and SQL query metrics.
+   */
+  boolean isCollectQueryMetrics();
+
+  /**
+   * Visit has started.
+   */
+  void visitStart();
+
+  /**
+   * Visit transaction metrics (and L2 cache metrics in future).
+   */
+  void visitTimed(MetaTimedMetric metric);
+
+  /**
+   * Visit DTO and SQL query metrics.
+   */
+  void visitQuery(MetaQueryMetric metric);
+
+  /**
+   * Visit ORM query metrics.
+   */
+  void visitOrmQuery(MetaOrmQueryMetric metric);
+
+  /**
+   * Visit has completed.
+   */
+  void visitEnd();
+
+}

src/main/java/io/ebean/service/SpiRawSqlService.java

@@ -2,8 +2,10 @@ package io.ebean.service;
 
 import io.ebean.RawSql;
 import io.ebean.RawSqlBuilder;
+import io.ebean.SqlRow;
 
 import java.sql.ResultSet;
+import java.sql.SQLException;
 
 /**
  * Service provided by Ebean for parsing and column mapping raw SQL queries.
@@ -24,4 +26,13 @@ public interface SpiRawSqlService {
    * Unparsed SQL so explicit column mapping expected.
    */
   RawSqlBuilder unparsed(String sql);
+
+  /**
+   * Create based on a JDBC ResultSet.
+   *
+   * @param resultSet           The ResultSet row to read as a SqlRow
+   * @param dbTrueValue         The DB true value
+   * @param binaryOptimizedUUID Flag set to true if the UUID value is stored as optimised binary(16)
+   */
+  SqlRow sqlRow(ResultSet resultSet, String dbTrueValue, boolean binaryOptimizedUUID) throws SQLException;
 }

src/main/java/io/ebean/text/json/EJson.java

@@ -136,7 +136,6 @@ public class EJson {
   /**
    * Parse the json returning as a List taking into account the current token.
    */
-  @SuppressWarnings("unchecked")
   public static <T> List<T> parseList(JsonParser parser, JsonToken currentToken) throws IOException {
     return plugin.parseList(parser, currentToken);
   }

src/main/java/io/ebean/util/AnnotationUtil.java

@@ -34,13 +34,14 @@ public class AnnotationUtil {
    * does not execute specialized search algorithms for classes or methods. It only traverses through Annotations!
    * It also does not filter out platform dependent annotations!
    */
+  @SuppressWarnings("unchecked")
   public static <A extends Annotation> A findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType) {
     if (annotationType == null) {
       return null;
     }
     // check if directly present, if not, start search for meta-annotations.
-    Annotation[] anns = annotatedElement.getAnnotations(); 
-    if (anns.length == 0) { 
+    Annotation[] anns = annotatedElement.getAnnotations();
+    if (anns.length == 0) {
       return null; // no annotations present, so searching for meta annotations not required
     }
 
@@ -51,7 +52,7 @@ public class AnnotationUtil {
         return (A) ann;
       }
     }
-    
+
     return findAnnotation(anns, annotationType, new HashSet<>());
 
   }
@@ -62,6 +63,7 @@ public class AnnotationUtil {
    * the supplied element.
    * <p><strong>Note</strong>: this method searches for annotations at class & superClass(es)!
    */
+  @SuppressWarnings("unchecked")
   public static <A extends Annotation> A findAnnotationRecursive(Class<?> clazz, Class<A> annotationType) {
     if (annotationType == null) {
       return null;
@@ -102,7 +104,7 @@ public class AnnotationUtil {
   }
 
   /**
-   * Finds all annotations recusively for a class and its superclasses.
+   * Finds all annotations recusively for a class and its superclasses or interfaces.
    */
   public static <A extends Annotation> Set<A> findAnnotationsRecursive(Class<?> clazz, Class<A> annotationType) {
     if (annotationType == null) {
@@ -110,13 +112,28 @@ public class AnnotationUtil {
     }
     Set<A> ret = new LinkedHashSet<>();
     Set<Annotation> visited = new HashSet<>();
-    while (clazz != null && clazz != Object.class) {
-      findMetaAnnotations(clazz, annotationType, ret, visited);
+    Set<Class<?>> visitedInterfaces = new HashSet<>();
+    while (clazz != null && !clazz.getName().startsWith("java.lang.")) {
+      findMetaAnnotationsRecursive(clazz, annotationType, ret, visited, visitedInterfaces);
       clazz = clazz.getSuperclass();
     }
     return ret;
   }
 
+  /**
+   * Searches the interfaces for annotations.
+   */
+  private static <A extends Annotation> void findMetaAnnotationsRecursive(Class<?> clazz,
+      Class<A> annotationType, Set<A> ret,
+      Set<Annotation> visited, Set<Class<?>> visitedInterfaces) {
+    findMetaAnnotations(clazz, annotationType, ret, visited);
+    for (Class<?> iface : clazz.getInterfaces()) {
+      if (!iface.getName().startsWith("java.lang.") && visitedInterfaces.add(iface)) {
+        findMetaAnnotationsRecursive(iface, annotationType, ret, visited, visitedInterfaces);
+      }
+    }
+  }
+
   /**
    * Perform the search algorithm avoiding endless recursion by tracking which
    * annotations have already been visited.

src/main/java/io/ebean/util/CamelCaseHelper.java

@@ -2,6 +2,52 @@ package io.ebean.util;
 
 public class CamelCaseHelper {
 
+  /**
+   * To underscore from camel case using digits compressed true and force upper case false.
+   */
+  public static String toUnderscoreFromCamel(String camelCase) {
+    return toUnderscoreFromCamel(camelCase, true, false);
+  }
+
+  /**
+   * Convert and return the string to underscore from camel case.
+   */
+  public static String toUnderscoreFromCamel(String camelCase, boolean digitsCompressed, boolean forceUpperCase) {
+
+    int lastUpper = -1;
+    StringBuilder sb = new StringBuilder(camelCase.length() + 4);
+    for (int i = 0; i < camelCase.length(); i++) {
+      char c = camelCase.charAt(i);
+
+      if ('_' == c) {
+        // Underscores should just be passed through
+        sb.append(c);
+        lastUpper = i;
+      } else if (Character.isDigit(c)) {
+        if (i > lastUpper + 1 && !digitsCompressed) {
+          sb.append("_");
+        }
+        sb.append(c);
+        lastUpper = i;
+
+      } else if (Character.isUpperCase(c)) {
+        if (i > lastUpper + 1) {
+          sb.append("_");
+        }
+        sb.append(Character.toLowerCase(c));
+        lastUpper = i;
+
+      } else {
+        sb.append(c);
+      }
+    }
+    String ret = sb.toString();
+    if (forceUpperCase) {
+      ret = ret.toUpperCase();
+    }
+    return ret;
+  }
+
   /**
    * To camel from underscore.
    *

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

@@ -1,10 +1,12 @@
-package io.ebeaninternal.util;
+package io.ebean.util;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.sql.Connection;
+import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 
 /**
  * Utility for closing raw Jdbc resources.
@@ -13,6 +15,32 @@ public class JdbcClose {
 
   private static final Logger logger = LoggerFactory.getLogger(JdbcClose.class);
 
+  /**
+   * Close the resultSet logging if an error occurs.
+   */
+  public static void close(Statement statement) {
+    try {
+      if (statement != null) {
+        statement.close();
+      }
+    } catch (SQLException e) {
+      logger.warn("Error closing statement", e);
+    }
+  }
+
+  /**
+   * Close the resultSet logging if an error occurs.
+   */
+  public static void close(ResultSet resultSet) {
+    try {
+      if (resultSet != null) {
+        resultSet.close();
+      }
+    } catch (SQLException e) {
+      logger.warn("Error closing resultSet", e);
+    }
+  }
+
   /**
    * Close the connection logging if an error occurs.
    */

src/main/java/io/ebeaninternal/api/LoadManyRequest.java

@@ -1,6 +1,5 @@
 package io.ebeaninternal.api;
 
-import io.ebean.EbeanServer;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebean.util.StringHelper;
@@ -124,11 +123,11 @@ public class LoadManyRequest extends LoadRequest {
     return loadContext.getBeanProperty();
   }
 
-  public SpiQuery<?> createQuery(EbeanServer server, int batchSize) {
+  public SpiQuery<?> createQuery(SpiEbeanServer server, int batchSize) {
 
     BeanPropertyAssocMany<?> many = getMany();
 
-    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(many.getTargetType());
+    SpiQuery<?> query = many.newQuery(server);
     String orderBy = many.getLazyFetchOrderBy();
     if (orderBy != null) {
       query.orderBy(orderBy);

src/main/java/io/ebeaninternal/api/ScopeTrans.java

@@ -89,6 +89,7 @@ public class ScopeTrans {
 
   }
 
+  @Override
   public String toString() {
     return "ScopeTrans[" + transaction + "]";
   }

src/main/java/io/ebeaninternal/api/ScopedTransaction.java

@@ -21,10 +21,16 @@ public class ScopedTransaction extends SpiTransactionProxy {
 
   private ScopeTrans current;
 
+  /**
+   * Flag set when we clear the thread scope (on commit/rollback or end).
+   */
+  private boolean scopeCleared;
+
   public ScopedTransaction(TransactionScopeManager manager) {
     this.manager = manager;
   }
 
+  @Override
   public String toString() {
     return "ScopedTransaction[" + current + "]";
   }
@@ -46,30 +52,51 @@ public class ScopedTransaction extends SpiTransactionProxy {
    */
   public void complete(Object returnOrThrowable, int opCode) {
     current.complete(returnOrThrowable, opCode);
+    // no finally here for pop() as we come in here twice if an
+    // error is thrown on commit (due to enhancement finally block)
     pop();
   }
 
   /**
-   * Programmatic complete - finally block, try to commit.
+   * Internal programmatic complete - finally block, try to commit.
    */
   public void complete() {
-    current.complete();
-    pop();
+    try {
+      current.complete();
+    } finally {
+      pop();
+    }
+  }
+
+  private void clearScopeOnce() {
+    if (!scopeCleared) {
+      manager.set(null);
+      scopeCleared = true;
+    }
+  }
+
+  private boolean clearScope() {
+    if (stack.isEmpty()) {
+      clearScopeOnce();
+      return true;
+    }
+    return false;
   }
 
   private void pop() {
-    if (!stack.isEmpty()) {
+    if (!clearScope()) {
       current = stack.pop();
       transaction = current.getTransaction();
-    } else {
-      manager.set(null);
     }
   }
 
   @Override
   public void end() throws PersistenceException {
-    current.end();
-    pop();
+    try {
+      current.end();
+    } finally {
+      pop();
+    }
   }
 
   @Override
@@ -79,17 +106,29 @@ public class ScopedTransaction extends SpiTransactionProxy {
 
   @Override
   public void commit() {
-    current.commitTransaction();
+    try {
+      current.commitTransaction();
+    } finally {
+      clearScope();
+    }
   }
 
   @Override
   public void rollback() throws PersistenceException {
-    current.rollback(null);
+    try {
+      current.rollback(null);
+    } finally {
+      clearScope();
+    }
   }
 
   @Override
   public void rollback(Throwable e) throws PersistenceException {
-    current.rollback(e);
+    try {
+      current.rollback(e);
+    } finally {
+      clearScope();
+    }
   }
 
   @Override

src/main/java/io/ebeaninternal/api/SpiDtoQuery.java

@@ -0,0 +1,52 @@
+package io.ebeaninternal.api;
+
+import io.ebean.DtoQuery;
+import io.ebeaninternal.server.dto.DtoMappingRequest;
+import io.ebeaninternal.server.dto.DtoQueryPlan;
+
+/**
+ * Internal extension to DtoQuery.
+ */
+public interface SpiDtoQuery<T> extends DtoQuery<T>, SpiSqlBinding {
+
+  /**
+   * Return the key for query plan.
+   */
+  String planKey();
+
+  /**
+   * Get the query plan for the cache.
+   */
+  DtoQueryPlan getQueryPlan(Object planKey);
+
+  /**
+   * Build the query plan.
+   */
+  DtoQueryPlan buildPlan(DtoMappingRequest request);
+
+  /**
+   * Put the query plan into the cache.
+   */
+  void putQueryPlan(Object planKey, DtoQueryPlan plan);
+
+  /**
+   * Return true if the query is in relaxed mapping mode.
+   */
+  boolean isRelaxedMode();
+
+  /**
+   * Return the label for the query.
+   */
+  String getLabel();
+
+  /**
+   * Return the associated DTO bean type.
+   */
+  Class<T> getType();
+
+  /**
+   * Return an underlying ORM query (if this query is built from an ORM query).
+   */
+  SpiQuery<?> getOrmQuery();
+
+}

src/main/java/io/ebeaninternal/api/SpiEbeanServer.java

@@ -1,5 +1,6 @@
 package io.ebeaninternal.api;
 
+import io.ebean.DtoQuery;
 import io.ebean.EbeanServer;
 import io.ebean.PersistenceContextScope;
 import io.ebean.Query;
@@ -13,13 +14,17 @@ import io.ebean.config.ServerConfig;
 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.ebeaninternal.dbmigration.ddlgeneration.DdlHandler;
+import io.ebeaninternal.server.core.SpiResultSet;
 import io.ebeaninternal.server.core.timezone.DataTimeZone;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.query.CQuery;
 import io.ebeaninternal.server.transaction.RemoteTransactionEvent;
 
 import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 /**
  * Service Provider extension to EbeanServer.
@@ -224,4 +229,43 @@ public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionL
    */
   void scopedTransactionExit(Object returnOrThrowable, int opCode);
 
+  /**
+   * DTO findList query.
+   */
+  <T> List<T> findDtoList(SpiDtoQuery<T> query);
+
+  /**
+   * DTO findOne query.
+   */
+  <T> T findDtoOne(SpiDtoQuery<T> query);
+
+  /**
+   * DTO findEach query.
+   */
+  <T> void findDtoEach(SpiDtoQuery<T> query, Consumer<T> consumer);
+
+  /**
+   * DTO findEachWhile query.
+   */
+  <T> void findDtoEachWhile(SpiDtoQuery<T> query, Predicate<T> consumer);
+
+  /**
+   * Return / wrap the ORM query as a DTO query.
+   */
+  <D> DtoQuery<D> findDto(Class<D> dtoType, SpiQuery<?> ormQuery);
+
+  /**
+   * Execute the underlying ORM query returning as a JDBC ResultSet to map to DTO beans.
+   */
+  SpiResultSet findResultSet(SpiQuery<?> ormQuery, SpiTransaction transaction);
+
+  /**
+   * Visit all the metrics (typically reporting them).
+   */
+  void visitMetrics(MetricVisitor visitor);
+
+  /**
+   * Return true if a row for the bean type and id exists.
+   */
+  boolean exists(Class<?> beanType, Object beanId, Transaction transaction);
 }