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

No effective change - Update tests from Ebean -> DB
No effective change - Add more tests for LocalDate pre 1900 etc
2024-04-21 10:51:47 +00:00 · 2019-03-14 21:16:47 +13:00 · 2019-03-14 21:11:59 +13:00 · 2019-03-14 16:20:14 +13:00 · 2019-03-14 16:15:47 +13:00 · 2019-03-14 16:08:04 +13:00
1564 changed files with 90871 additions and 27699 deletions
@@ -10,3 +10,4 @@ indent_style = space
 insert_final_newline = true
 trim_trailing_whitespace = true
 spaces_around_operators = true
+max_line_length = 130
@@ -20,3 +20,4 @@ profiling/
 *.ipr
 *.iws
 .idea/
+*uuid.state
@@ -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

@@ -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
+
@@ -1,8 +1,11 @@
+[![Build Status](https://travis-ci.org/ebean-orm/ebean.svg?branch=master)](https://travis-ci.org/ebean-orm/ebean)
+[![Maven Central : ebean](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean)
+
 # Need help?
 Post questions or issues to the Ebean google group - https://groups.google.com/forum/#!forum/ebean

 # Documentation
-Goto [https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Website")
+Goto [https://ebean.io/docs/](https://ebean.io/docs/)


 ## Maven cental links:
@@ -10,8 +13,7 @@ Goto [https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Web

 [Maven central - all related projects](http://search.maven.org/#search%7Cga%7C1%7Cebean "maven central all related projects")

-## Current versions
-* [![Maven Central : ebean](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean) - ebean
-* [![Maven Central : ebean-agent](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-agent) - ebean-agent
-* [![Maven Central : ebean-maven-plugin](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-maven-plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-maven-plugin) - ebean-maven-plugin
+## Other versions
+* [![Maven Central : ebean-agent](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-agent) - ebean-agent
+* [![Maven Central : ebean-maven-plugin](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-maven-plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-maven-plugin) - ebean-maven-plugin

@@ -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
@@ -150,3 +151,18 @@ In `InsertHandler.getPstmt` the `meta.getIdentityDbColumns()` contains
 TODO: not yet tested


+
+'hana' platform
+--------------------
+
+Requires an installed SAP HANA server - e.g. https://store.docker.com/images/sap-hana-express-edition
+
+- Create a user `EBEAN_TEST` with password `Eb3an_test` in the tenant database `HXE`
+- Adjust the connection string and/or username in `ebean.properties`
+  
+run: `mvn clean test -Ddatasource.default=hana`
+
+Current status: PASS
+Tests run: 2486, Failures: 0, Errors: 0, Skipped: 84
+
+
@@ -9,15 +9,20 @@

  <groupId>io.ebean</groupId>
  <artifactId>ebean</artifactId>
-  <version>11.10.1</version>
+  <version>11.36.2</version>
  <packaging>jar</packaging>

  <name>ebean</name>
  <url>http://ebean-orm.github.io/</url>

+  <properties>
+    <jackson-core.version>2.9.5</jackson-core.version>
+    <snakeyaml.version>1.21</snakeyaml.version>
+  </properties>
+
  <scm>
    <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-11.10.1</tag>
+    <tag>ebean-11.36.2</tag>
  </scm>

  <profiles>
@@ -83,6 +88,15 @@
      <scope>provided</scope>
    </dependency>

+    <!--
+    Exclude snakeyaml if you desire - it is not strictly required.
+    -->
+    <dependency>
+      <groupId>org.yaml</groupId>
+      <artifactId>snakeyaml</artifactId>
+      <version>${snakeyaml.version}</version>
+    </dependency>
+
    <!--
    Class retention Nonnull and Nullable annotations
    to assist with IDE auto-completion with Ebean API
@@ -103,13 +117,19 @@
    <dependency>
      <groupId>io.ebean</groupId>
      <artifactId>ebean-annotation</artifactId>
-      <version>3.6</version>
+      <version>4.6</version>
    </dependency>

    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-datasource</artifactId>
-      <version>3.1.1</version>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-types</artifactId>
+      <version>1.3</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-datasource</artifactId>
+      <version>4.5.1</version>
    </dependency>

    <dependency>
@@ -121,27 +141,27 @@
    <dependency>
      <groupId>io.ebean</groupId>
      <artifactId>ebean-migration</artifactId>
-      <version>11.3.1</version>
+      <version>11.14.1</version>
    </dependency>

    <dependency>
      <groupId>org.antlr</groupId>
      <artifactId>antlr4-runtime</artifactId>
-      <version>4.6</version>
+      <version>4.7.2</version>
    </dependency>

    <!-- Jackson core used internally by Ebean -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
-      <version>2.9.0</version>
+      <version>${jackson-core.version}</version>
    </dependency>

    <!-- provided scope for JsonNode support -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
-      <version>2.9.0</version>
+      <version>${jackson-core.version}</version>
      <scope>provided</scope>
    </dependency>

@@ -174,11 +194,26 @@
      <scope>provided</scope>
    </dependency>

+    <!-- Provided scope to compile with java 11 -->
+    <dependency>
+      <groupId>org.glassfish.jaxb</groupId>
+      <artifactId>jaxb-runtime</artifactId>
+      <version>2.4.0-b180830.0438</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.annotation</groupId>
+      <artifactId>javax.annotation-api</artifactId>
+      <version>1.3.2</version>
+      <scope>provided</scope>
+    </dependency>
+
    <!-- Provided scope for Postgres JSON/JSONB support -->
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
-      <version>9.4.1212</version>
+      <version>42.2.2</version>
      <scope>provided</scope>
    </dependency>

@@ -191,12 +226,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>
@@ -208,14 +243,14 @@
    <dependency>
      <groupId>org.avaje</groupId>
      <artifactId>avaje-agentloader</artifactId>
-      <version>2.1.2</version>
+      <version>3.0.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>io.ebean</groupId>
      <artifactId>ebean-agent</artifactId>
-      <version>11.9.1</version>
+      <version>11.27.1</version>
      <scope>test</scope>
    </dependency>

@@ -224,7 +259,7 @@
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
-      <version>1.4.196</version>
+      <version>1.4.197</version>
      <scope>provided</scope>
    </dependency>

@@ -245,7 +280,7 @@
    <dependency>
      <groupId>com.microsoft.sqlserver</groupId>
      <artifactId>mssql-jdbc</artifactId>
-      <version>6.1.3.jre8-preview</version>
+      <version>7.2.0.jre8</version>
      <scope>test</scope>
    </dependency>

@@ -257,6 +292,13 @@
      <scope>test</scope>
    </dependency>

+    <dependency>
+      <groupId>com.sap.cloud.db.jdbc</groupId>
+      <artifactId>ngdbc</artifactId>
+      <version>2.3.48</version>
+      <scope>test</scope>
+    </dependency>
+
    <dependency>
      <groupId>org.avaje.composite</groupId>
      <artifactId>avaje-composite-testing</artifactId>
@@ -288,7 +330,7 @@
      <plugin>
        <groupId>io.ebean</groupId>
        <artifactId>ebean-maven-plugin</artifactId>
-        <version>11.9.1</version>
+        <version>11.27.1</version>
        <executions>
          <execution>
            <id>test</id>
@@ -306,9 +348,10 @@
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
-        <version>2.5</version>
+        <version>2.22.1</version>
        <configuration>
          <useSystemClassLoader>false</useSystemClassLoader>
+          <trimStackTrace>false</trimStackTrace>
          <failIfNoTests>false</failIfNoTests>
          <includes>
            <include>**/Test*.java</include>
@@ -321,6 +364,11 @@
              <name>datasource.default</name>
              <value>${datasource.default}</value>
            </property>
+            <property>
+              <!-- transfer dbClockDelta parameter -->
+              <name>dbClockDelta</name>
+              <value>${dbClockDelta}</value>
+            </property>
          </systemProperties>
        </configuration>
      </plugin>
@@ -341,11 +389,11 @@
        <artifactId>maven-javadoc-plugin</artifactId>
        <version>2.9.1</version>
        <configuration>
-          <doctitle>Ebean 10</doctitle>
+          <doctitle>Ebean 11</doctitle>
          <overview>src/main/java/io/ebean/overview.html</overview>
          <source>1.8</source>
          <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
-          <excludePackageNames>io.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames>
+          <excludePackageNames>io.ebeaninternal.*:io.ebeanservice:io.ebean.common:io.ebean.bean:io.ebean.service:io.ebean.metric:io.ebean.util:io.ebean.config.properties:io.ebean.config.dbplatform*</excludePackageNames>
          <docletArtifact>
            <groupId>org.avaje</groupId>
            <artifactId>pygments-doclet</artifactId>
@@ -1,6 +1,8 @@
 package io.ebean;

+import java.util.concurrent.Callable;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;

 /**
@@ -37,4 +39,21 @@ public interface BackgroundExecutor {
   * </p>
   */
  void executePeriodically(Runnable r, long delay, TimeUnit unit);
+
+  /**
+   * Schedules a Runnable for one-shot action that becomes enabled after the given delay.
+   *
+   * @return a ScheduledFuture representing pending completion of the task and
+   *         whose get() method will return null upon completion
+   */
+  ScheduledFuture<?> schedule(Runnable r, long delay, TimeUnit unit);
+
+  /**
+   * Schedules a Callable for one-shot action that becomes enabled after the given delay.
+   *
+   * @return a ScheduledFuture that can be used to extract result or cancel
+   */
+  <V> ScheduledFuture<V> schedule(Callable<V> c, long delay, TimeUnit unit);
+
+
 }
@@ -0,0 +1,164 @@
+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(Database database) {
+ *     super(Customer.class, database);
+ *   }
+ *
+ *   // ... add customer specific finders
+ * }
+ *
+ * }</pre>
+ *
+ * @param <I> The ID type
+ * @param <T> The Bean type
+ */
+public abstract class BeanFinder<I,T> {
+
+  protected final Database server;
+
+  protected final Class<T> type;
+
+  /**
+   * Create with the given bean type and Database instance.
+   *
+   * @param type The bean type
+   * @param server The Database instance typically created via Spring factory or equivalent.
+   */
+  protected BeanFinder(Class<T> type, Database server) {
+    this.type = type;
+    this.server = server;
+  }
+
+  /**
+   * Return the Database to use.
+   */
+  public Database 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 Database to the default.
+   * <p>
+   * This is equivalent to {@link DB#byName(String)}
+   *
+   * @param server The name of the Database. If this is null then the default Database is returned.
+   */
+  public Database db(String server) {
+    return DB.byName(server);
+  }
+
+  /**
+   * Creates an entity reference for this ID.
+   * <p>
+   * Equivalent to {@link Database#getReference(Class, Object)}
+   */
+  @Nonnull
+  public T ref(I id) {
+    return db().getReference(type, id);
+  }
+
+  /**
+   * Retrieves an entity by ID.
+   */
+  @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.
+   */
+  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 Database#update(Class)}
+   */
+  protected UpdateQuery<T> updateQuery() {
+    return db().update(type);
+  }
+
+  /**
+   * Creates a query.
+   * <p>
+   * Equivalent to {@link Database#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);
+  }
+}
@@ -0,0 +1,218 @@
+package io.ebean;
+
+import io.ebean.bean.EntityBean;
+
+import java.util.Collection;
+
+/**
+ * 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(Database 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 Database instance.
+   * <p>
+   * Typically users would extend BeanRepository rather than BeanFinder.
+   * </p>
+   * <pre>{@code
+   *
+   *   @Inject
+   *   public CustomerRepository(Database server) {
+   *     super(Customer.class, server);
+   *   }
+   *
+   * }</pre>
+   *
+   * @param type   The bean type
+   * @param server The Database instance typically created via Spring factory or equivalent
+   */
+  protected BeanRepository(Class<T> type, Database 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 Database#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 Database#save(Object)
+   */
+  public void save(T bean) {
+    db().save(bean);
+  }
+
+  /**
+   * Save all the beans in the collection.
+   */
+  public int saveAll(Collection<T> bean) {
+    return db().saveAll(bean);
+  }
+
+  /**
+   * Update this entity.
+   *
+   * @see Database#update(Object)
+   */
+  public void update(T bean) {
+    db().update(bean);
+  }
+
+  /**
+   * Insert this entity.
+   *
+   * @see Database#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 Database#delete(Object)
+   */
+  public boolean delete(T bean) {
+    return db().delete(bean);
+  }
+
+  /**
+   * Delete all the beans in the collection.
+   */
+  public int deleteAll(Collection<T> beans) {
+    return db().deleteAll(beans);
+  }
+
+  /**
+   * 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 Database#deletePermanent(Object)
+   */
+  public boolean deletePermanent(T bean) {
+    return db().deletePermanent(bean);
+  }
+
+  /**
+   * Merge this entity using the default merge options.
+   * <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 Database#merge(Object)
+   */
+  public void merge(T bean) {
+    db().merge(bean);
+  }
+
+  /**
+   * Merge this entity using the specified merge options.
+   * <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 Database#merge(Object, MergeOptions)
+   */
+  public void merge(T bean, MergeOptions options) {
+    db().merge(bean, options);
+  }
+
+  /**
+   * Refreshes this entity from the database.
+   *
+   * @see Database#refresh(Object)
+   */
+  public void refresh(T bean) {
+    db().refresh(bean);
+  }
+}
@@ -1,5 +1,6 @@
 package io.ebean;

+import javax.annotation.Nullable;
 import java.util.Map;
 import java.util.Set;

@@ -56,7 +57,7 @@ public interface BeanState {
   *
   *   // set loaded state on the email property to false so that
   *   // the email property is not included in a stateless update
-   *   Ebean.getBeanState(user).setPropertyLoaded("email", false);
+   *   DB.getBeanState(user).setPropertyLoaded("email", false);
   *
   *   user.update();
   *
@@ -101,7 +102,7 @@ public interface BeanState {
  /**
   * Advanced - Used to programmatically build a partially or fully loaded
   * entity bean. First create an entity bean via
-   * {@link EbeanServer#createEntityBean(Class)}, then populate its properties
+   * {@link Database#createEntityBean(Class)}, then populate its properties
   * and then call this method specifying which properties where loaded or null
   * for a fully loaded entity bean.
   */
@@ -111,4 +112,10 @@ public interface BeanState {
   * Reset the bean putting it into NEW state such that a save() results in an insert.
   */
  void resetForInsert();
+
+  /**
+   * Returns a map with load erros.
+   */
+  @Nullable
+  Map<String, Exception> getLoadErrors();
 }
@@ -17,11 +17,11 @@ import java.sql.SQLException;
 *
 * String sql = "{call sp_order_mod(?,?)}";
 *
- * CallableSql cs = Ebean.createCallableSql(sql);
+ * CallableSql cs = DB.createCallableSql(sql);
 * cs.setParameter(1, "turbo");
 * cs.registerOut(2, Types.INTEGER);
 *
- * Ebean.execute(cs);
+ * DB.execute(cs);
 *
 * // read the out parameter
 * Integer returnValue = (Integer) cs.getObject(2);
@@ -38,7 +38,7 @@ import java.sql.SQLException;
 *
 * String sql = "{call sp_insert_order(?,?)}";
 *
- * CallableSql cs = Ebean.createCallableSql(sql);
+ * CallableSql cs = DB.createCallableSql(sql);
 *
 * // Inform Ebean this stored procedure inserts into the
 * // oe_order table and inserts + updates the oe_order_detail table.
@@ -46,35 +46,33 @@ import java.sql.SQLException;
 * cs.addModification("oe_order", true, false, false);
 * cs.addModification("oe_order_detail", true, true, false);
 *
- * Transaction t = Ebean.startTransaction();
 *
- * // execute using JDBC batching 10 statements at a time
- * t.setBatchMode(true);
- * t.setBatchSize(10);
- * try {
+ * try (Transaction t = DB.beginTransaction()) {
+ *
+ *   // execute using JDBC batching 10 statements at a time
+ *   t.setBatchMode(true);
+ *   t.setBatchSize(10);
+ *
 *   cs.setParameter(1, "Was");
 *   cs.setParameter(2, "Banana");
- *   Ebean.execute(cs);
+ *   DB.execute(cs);
 *
 *   cs.setParameter(1, "Here");
 *   cs.setParameter(2, "Kumera");
- *   Ebean.execute(cs);
+ *   DB.execute(cs);
 *
 *   cs.setParameter(1, "More");
 *   cs.setParameter(2, "Apple");
- *   Ebean.execute(cs);
+ *   DB.execute(cs);
 *
- *   // Ebean.externalModification("oe_order",true,false,false);
- *   // Ebean.externalModification("oe_order_detail",true,true,false);
- *   Ebean.commitTransaction();
+ *   // DB.externalModification("oe_order",true,false,false);
+ *   // DB.externalModification("oe_order_detail",true,true,false);
+ *   t.commit();
 *
- * } finally {
- *   Ebean.endTransaction();
 * }
 * }</pre>
 *
 * @see SqlUpdate
- * @see Ebean#execute(CallableSql)
 */
 public interface CallableSql {

@@ -173,7 +171,7 @@ public interface CallableSql {
   * Add table modification information to the TransactionEvent.
   * <p>
   * This would be similar to using the
-   * <code>Ebean.externalModification()</code> method. It may be easier and make
+   * <code>DB.externalModification()</code> method. It may be easier and make
   * more sense to set it here with the CallableSql.
   * </p>
   * <p>
@@ -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,
+}
@@ -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;
+  }
+  
+}
@@ -0,0 +1,67 @@
+package io.ebean;
+
+import io.ebean.config.ContainerConfig;
+import io.ebean.config.DatabaseConfig;
+
+/**
+ * Creates Database instances.
+ * <p>
+ * This uses either DatabaseConfig or properties in the application.properties file to
+ * configure and create a Database instance.
+ * </p>
+ * <p>
+ * The Database instance can either be registered with the DB singleton or
+ * not. The DB singleton effectively holds a map of Database by a name.
+ * If the Database is registered with the DB singleton you can retrieve it
+ * later via {@link DB#byName(String)}.
+ * </p>
+ * <p>
+ * One Database can be nominated as the 'default/primary' Database. Many
+ * methods on the DB singleton such as {@link DB#find(Class)} are just a
+ * convenient way of using the 'default/primary' Database.
+ * </p>
+ */
+public class DatabaseFactory {
+
+  /**
+   * Initialise the container with clustering configuration.
+   * <p>
+   * Call this prior to creating any Database instances or alternatively set the
+   * ContainerConfig on the ServerConfig when creating the first Database instance.
+   */
+  public static synchronized void initialiseContainer(ContainerConfig containerConfig) {
+    EbeanServerFactory.initialiseContainer(containerConfig);
+  }
+
+  /**
+   * Create using ebean.properties to configure the server.
+   */
+  public static synchronized Database create(String name) {
+    return EbeanServerFactory.create(name);
+  }
+
+  /**
+   * Create using the ServerConfig object to configure the server.
+   */
+  public static synchronized Database create(DatabaseConfig config) {
+    return EbeanServerFactory.create(config);
+  }
+
+  /**
+   * Create using the ServerConfig additionally specifying a classLoader to use as the context class loader.
+   */
+  public static synchronized Database createWithContextClassLoader(DatabaseConfig config, ClassLoader classLoader) {
+    return EbeanServerFactory.createWithContextClassLoader(config, classLoader);
+  }
+
+  /**
+   * Shutdown gracefully all Database instances cleaning up any resources as required.
+   * <p>
+   * This is typically invoked via JVM shutdown hook and not explicitly called.
+   * </p>
+   */
+  public static synchronized void shutdown() {
+    EbeanServerFactory.shutdown();
+  }
+
+}
@@ -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 =
+ *     DB.findDto(CustomerDto.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);
+
+}
@@ -2,126 +2,48 @@ package io.ebean;

 import io.ebean.annotation.TxIsolation;
 import io.ebean.cache.ServerCacheManager;
+import io.ebean.config.BeanNotEnhancedException;
 import io.ebean.config.ServerConfig;
+import io.ebean.datasource.DataSourceConfigurationException;
+import io.ebean.plugin.Property;
 import io.ebean.text.csv.CsvReader;
 import io.ebean.text.json.JsonContext;
-import 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;

 /**
- * This Ebean object is effectively a singleton that holds a map of registered
- * {@link EbeanServer}s. It additionally provides a convenient way to use the
- * 'default' EbeanServer.
+ * Ebean is a registry of {@link Database} by name. Ebean has now been renamed to {@link DB}.
 * <p>
- * If you are using a Dependency Injection framework such as
- * <strong>Spring</strong> or <strong>Guice</strong> you will probably
- * <strong>NOT</strong> use this Ebean singleton object. Instead you will
- * configure and construct EbeanServer instances using {@link ServerConfig} and
- * {@link EbeanServerFactory} and inject those EbeanServer instances into your
- * data access objects.
- * </p>
+ * Ebean is effectively this is an alias for {@link DB} which is the new and improved name for Ebean.
 * <p>
- * In documentation "Ebean singleton" refers to this object.
- * </p>
- * <ul>
- * <li>There is one EbeanServer per Database (javax.sql.DataSource).</li>
- * <li>EbeanServers can be 'registered' with the Ebean singleton (put into its
- * map). Registered EbeanServer's can later be retrieved via
- * {@link #getServer(String)}.</li>
- * <li>One EbeanServer can be referred to as the 'default' EbeanServer. For
- * convenience, the Ebean singleton (this object) provides methods such as
- * {@link #find(Class)} that proxy through to the 'default' EbeanServer. This
- * can be useful for applications that use a single database.</li>
- * </ul>
- * <p>
- * For developer convenience Ebean has static methods that proxy through to the
- * methods on the <em>'default'</em> EbeanServer. These methods are provided for
- * developers who are mostly using a single database. Many developers will be
- * able to use the methods on Ebean rather than get a EbeanServer.
- * </p>
- * <p>
- * EbeanServers can be created and used without ever needing or using the Ebean
- * singleton. Refer to {@link ServerConfig#setRegister(boolean)}.
- * </p>
- * <p>
- * You can either programmatically create/register EbeanServers via
- * {@link EbeanServerFactory} or they can automatically be created and
- * registered when you first use the Ebean singleton. When EbeanServers are
- * created automatically they are configured using information in the
- * ebean.properties file.
- * </p>
- * <pre>{@code
- *
- *   // fetch shipped orders (and also their customer)
- *   List<Order> list = Ebean.find(Order.class)
- * 	  .fetch("customer")
- * 	  .where()
- * 	  .eq("status.code", Order.Status.SHIPPED)
- * 	  .findList();
- *
- *   // read/use the order list ...
- *   for (Order order : list) {
- * 	   Customer customer = order.getCustomer();
- * 	   ...
- *   }
- *
- * }</pre>
- * <pre>{@code
- *
- *   // fetch order 10, modify and save
- *   Order order = Ebean.find(Order.class, 10);
- *
- *   OrderStatus shipped = Ebean.getReference(OrderStatus.class,"SHIPPED");
- *   order.setStatus(shipped);
- *   order.setShippedDate(shippedDate);
- *   ...
- *
- *   // implicitly creates a transaction and commits
- *   Ebean.save(order);
- *
- * }</pre>
- * <p>
- * When you have multiple databases and need access to a specific one the
- * {@link #getServer(String)} method provides access to the EbeanServer for that
- * specific database.
- * </p>
- * <pre>{@code
- *
- *   // Get access to the Human Resources EbeanServer/Database
- *   EbeanServer hrDb = Ebean.getServer("hr");
- *
- *   // fetch contact 3 from the HR database
- *   Contact contact = hrDb.find(Contact.class, 3);
- *
- *   contact.setName("I'm going to change");
- *   ...
- *
- *   // save the contact back to the HR database
- *   hrDb.save(contact);
- *
- * }</pre>
+ * The preference is to use DB and Database rather than Ebean and EbeanServer.
 */
 public final class Ebean {
  private static final Logger logger = LoggerFactory.getLogger(Ebean.class);

+  static {
+    EbeanVersion.getVersion(); // initialises the version class and logs the version.
+  }
+
  /**
-   * Manages creation and cache of EbeanServers.
+   * Manages creation and cache of Databases.
   */
  private static final Ebean.ServerManager serverMgr = new Ebean.ServerManager();

  /**
-   * Helper class for managing fast and safe access and creation of
-   * EbeanServers.
+   * Helper class for managing fast and safe access and creation of Databases.
   */
  private static final class ServerManager {

@@ -131,29 +53,21 @@ 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<>();

    private final Object monitor = new Object();

    /**
-     * The 'default' EbeanServer.
+     * The 'default' Database.
     */
    private EbeanServer defaultServer;

    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);
@@ -161,15 +75,24 @@ public final class Ebean {
            defaultServer = getWithCreate(defaultName.trim());
          }
        }
+      } catch (BeanNotEnhancedException e) {
+        throw e;
+
+      } catch (DataSourceConfigurationException e) {
+        String msg = "Configuration error creating DataSource for the default Database." +
+          " This typically means a missing application-test.yaml or missing ebean-test-config dependency." +
+          " See https://ebean.io/docs/trouble-shooting#datasource";
+        throw new DataSourceConfigurationException(msg, e);
+
      } catch (Throwable e) {
-        logger.error("Error trying to create the default EbeanServer", e);
+        logger.error("Error trying to create the default Database", e);
        throw new RuntimeException(e);
      }
    }

    private EbeanServer getDefaultServer() {
      if (defaultServer == null) {
-        String msg = "The default EbeanServer has not been defined?";
+        String msg = "The default Database has not been defined?";
        msg += " This is normally set via the ebean.datasource.default property.";
        msg += " Otherwise it should be registered programmatically via registerServer()";
        throw new PersistenceException(msg);
@@ -191,7 +114,7 @@ public final class Ebean {
    }

    /**
-     * Synchronized read, create and put of EbeanServers.
+     * Synchronized read, create and put of Databases.
     */
    private EbeanServer getWithCreate(String name) {

@@ -230,7 +153,7 @@ public final class Ebean {
  }

  /**
-   * Get the EbeanServer for a given DataSource. If name is null this will
+   * Get the Database for a given DataSource. If name is null this will
   * return the 'default' EbeanServer.
   * <p>
   * This is provided to access EbeanServer for databases other than the
@@ -376,7 +299,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
@@ -621,7 +544,8 @@ public final class Ebean {
   *   Customer customer = new Customer();
   *   customer.setId(7);
   *   customer.setName("ModifiedNameNoOCC");
-   *   ebeanServer.update(customer);
+   *
+   *   DB.update(customer);
   *
   * }</pre>
   *
@@ -639,6 +563,25 @@ public final class Ebean {
    serverMgr.getDefaultServer().updateAll(beans);
  }

+  /**
+   * Merge the bean using the default merge options.
+   *
+   * @param bean The bean to merge
+   */
+  public static void merge(Object bean) {
+    serverMgr.getDefaultServer().merge(bean);
+  }
+
+  /**
+   * 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 +589,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>
@@ -1043,10 +1045,9 @@ public final class Ebean {
   *
   *   String sql = "select c.id, c.name from customer c where c.name like ? order by c.name";
   *
-   *   Query<Customer> query = ebeanServer.findNative(Customer.class, sql);
-   *   query.setParameter(1, "Rob%");
-   *
-   *   List<Customer> customers = query.findList();
+   *   List<Customer> customers = DB.findNative(Customer.class, sql)
+   *     .setParameter(1, "Rob%")
+   *     .findList()
   *
   * }</pre>
   *
@@ -1058,6 +1059,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>
@@ -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());
    }

@@ -0,0 +1,44 @@
+package io.ebean;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+/**
+ * Class to determine the ebean version. (
+ * @author Roland Praml, FOCONIS AG
+ *
+ */
+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();
+      try (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;
+  }
+
+}
@@ -22,8 +22,8 @@ package io.ebean;
 * example.setName("Rob%");
 * example.setNotes("%something%");
 *
- * List&lt;Customer&gt; list =
- *     Ebean.find(Customer.class)
+ * List<Customer> list =
+ *     DB.find(Customer.class)
 *         .where()
 *         // pass the bean into the where() clause
 *         .exampleLike(example)
@@ -46,7 +46,7 @@ package io.ebean;
 *     .includeZeros();
 *
 * List<Customer> list =
- *     Ebean.find(Customer.class)
+ *     DB.find(Customer.class)
 *         .where()
 *         .add(qbe)
 *         .findList();
@@ -13,27 +13,15 @@ import java.util.Map;
 * {@link Query#where()}.
 * </p>
 * <p>
- * This provides a convenient way to create expressions for the 'Default'
- * server. It is actually a short cut for using the ExpressionFactory of the
- * 'default' EbeanServer.
+ * This provides a convenient way to create expressions for the default
+ * database.
 * <p>
- * See also {@link Ebean#getExpressionFactory()}
+ * See also {@link DB#getExpressionFactory()}
 * </p>
 * <p>
 * Creates standard common expressions for using in a Query Where or Having
 * clause.
 * </p>
- * <pre>{@code
- *
- * // Example: Using an Expr.or() method
- * Query<Order> query = Ebean.createQuery(Order.class);
- * query.where(
- *     Expr.or(Expr.eq("status", Order.NEW),
- *             Expr.gt("orderDate", lastWeek));
- *
- * List<Order> list = query.findList();
- * ...
- * }</pre>
 *
 * @see Query#where()
 */
@@ -64,11 +52,20 @@ public class Expr {
    return Ebean.getExpressionFactory().ieq(propertyName, value);
  }

+  /**
+   * In Range - property >= value1 and property < value2.
+   * <p>
+   * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
+   * </p>
+   */
+  public static Expression inRange(String propertyName, Object value1, Object value2) {
+    return Ebean.getExpressionFactory().inRange(propertyName, value1, value2);
+  }
+
  /**
   * Between - property between the two given values.
   */
  public static Expression between(String propertyName, Object value1, Object value2) {
-
    return Ebean.getExpressionFactory().between(propertyName, value1, value2);
  }

@@ -76,7 +73,6 @@ public class Expr {
   * Between - value between two given properties.
   */
  public static Expression between(String lowProperty, String highProperty, Object value) {
-
    return Ebean.getExpressionFactory().betweenProperties(lowProperty, highProperty, value);
  }

@@ -242,6 +238,43 @@ public class Expr {
    return Ebean.getExpressionFactory().in(propertyName, values);
  }

+  /**
+   * In where null or empty values means that no predicate is added to the query.
+   * <p>
+   * That is, only add the IN predicate if the values are not null or empty.
+   * <p>
+   * Without this we typically need to code an <code>if</code> block to only add
+   * the IN predicate if the collection is not empty like:
+   * </p>
+   *
+   * <h3>Without inOrEmpty()</h3>
+   * <pre>{@code
+   *
+   *   query.where() // add some predicates
+   *     .eq("status", Status.NEW);
+   *
+   *   if (ids != null && !ids.isEmpty()) {
+   *     query.where().in("customer.id", ids);
+   *   }
+   *
+   *   query.findList();
+   *
+   * }</pre>
+   *
+   * <h3>Using inOrEmpty()</h3>
+   * <pre>{@code
+   *
+   *   query.where()
+   *     .eq("status", Status.NEW)
+   *     .inOrEmpty("customer.id", ids)
+   *     .findList();
+   *
+   * }</pre>
+   */
+  public static Expression inOrEmpty(String propertyName, Collection<?> values) {
+    return Ebean.getExpressionFactory().inOrEmpty(propertyName, values);
+  }
+
  /**
   * Id Equal to - ID property is equal to the value.
   */
@@ -30,9 +30,9 @@ import java.util.Map;
 *     Expr.or(Expr.eq("status", Order.Status.NEW),
 *             Expr.gt("orderDate", lastWeek));
 *
- * Query<Order> query = Ebean.createQuery(Order.class);
- * query.where().add(newOrLastWeek);
- * List<Order> list = query.findList();
+ * List<Order> list = DB.find(Order.class)
+ *   .where().add(newOrLastWeek)
+ *   .findList();
 * ...
 * }</pre>
 *
@@ -122,6 +122,11 @@ public interface ExpressionFactory {
   */
  Expression eq(String propertyName, Object value);

+  /**
+   * Equal To or Null - property equal to the given value or null.
+   */
+  Expression eqOrNull(String propertyName, Object value);
+
  /**
   * Not Equal To - property not equal to the given value.
   */
@@ -133,11 +138,49 @@ public interface ExpressionFactory {
   */
  Expression ieq(String propertyName, String value);

+  /**
+   * Case Insensitive Not Equal To - property not equal to the given value (typically
+   * using a lower() function to make it case insensitive).
+   */
+  Expression ine(String propertyName, String value);
+
  /**
   * Case Insensitive Equal To that allows for named parameter use.
   */
  Expression ieqObject(String propertyName, Object value);

+  /**
+   * Case Insensitive Not Equal To that allows for named parameter use.
+   */
+  Expression ineObject(String propertyName, Object value);
+
+  /**
+   * In Range - property >= value1 and property < value2.
+   * <p>
+   * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
+   * </p>
+   */
+  Expression inRange(String propertyName, Object value1, Object value2);
+
+  /**
+   * Value in Range between 2 properties.
+   *
+   * <pre>{@code
+   *
+   *    .startDate.inRangeWith(endDate, now)
+   *
+   *    // which equates to
+   *    startDate <= now and (endDate > now or endDate is null)
+   *
+   * }</pre>
+   *
+   * <p>
+   * This is a convenience expression combining a number of simple expressions.
+   * The most common use of this could be called "effective dating" where 2 date or
+   * timestamp columns represent the date range in which
+   */
+  Expression inRangeWith(String lowProperty, String highProperty, Object value);
+
  /**
   * Between - property between the two given values.
   */
@@ -148,6 +191,14 @@ public interface ExpressionFactory {
   */
  Expression betweenProperties(String lowProperty, String highProperty, Object value);

+  /**
+   * Greater Than Or Null - property greater than the given value or null.
+   * <p>
+   * A convenient expression combining GT and Is Null.  Most often useful for range
+   * expressions where the top range value is nullable.
+   */
+  Expression gtOrNull(String propertyName, Object value);
+
  /**
   * Greater Than - property greater than the given value.
   */
@@ -159,6 +210,14 @@ public interface ExpressionFactory {
   */
  Expression ge(String propertyName, Object value);

+  /**
+   * Less Than or Null - property less than the given value or null.
+   * <p>
+   * A convenient expression combining LT and Is Null.  Most often useful for range
+   * expressions where the bottom range value is nullable.
+   */
+  Expression ltOrNull(String propertyName, Object value);
+
  /**
   * Less Than - property less than the given value.
   */
@@ -266,6 +325,41 @@ public interface ExpressionFactory {
   */
  Expression in(String propertyName, Collection<?> values);

+  /**
+   * In where null or empty values means that no predicate is added to the query.
+   * <p>
+   * That is, only add the IN predicate if the values are not null or empty.
+   * <p>
+   * Without this we typically need to code an <code>if</code> block to only add
+   * the IN predicate if the collection is not empty like:
+   * </p>
+   *
+   * <h3>Without inOrEmpty()</h3>
+   * <pre>{@code
+   *
+   *   query.where() // add some predicates
+   *     .eq("status", Status.NEW);
+   *
+   *   if (ids != null && !ids.isEmpty()) {
+   *     query.where().in("customer.id", ids);
+   *   }
+   *
+   *   query.findList();
+   *
+   * }</pre>
+   *
+   * <h3>Using inOrEmpty()</h3>
+   * <pre>{@code
+   *
+   *   query.where()
+   *     .eq("status", Status.NEW)
+   *     .inOrEmpty("customer.id", ids)
+   *     .findList();
+   *
+   * }</pre>
+   */
+  Expression inOrEmpty(String propertyName, Collection<?> values);
+
  /**
   * Not In - property has a value in the array of values.
   */
@@ -327,6 +421,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>
@@ -120,6 +120,46 @@ public interface ExpressionList<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);
+
+  /**
+   * Return the underlying query as an UpdateQuery.
+   * <p>
+   * Typically this is used with query beans to covert a query bean
+   * query into an UpdateQuery like the examples below.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  int rowsUpdated = new QCustomer()
+   *       .name.startsWith("Rob")
+   *       .asUpdate()
+   *       .set("active", false)
+   *       .update();;
+   *
+   * }</pre>
+   *
+   * <pre>{@code
+   *
+   *   int rowsUpdated = new QContact()
+   *       .notes.note.startsWith("Make Inactive")
+   *       .email.endsWith("@foo.com")
+   *       .customer.id.equalTo(42)
+   *       .asUpdate()
+   *       .set("inactive", true)
+   *       .setRaw("email = lower(email)")
+   *       .update();
+   *
+   * }</pre>
+   */
+  UpdateQuery<T> asUpdate();
+
  /**
   * Execute using "for update" clause which results in the DB locking the record.
   */
@@ -158,6 +198,18 @@ public interface ExpressionList<T> {
   */
  int delete();

+  /**
+   * Execute as a delete query deleting the 'root level' beans that match the predicates
+   * in the query.
+   * <p>
+   * Note that if the query includes joins then the generated delete statement may not be
+   * optimal depending on the database platform.
+   * </p>
+   *
+   * @return the number of rows that were deleted.
+   */
+  int delete(Transaction transaction);
+
  /**
   * Execute as a update query.
   *
@@ -166,6 +218,40 @@ public interface ExpressionList<T> {
   */
  int update();

+  /**
+   * Execute as a update query with the given transaction.
+   *
+   * @return the number of rows that were updated.
+   * @see UpdateQuery
+   */
+  int update(Transaction transaction);
+
+  /**
+   * Execute the query returning true if a row is found.
+   * <p>
+   * The query is executed using max rows of 1 and will only select the id property.
+   * This method is really just a convenient way to optimise a query to perform a
+   * 'does a row exist in the db' check.
+   * </p>
+   *
+   * <h2>Example:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = query().where().eq("email", "rob@foo.com").exists();
+   *
+   * }</pre>
+   *
+   * <h2>Example using a query bean:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = new QContact().email.equalTo("rob@foo.com").exists();
+   *
+   * }</pre>
+   *
+   * @return True if the query finds a matching row in the database
+   */
+  boolean exists();
+
  /**
   * Execute the query iterating over the results.
   *
@@ -230,23 +316,23 @@ public interface ExpressionList<T> {

  /**
   * Execute the query returning a list of values for a single property.
-   * <p>
+   *
   * <h3>Example 1:</h3>
   * <pre>{@code
   *
   *  List<String> names =
-   *    Ebean.find(Customer.class)
+   *    DB.find(Customer.class)
   *      .select("name")
   *      .orderBy().asc("name")
   *      .findSingleAttributeList();
   *
   * }</pre>
-   * <p>
+   *
   * <h3>Example 2:</h3>
   * <pre>{@code
   *
   *  List<String> names =
-   *    Ebean.find(Customer.class)
+   *    DB.find(Customer.class)
   *      .setDistinct(true)
   *      .select("name")
   *      .where().eq("status", Customer.Status.NEW)
@@ -263,11 +349,10 @@ public interface ExpressionList<T> {

  /**
   * Execute a query returning a single value of a single property/column.
-   * <p>
   * <pre>{@code
   *
   *  String name =
-   *    Ebean.find(Customer.class)
+   *    DB.find(Customer.class)
   *      .select("name")
   *      .where().eq("id", 42)
   *      .findSingleAttribute();
@@ -348,10 +433,9 @@ public interface ExpressionList<T> {
   * If maxRows is not set on the query prior to calling findPagedList() then a
   * PersistenceException is thrown.
   * </p>
-   * <p>
   * <pre>{@code
   *
-   *  PagedList<Order> pagedList = Ebean.find(Order.class)
+   *  PagedList<Order> pagedList = DB.find(Order.class)
   *       .setFirstRow(50)
   *       .setMaxRows(20)
   *       .findPagedList();
@@ -404,6 +488,11 @@ public interface ExpressionList<T> {
   */
  Query<T> select(String properties);

+  /**
+   * Apply the fetchGroup which defines what part of the object graph to load.
+   */
+  Query<T> select(FetchGroup<T> fetchGroup);
+
  /**
   * Set whether this query uses DISTINCT.
   * <p>
@@ -413,7 +502,7 @@ public interface ExpressionList<T> {
   * <pre>{@code
   *
   *   List<Customer> customers =
-   *       Ebean.find(Customer.class)
+   *       DB.find(Customer.class)
   *          .setDistinct(true)
   *          .select("name")     // only select the customer name
   *          .findList();
@@ -480,6 +569,35 @@ public interface ExpressionList<T> {
   */
  Query<T> setUseQueryCache(CacheMode useCache);

+  /**
+   * Extended version for setDistinct in conjunction with "findSingleAttributeList";
+   * <pre>{@code
+   *
+   *  List<CountedValue<Order.Status>> orderStatusCount =
+   *
+   *     DB.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 +633,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>
@@ -557,7 +680,6 @@ public interface ExpressionList<T> {

  /**
   * Equal to expression for the value at the given path in the JSON document.
-   * <p>
   * <pre>{@code
   *
   *   where().jsonEqualTo("content", "path.other", 34)
@@ -572,7 +694,6 @@ public interface ExpressionList<T> {

  /**
   * Not Equal to - for the given path in a JSON document.
-   * <p>
   * <pre>{@code
   *
   *   where().jsonNotEqualTo("content", "path.other", 34)
@@ -587,7 +708,6 @@ public interface ExpressionList<T> {

  /**
   * Greater than - for the given path in a JSON document.
-   * <p>
   * <pre>{@code
   *
   *   where().jsonGreaterThan("content", "path.other", 34)
@@ -598,7 +718,6 @@ public interface ExpressionList<T> {

  /**
   * Greater than or equal to - for the given path in a JSON document.
-   * <p>
   * <pre>{@code
   *
   *   where().jsonGreaterOrEqual("content", "path.other", 34)
@@ -609,7 +728,6 @@ public interface ExpressionList<T> {

  /**
   * Less than - for the given path in a JSON document.
-   * <p>
   * <pre>{@code
   *
   *   where().jsonLessThan("content", "path.other", 34)
@@ -620,7 +738,6 @@ public interface ExpressionList<T> {

  /**
   * Less than or equal to - for the given path in a JSON document.
-   * <p>
   * <pre>{@code
   *
   *   where().jsonLessOrEqualTo("content", "path.other", 34)
@@ -631,7 +748,6 @@ public interface ExpressionList<T> {

  /**
   * Between - for the given path in a JSON document.
-   * <p>
   * <pre>{@code
   *
   *   where().jsonBetween("content", "orderDate", lowerDateTime, upperDateTime)
@@ -642,21 +758,6 @@ public interface ExpressionList<T> {

  /**
   * Add an Expression to the list.
-   * <p>
-   * This returns the list so that add() can be chained.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   * Query<Customer> query = Ebean.find(Customer.class);
-   * query.where()
-   *     .like("name","Rob%")
-   *     .eq("status", Customer.ACTIVE);
-   *
-   * List<Customer> list = query.findList();
-   * ...
-   *
-   * }</pre>
   */
  ExpressionList<T> add(Expression expr);

@@ -670,6 +771,11 @@ public interface ExpressionList<T> {
   */
  ExpressionList<T> eq(String propertyName, Object value);

+  /**
+   * Equal To or Null - property is equal to a given value or null.
+   */
+  ExpressionList<T> eqOrNull(String propertyName, Object value);
+
  /**
   * Not Equal To - property not equal to the given value.
   */
@@ -682,8 +788,41 @@ public interface ExpressionList<T> {
  ExpressionList<T> ieq(String propertyName, String value);

  /**
-   * Between - property between the two given values.
+   * Case Insensitive Not Equal To - property not equal to the given value (typically
+   * using a lower() function to make it case insensitive).
   */
+  ExpressionList<T> ine(String propertyName, String value);
+
+  /**
+   * Value in Range between 2 properties.
+   *
+   * <pre>{@code
+   *
+   *    .startDate.inRangeWith(endDate, now)
+   *
+   *    // which equates to
+   *    startDate <= now and (endDate > now or endDate is null)
+   *
+   * }</pre>
+   *
+   * <p>
+   * This is a convenience expression combining a number of simple expressions.
+   * The most common use of this could be called "effective dating" where 2 date or
+   * timestamp columns represent the date range in which
+   */
+  ExpressionList<T> inRangeWith(String lowProperty, String highProperty, Object value);
+
+  /**
+   * In Range - property >= value1 and property < value2.
+   * <p>
+   * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
+   * </p>
+   */
+  ExpressionList<T> inRange(String propertyName, Object value1, Object value2);
+
+    /**
+     * Between - property between the two given values.
+     */
  ExpressionList<T> between(String propertyName, Object value1, Object value2);

  /**
@@ -696,6 +835,11 @@ public interface ExpressionList<T> {
   */
  ExpressionList<T> gt(String propertyName, Object value);

+  /**
+   * Greater Than or Null - property greater than the given value or null.
+   */
+  ExpressionList<T> gtOrNull(String propertyName, Object value);
+
  /**
   * Greater Than or Equal to - property greater than or equal to the given
   * value.
@@ -707,6 +851,11 @@ public interface ExpressionList<T> {
   */
  ExpressionList<T> lt(String propertyName, Object value);

+  /**
+   * Less Than or Null - property less than the given value or null.
+   */
+  ExpressionList<T> ltOrNull(String propertyName, Object value);
+
  /**
   * Less Than or Equal to - property less than or equal to the given value.
   */
@@ -736,7 +885,6 @@ public interface ExpressionList<T> {
   * To get control over the options you can create an ExampleExpression and set
   * those options such as case insensitive etc.
   * </p>
-   * <p>
   * <pre>{@code
   *
   * // create an example bean and set the properties
@@ -745,16 +893,15 @@ public interface ExpressionList<T> {
   * example.setName("Rob%");
   * example.setNotes("%something%");
   *
-   * List&lt;Customer&gt; list = Ebean.find(Customer.class).where()
-   *     // pass the bean into the where() clause
-   *     .exampleLike(example)
-   *     // you can add other expressions to the same query
-   *     .gt("id", 2).findList();
+   * List<Customer> list =
+   *   DB.find(Customer.class)
+   *     .where().exampleLike(example)
+   *     .findList();
   *
   * }</pre>
   * <p>
   * Similarly you can create an ExampleExpression
-   * <p>
+   * </p>
   * <pre>{@code
   *
   * Customer example = new Customer();
@@ -764,7 +911,7 @@ public interface ExpressionList<T> {
   * // create a ExampleExpression with more control
   * ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO).includeZeros();
   *
-   * List<Customer> list = Ebean.find(Customer.class).where().add(qbe).findList();
+   * List<Customer> list = DB.find(Customer.class).where().add(qbe).findList();
   *
   * }</pre>
   */
@@ -842,8 +989,43 @@ public interface ExpressionList<T> {
  ExpressionList<T> in(String propertyName, Collection<?> values);

  /**
-   * In - using a subQuery.
+   * In where null or empty values means that no predicate is added to the query.
+   * <p>
+   * That is, only add the IN predicate if the values are not null or empty.
+   * <p>
+   * Without this we typically need to code an <code>if</code> block to only add
+   * the IN predicate if the collection is not empty like:
+   * </p>
   *
+   * <h3>Without inOrEmpty()</h3>
+   * <pre>{@code
+   *
+   *   query.where() // add some predicates
+   *     .eq("status", Status.NEW);
+   *
+   *   if (ids != null && !ids.isEmpty()) {
+   *     query.where().in("customer.id", ids);
+   *   }
+   *
+   *   query.findList();
+   *
+   * }</pre>
+   *
+   * <h3>Using inOrEmpty()</h3>
+   * <pre>{@code
+   *
+   *   query.where()
+   *     .eq("status", Status.NEW)
+   *     .inOrEmpty("customer.id", ids)
+   *     .findList();
+   *
+   * }</pre>
+   */
+  ExpressionList<T> inOrEmpty(String propertyName, Collection<?> values);
+
+  /**
+   * 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 +1035,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 +1045,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 +1143,65 @@ 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.
+   * <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 expression for the given bit flags to be NOT set.
+   * <pre>{@code
+   *
+   * where().bitwiseNot("flags", BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseNot(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>
@@ -980,6 +1221,13 @@ public interface ExpressionList<T> {
   *   raw("add_days(orderDate, 10) < ?", someDate)
   *
   * }</pre>
+   *
+   * <h4>Subquery example:</h4>
+   * <pre>{@code
+   *
+   *   .raw("t0.customer_id in (select customer_id from customer_group where group_id = any(?::uuid[]))", groupIds)
+   *
+   * }</pre>
   */
  ExpressionList<T> raw(String raw, Object value);

@@ -1004,15 +1252,83 @@ public interface ExpressionList<T> {
   * then they are not translated. logical property name names (not fully
   * qualified) will still be translated to their physical name.
   * </p>
-   * <p>
   * <pre>{@code
   *
   *   raw("orderQty < shipQty")
   *
   * }</pre>
+   *
+   * <h4>Subquery example:</h4>
+   * <pre>{@code
+   *
+   *   .raw("t0.customer_id in (select customer_id from customer_group where group_id = any(?::uuid[]))", groupIds)
+   *
+   * }</pre>
   */
  ExpressionList<T> raw(String raw);

+  /**
+   * Only add the raw expression if the values is not null or empty.
+   * <p>
+   * This is a pure convenience expression to make it nicer to deal with the pattern where we use
+   * raw() expression with a subquery and only want to add the subquery predicate when the collection
+   * of values is not empty.
+   * </p>
+   * <h3>Without inOrEmpty()</h3>
+   * <pre>{@code
+   *
+   *   query.where() // add some predicates
+   *     .eq("status", Status.NEW);
+   *
+   *   // common pattern - we can use rawOrEmpty() instead
+   *   if (orderIds != null && !orderIds.isEmpty()) {
+   *     query.where().raw("t0.customer_id in (select o.customer_id from orders o where o.id in (?1))", orderIds);
+   *   }
+   *
+   *   query.findList();
+   *
+   * }</pre>
+   *
+   * <h3>Using rawOrEmpty()</h3>
+   * Note that in the example below we use the <code>?1</code> bind parameter to get  "parameter expansion"
+   * for each element in the collection.
+   *
+   * <pre>{@code
+   *
+   *   query.where()
+   *     .eq("status", Status.NEW)
+   *     // only add the expression if orderIds is not empty
+   *     .rawOrEmpty("t0.customer_id in (select o.customer_id from orders o where o.id in (?1))", orderIds);
+   *     .findList();
+   *
+   * }</pre>
+   *
+   * <h3>Postgres ANY</h3>
+   * With Postgres we would often use the SQL <code>ANY</code> expression and array parameter binding
+   * rather than <code>IN</code>.
+   *
+   * <pre>{@code
+   *
+   *   query.where()
+   *     .eq("status", Status.NEW)
+   *     .rawOrEmpty("t0.customer_id in (select o.customer_id from orders o where o.id = any(?))", orderIds);
+   *     .findList();
+   *
+   * }</pre>
+   * <p>
+   *   Note that we need to cast the Postgres array for UUID types like:
+   * </p>
+   * <pre>{@code
+   *
+   *   " ... = any(?::uuid[])"
+   *
+   * }</pre>
+   *
+   * @param raw The raw expression that is typically a subquery
+   * @param values The values which is typically a list or set of id values.
+   */
+  ExpressionList<T> rawOrEmpty(String raw, Collection<?> values);
+
  /**
   * Add a match expression.
   *
@@ -1083,12 +1399,10 @@ public interface ExpressionList<T> {
   * typically you only explicitly need to use the and() junction
   * when it is nested inside an or() or not() junction.
   * </p>
-   * <p>
   * <pre>{@code
   *
   *  // Example: Nested and()
   *
-   *  Ebean.find(Customer.class)
   *    .where()
   *    .or()
   *      .and() // nested and
@@ -1109,16 +1423,27 @@ public interface ExpressionList<T> {
   * Return a list of expressions that will be joined by OR's.
   * This is exactly the same as disjunction();
   * <p>
-   * <p>
   * Use endOr() or endJunction() to end the OR junction.
   * </p>
-   * <p>
+   *
+   * <pre>{@code
+   *
+   *  // Example: (status active OR anniversary is null)
+   *
+   *    .where()
+   *    .or()
+   *      .eq("status", Customer.Status.ACTIVE)
+   *      .isNull("anniversary")
+   *    .orderBy().asc("name")
+   *    .findList();
+   *
+   * }</pre>
+   *
   * <pre>{@code
   *
   *  // Example: Use or() to join
   *  // two nested and() expressions
   *
-   *  Ebean.find(Customer.class)
   *    .where()
   *    .or()
   *      .and()
@@ -1142,8 +1467,8 @@ public interface ExpressionList<T> {
   * Use endNot() or endJunction() to end expressions being added to the
   * NOT expression list.
   * </p>
-   * <p>
-   * <pre>@{code
+   *
+   * <pre>{@code
   *
   *    .where()
   *      .not()
@@ -1152,12 +1477,11 @@ public interface ExpressionList<T> {
   *        .endNot()
   *
   * }</pre>
-   * <p>
-   * <pre>@{code
+   *
+   * <pre>{@code
   *
   * // Example: nested not()
   *
-   * Ebean.find(Customer.class)
   *   .where()
   *     .eq("status", Customer.Status.ACTIVE)
   *     .not()
@@ -0,0 +1,479 @@
+package io.ebean;
+
+import io.ebeaninternal.api.SpiQuery;
+import io.ebeaninternal.api.SpiTransaction;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.persistence.NonUniqueResultException;
+import java.time.Clock;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * The extended API for Database.
+ * <p>
+ * This provides the finder methods that take an explicit transaction rather than obtaining
+ * the transaction from the usual mechanism (which is ThreadLocal based).
+ * </p>
+ * <p>
+ * In general we only want to use this ExtendedServer API when we want to avoid / bypass
+ * the use of the mechanism to get the current transaction and instead explicitly supply
+ * the transaction to use.
+ * </p>
+ * <p>
+ * Note that in all cases the transaction supplied can be null and in this case the Database
+ * will use the normal mechanism to obtain the transaction to use.
+ * </p>
+ */
+public interface ExtendedServer {
+
+  /**
+   * Return the NOW time from the Clock.
+   */
+  long clockNow();
+
+  /**
+   * Set the Clock to use for <code>@WhenCreated</code> and <code>@WhenModified</code>.
+   * <p>
+   * Note that we only expect to change the Clock for testing purposes.
+   * </p>
+   */
+  void setClock(Clock clock);
+
+  /**
+   * Execute the query returning true if a row is found.
+   * <p>
+   * The query is executed using max rows of 1 and will only select the id property.
+   * This method is really just a convenient way to optimise a query to perform a
+   * 'does a row exist in the db' check.
+   * </p>
+   *
+   * <h2>Example:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = query().where().eq("email", "rob@foo.com").exists();
+   *
+   * }</pre>
+   *
+   * <h2>Example using a query bean:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = new QContact().email.equalTo("rob@foo.com").exists();
+   *
+   * }</pre>
+   *
+   * @return True if the query finds a matching row in the database
+   */
+  <T> boolean exists(SpiQuery<?> ormQuery, SpiTransaction transaction);
+
+  /**
+   * Return the number of 'top level' or 'root' entities this query should return.
+   *
+   * @see Query#findCount()
+   * @see Query#findFutureCount()
+   */
+  <T> int findCount(Query<T> query, Transaction transaction);
+
+  /**
+   * Return the Id values of the query as a List.
+   *
+   * @see Query#findIds()
+   */
+  @Nonnull
+  <A, T> List<A> findIds(Query<T> query, Transaction transaction);
+
+  /**
+   * Return a QueryIterator for the query.
+   * <p>
+   * Generally using {@link #findEach(Query, Consumer, Transaction)} or
+   * {@link #findEachWhile(Query, Predicate, Transaction)} is preferred
+   * to findIterate(). The reason is that those methods automatically take care of
+   * closing the queryIterator (and the underlying jdbc statement and resultSet).
+   * </p>
+   * <p>
+   * This is similar to findEach in that not all the result beans need to be held
+   * in memory at the same time and as such is good for processing large queries.
+   * </p>
+   *
+   * @see Query#findIterate()
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  @Nonnull
+  <T> QueryIterator<T> findIterate(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query visiting the each bean one at a time.
+   * <p>
+   * Unlike findList() this is suitable for processing a query that will return
+   * a very large resultSet. The reason is that not all the result beans need to be
+   * held in memory at the same time and instead processed one at a time.
+   * </p>
+   * <p>
+   * Internally this query using a PersistenceContext scoped to each bean (and the
+   * beans associated object graph).
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *     DB.find(Order.class)
+   *       .where().eq("status", Order.Status.NEW)
+   *       .order().asc("id")
+   *       .findEach((Order order) -> {
+   *
+   *         // do something with the order bean
+   *         System.out.println(" -- processing order ... " + order);
+   *       });
+   *
+   * }</pre>
+   *
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  <T> void findEach(Query<T> query, Consumer<T> consumer, Transaction transaction);
+
+  /**
+   * Execute the query visiting the each bean one at a time.
+   * <p>
+   * Compared to findEach() this provides the ability to stop processing the query
+   * results early by returning false for the Predicate.
+   * </p>
+   * <p>
+   * Unlike findList() this is suitable for processing a query that will return
+   * a very large resultSet. The reason is that not all the result beans need to be
+   * held in memory at the same time and instead processed one at a time.
+   * </p>
+   * <p>
+   * Internally this query using a PersistenceContext scoped to each bean (and the
+   * beans associated object graph).
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *     DB.find(Order.class)
+   *       .where().eq("status", Order.Status.NEW)
+   *       .order().asc("id")
+   *       .findEachWhile((Order order) -> {
+   *
+   *         // do something with the order bean
+   *         System.out.println(" -- processing order ... " + order);
+   *
+   *         boolean carryOnProcessing = ...
+   *         return carryOnProcessing;
+   *       });
+   *
+   * }</pre>
+   *
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  <T> void findEachWhile(Query<T> query, Predicate<T> consumer, Transaction transaction);
+
+  /**
+   * Return versions of a @History entity bean.
+   * <p>
+   * Generally this query is expected to be a find by id or unique predicates query.
+   * It will execute the query against the history returning the versions of the bean.
+   * </p>
+   */
+  @Nonnull
+  <T> List<Version<T>> findVersions(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute a query returning a list of beans.
+   * <p>
+   * Generally you are able to use {@link Query#findList()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   * List<Customer> customers = DB.find(Customer.class)
+   *     .where().ilike("name", "rob%")
+   *     .findList();
+   *
+   * }</pre>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched beans.
+   * @see Query#findList()
+   */
+  @Nonnull
+  <T> List<T> findList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find row count query in a background thread.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a
+   * timeout).
+   * </p>
+   *
+   * @param query       the query to execute the row count on
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the row count query
+   * @see Query#findFutureCount()
+   */
+  @Nonnull
+  <T> FutureRowCount<T> findFutureCount(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find Id's query in a background thread.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a
+   * timeout).
+   * </p>
+   *
+   * @param query       the query to execute the fetch Id's on
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the list of Id's
+   * @see Query#findFutureIds()
+   */
+  @Nonnull
+  <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find list query in a background thread returning a FutureList object.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a timeout).
+   * <p>
+   * This query will execute in it's own PersistenceContext and using its own transaction.
+   * What that means is that it will not share any bean instances with other queries.
+   *
+   * @param query       the query to execute in the background
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the list result of the query
+   * @see Query#findFutureList()
+   */
+  @Nonnull
+  <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction);
+
+  /**
+   * Return a PagedList for this query using firstRow and maxRows.
+   * <p>
+   * The benefit of using this over findList() is that it provides functionality to get the
+   * total row count etc.
+   * </p>
+   * <p>
+   * If maxRows is not set on the query prior to calling findPagedList() then a
+   * PersistenceException is thrown.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *  PagedList<Order> pagedList = DB.find(Order.class)
+   *       .setFirstRow(50)
+   *       .setMaxRows(20)
+   *       .findPagedList();
+   *
+   *       // fetch the total row count in the background
+   *       pagedList.loadRowCount();
+   *
+   *       List<Order> orders = pagedList.getList();
+   *       int totalRowCount = pagedList.getTotalRowCount();
+   *
+   * }</pre>
+   *
+   * @return The PagedList
+   * @see Query#findPagedList()
+   */
+  @Nonnull
+  <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning a set of entity beans.
+   * <p>
+   * Generally you are able to use {@link Query#findSet()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   * Set<Customer> customers = DB.find(Customer.class)
+   *     .where().ilike("name", "rob%")
+   *     .findSet();
+   *
+   * }</pre>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute
+   * @param transaction the transaction to use (can be null).
+   * @return the set of fetched beans.
+   * @see Query#findSet()
+   */
+  @Nonnull
+  <T> Set<T> findSet(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning the entity beans in a Map.
+   * <p>
+   * Generally you are able to use {@link Query#findMap()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the map of fetched beans.
+   * @see Query#findMap()
+   */
+  @Nonnull
+  <K, T> Map<K, T> findMap(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning a list of values for a single property.
+   * <p>
+   * <h3>Example 1:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    DB.find(Customer.class)
+   *      .select("name")
+   *      .orderBy().asc("name")
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   * <h3>Example 2:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    DB.find(Customer.class)
+   *      .setDistinct(true)
+   *      .select("name")
+   *      .where().eq("status", Customer.Status.NEW)
+   *      .orderBy().asc("name")
+   *      .setMaxRows(100)
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   *
+   * @return the list of values for the selected property
+   * @see Query#findSingleAttributeList()
+   */
+  @Nonnull
+  <A, T> List<A> findSingleAttributeList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning at most one entity bean or null (if no matching
+   * bean is found).
+   * <p>
+   * This will throw a NonUniqueResultException if the query finds more than one result.
+   * </p>
+   * <p>
+   * Generally you are able to use {@link Query#findOne()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched beans.
+   * @throws NonUniqueResultException if more than one result was found
+   * @see Query#findOne()
+   */
+  @Nullable
+  <T> T findOne(Query<T> query, Transaction transaction);
+
+  /**
+   * Similar to findOne() but returns an Optional (rather than nullable).
+   */
+  @Nonnull
+  <T> Optional<T> findOneOrEmpty(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute as a delete query deleting the 'root level' beans that match the predicates
+   * in the query.
+   * <p>
+   * Note that if the query includes joins then the generated delete statement may not be
+   * optimal depending on the database platform.
+   * </p>
+   *
+   * @param query       the query used for the delete
+   * @param transaction the transaction to use (can be null)
+   * @param <T>         the type of entity bean to fetch.
+   * @return the number of beans/rows that were deleted
+   */
+  <T> int delete(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the update query returning the number of rows updated.
+   * <p>
+   * The update query must be created using {@link Database#update(Class)}.
+   * </p>
+   *
+   * @param query       the update query to execute
+   * @param transaction the optional transaction to use for the update (can be null)
+   * @param <T>         the type of entity bean
+   * @return The number of rows updated
+   */
+  <T> int update(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the sql query returning a list of MapBean.
+   * <p>
+   * Generally you are able to use {@link SqlQuery#findList()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched MapBean.
+   * @see SqlQuery#findList()
+   */
+  @Nonnull
+  List<SqlRow> findList(SqlQuery query, Transaction transaction);
+
+  /**
+   * Execute the SqlQuery 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(SqlQuery query, Consumer<SqlRow> consumer, Transaction transaction);
+
+  /**
+   * Execute the SqlQuery 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(SqlQuery query, Predicate<SqlRow> consumer, Transaction transaction);
+
+  /**
+   * Execute the sql query returning a single MapBean or null.
+   * <p>
+   * This will throw a PersistenceException if the query found more than one
+   * result.
+   * </p>
+   * <p>
+   * Generally you are able to use {@link SqlQuery#findOne()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the fetched MapBean or null if none was found.
+   * @see SqlQuery#findOne()
+   */
+  @Nullable
+  SqlRow findOne(SqlQuery query, Transaction transaction);
+
+}
@@ -24,7 +24,7 @@ import java.io.Serializable;
 * <p>
 * <pre>{@code
 * // Normal fetch join results in a single SQL query
- * List<Order> list = Ebean.find(Order.class).fetch("details").findList();
+ * List<Order> list = DB.find(Order.class).fetch("details").findList();
 *
 * // Find Orders join details using a single SQL query
 * }</pre>
@@ -36,7 +36,7 @@ import java.io.Serializable;
 *
 * // This will use 2 SQL queries to build this object graph
 * List<Order> list =
- *     Ebean.find(Order.class)
+ *     DB.find(Order.class)
 *         .fetch("details", new FetchConfig().query())
 *         .findList();
 *
@@ -52,7 +52,7 @@ import java.io.Serializable;
 *
 * // This will use 3 SQL queries to build this object graph
 * List<Order> list =
- *     Ebean.find(Order.class)
+ *     DB.find(Order.class)
 *         .fetch("details", new FetchConfig().query())
 *         .fetch("customer", new FetchConfig().queryFirst(5))
 *         .findList();
@@ -70,7 +70,7 @@ import java.io.Serializable;
 * <pre>{@code
 * // This will use 3 SQL queries to build this object graph
 * List<Order> list =
- *     Ebean.find(Order.class)
+ *     DB.find(Order.class)
 *         .select("status, shipDate")
 *         .fetch("details", "quantity, price", new FetchConfig().query())
 *         .fetch("details.product", "sku, name")
@@ -100,7 +100,7 @@ import java.io.Serializable;
 * <pre>{@code
 *
 * List<Order> list =
- *     Ebean.find(Order.class)
+ *     DB.find(Order.class)
 *         .fetch("customer", new FetchConfig().query(10).lazy(5))
 *         .findList();
 *
@@ -121,7 +121,7 @@ import java.io.Serializable;
 * <p>
 * <pre>{@code
 *
- * List<Order> list = Ebean.find(Order.class)
+ * List<Order> list = DB.find(Order.class)
 *   .fetch("customer","name", new FetchConfig().lazy(5))
 *   .fetch("customer.contacts","contactName, phone, email")
 *   .fetch("customer.shippingAddress")
@@ -0,0 +1,114 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Defines what part of the object graph to load (select and fetch clauses).
+ * <p>
+ * Using a FetchGroup effectively sets the select() and fetch() clauses for a query. It is alternative
+ * to specifying the select() and fetch() clauses on the query allowing for more re-use of "what to load"
+ * that can be defined separately from the query and combined with other FetchGroups.
+ * </p>
+ *
+ * <h3>Select example</h3>
+ * <pre>{@code
+ *
+ * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class, "name, status");
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .findList();
+ *
+ * }</pre>
+ *
+ * <h3>Select and fetch example</h3>
+ * <pre>{@code
+ *
+ * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class)
+ *   .select("name, status")
+ *   .fetch("contacts", "firstName, lastName, email")
+ *   .build();
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .findList();
+ *
+ * }</pre>
+ *
+ * <h3>Combining FetchGroups</h3>
+ * <p>
+ *   FetchGroups can be combined together to form another FetchGroup.
+ * </p>
+ * <pre>{@code
+ *
+ *  FetchGroup<Address> FG_ADDRESS = FetchGroup.of(Address.class)
+ *    .select("line1, line2, city")
+ *    .fetch("country", "name")
+ *    .build();
+ *
+ *  FetchGroup<Customer> FG_CUSTOMER = FetchGroup.of(Customer.class)
+ *    .select("name, version")
+ *    .fetch("billingAddress", FG_ADDRESS)
+ *    .build();
+ *
+ *
+ *  Customer.query()
+ *    .select(FG_CUSTOMER)
+ *    .findList();
+ *
+ * }</pre>
+ *
+ * @param <T> The bean type the Fetch group can be applied to
+ */
+public interface FetchGroup<T> {
+
+  /**
+   * Return the FetchGroup with the given select clause.
+   * <p>
+   *   We use this for simple FetchGroup that only select() properties and do not have additional fetch() clause.
+   * </p>
+   * <pre>{@code
+   *
+   * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class, "name, status");
+   *
+   * Customer.query()
+   *   .select(fetchGroup)
+   *   .findList();
+   *
+   * }</pre>
+   *
+   * @param select The select clause of the FetchGroup
+   *
+   * @return The FetchGroup with the given select clause
+   */
+  @Nonnull
+  static <T> FetchGroup<T> of(Class<T> cls, String select) {
+    return XServiceProvider.fetchGroupOf(cls, select);
+  }
+
+  /**
+   * Return the FetchGroupBuilder with the given select clause that we can add fetch clauses to.
+   * <p>
+   * We chain select() with one or more fetch() clauses to define the object graph to load.
+   * </p>
+   * <pre>{@code
+   *
+   * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class)
+   *   .select("name, status")
+   *   .fetch("contacts", "firstName, lastName, email")
+   *   .build();
+   *
+   * Customer.query()
+   *   .select(fetchGroup)
+   *   .findList();
+   *
+   * }</pre>
+   *
+   * @return The FetchGroupBuilder with the given select clause which we will add fetch clauses to
+   */
+  @Nonnull
+  static <T> FetchGroupBuilder<T> of(Class<T> cls) {
+    return XServiceProvider.fetchGroupOf(cls);
+  }
+
+}
@@ -0,0 +1,93 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Builds a FetchGroup by adding fetch clauses.
+ * <p>
+ * We add select() and fetch() clauses to define the object graph we want to load.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ * FetchGroup fetchGroup = FetchGroup
+ *   .select("name, status")
+ *   .fetch("contacts", "firstName, lastName, email")
+ *   .build();
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .where()
+ *   ...
+ *   .findList();
+ *
+ * }</pre>
+ */
+public interface FetchGroupBuilder<T> {
+
+  /**
+   * Specify specific properties to select (top level properties).
+   */
+  @Nonnull
+  FetchGroupBuilder<T> select(String select);
+
+  /**
+   * Fetch all the properties at the given path.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path);
+
+  /**
+   * Fetch the path with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path using a query join with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path lazily with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path including specified properties.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path, String properties);
+
+  /**
+   * Fetch the path including all its properties using a query join.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path);
+
+  /**
+   * Fetch the path including specified properties using a query join.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path, String properties);
+
+  /**
+   * Fetch the path including all its properties lazily.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path);
+
+  /**
+   * Fetch the path including specified properties lazily.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path, String properties);
+
+  /**
+   * Build and return the FetchGroup.
+   */
+  @Nonnull
+  FetchGroup<T> build();
+}
@@ -25,14 +25,14 @@ import java.util.Set;
 * // get a list of entities (query execution statistics in this case)
 *
 * List<MetaQueryStatistic> list =
- *     Ebean.find(MetaQueryStatistic.class).findList();
+ *     DB.find(MetaQueryStatistic.class).findList();
 *
 * long nowMinus24Hrs = System.currentTimeMillis() - 24 * (1000 * 60 * 60);
 *
 * // sort and filter the list returning a filtered list...
 *
 * List<MetaQueryStatistic> filteredList =
- *     Ebean.filter(MetaQueryStatistic.class)
+ *     DB.filter(MetaQueryStatistic.class)
 *         .sort("avgTimeMicros desc")
 *         .gt("executionCount", 0)
 *         .gt("lastQueryTime", nowMinus24Hrs)
@@ -63,12 +63,12 @@ import java.util.Set;
 * // get a list of entities (query execution statistics)
 *
 * List<Order> orders =
- *     Ebean.find(Order.class).findList();
+ *     DB.find(Order.class).findList();
 *
 * // Apply a filter...
 *
 * List<Order> filteredOrders =
- *     Ebean.filter(Order.class)
+ *     DB.filter(Order.class)
 *         .startsWith("customer.name", "Rob")
 *         .eq("customer.shippingAddress.city", "Auckland")
 *         .filter(orders);
@@ -2,7 +2,6 @@ package io.ebean;

 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-
 import java.util.List;

 /**
@@ -14,8 +13,7 @@ import java.util.List;
 * </p>
 * <h3>Testing</h3>
 * <p>
- * For testing the mocki-ebean project has the ability to replace the finder implementation
- * <p>
+ * For testing the mocki-ebean project has the ability to replace the finder implementation.
 * </p>
 * <pre>{@code
 *
@@ -25,7 +23,7 @@ import java.util.List;
 *     super(Customer.class);
 *   }
 *
- *   // Add your customer finder methods ...
+ *   // Add finder methods ...
 *
 *   public Customer byName(String name) {
 *     return query().eq("name", name).findOne();
@@ -46,6 +44,15 @@ import java.util.List;
 *   ...
 *
 * }</pre>
+ * <p>
+ *  When the Finder is registered as a field on Customer it can then be used like:
+ * </p>
+ * <pre>{@code
+ *
+ *   Customer rob = Customer.find.byName("Rob");
+ *
+ * }</pre>
+ *
 */
 public class Finder<I, T> {

@@ -55,9 +62,9 @@ public class Finder<I, T> {
  private final Class<T> type;

  /**
-   * The name of the EbeanServer, null for the default server.
+   * The name of the database this finder will use, null for the default database.
   */
-  private final String serverName;
+  private final String _$dbName;

  /**
   * Create with the type of the entity bean.
@@ -82,15 +89,15 @@ public class Finder<I, T> {
   */
  public Finder(Class<T> type) {
    this.type = type;
-    this.serverName = null;
+    this._$dbName = null;
  }

  /**
-   * Create with the type of the entity bean and specific server name.
+   * Create with the type of the entity bean and specific database name.
   */
-  public Finder(Class<T> type, String serverName) {
+  public Finder(Class<T> type, String databaseName) {
    this.type = type;
-    this.serverName = serverName;
+    this._$dbName = databaseName;
  }

  /**
@@ -108,30 +115,27 @@ public class Finder<I, T> {
  }

  /**
-   * Return the underlying 'default' EbeanServer.
-   * <p>
-   * This provides full access to the API such as explicit transaction demarcation etc.
+   * Return the Database this finder will use.
   */
-  public EbeanServer db() {
-    return Ebean.getServer(serverName);
+  public Database db() {
+    return DB.byName(_$dbName);
  }

  /**
-   * Return typically a different EbeanServer to the default.
+   * Return typically a different Database to the default.
   * <p>
-   * This is equivalent to {@link Ebean#getServer(String)}
+   * This is equivalent to {@link DB#byName(String)}
   *
-   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is
-   *               returned.
+   * @param databaseName The name of the Database. If this is null then the default database is returned.
   */
-  public EbeanServer db(String server) {
-    return Ebean.getServer(server);
+  public Database db(String databaseName) {
+    return DB.byName(databaseName);
  }

  /**
   * Creates an entity reference for this ID.
   * <p>
-   * Equivalent to {@link EbeanServer#getReference(Class, Object)}
+   * Equivalent to {@link Database#getReference(Class, Object)}
   */
  @Nonnull
  public T ref(I id) {
@@ -141,7 +145,7 @@ public class Finder<I, T> {
  /**
   * Retrieves an entity by ID.
   * <p>
-   * Equivalent to {@link EbeanServer#find(Class, Object)}
+   * Equivalent to {@link Database#find(Class, Object)}
   */
  @Nullable
  public T byId(I id) {
@@ -151,7 +155,7 @@ public class Finder<I, T> {
  /**
   * Delete a bean by Id.
   * <p>
-   * Equivalent to {@link EbeanServer#delete(Class, Object)}
+   * Equivalent to {@link Database#delete(Class, Object)}
   */
  public void deleteById(I id) {
    db().delete(type, id);
@@ -181,7 +185,7 @@ public class Finder<I, T> {
   * }</pre>
   *
   * <p>
-   * Equivalent to {@link EbeanServer#update(Class)}
+   * Equivalent to {@link Database#update(Class)}
   */
  public UpdateQuery<T> update() {
    return db().update(type);
@@ -190,7 +194,7 @@ public class Finder<I, T> {
  /**
   * Creates a query.
   * <p>
-   * Equivalent to {@link EbeanServer#find(Class)}
+   * Equivalent to {@link Database#find(Class)}
   */
  public Query<T> query() {
    return db().find(type);
@@ -20,7 +20,7 @@ import java.util.concurrent.TimeoutException;
 * <pre>{@code
 *
 *  // create a query to find all orders
- * Query<Order> query = Ebean.find(Order.class);
+ * Query<Order> query = DB.find(Order.class);
 *
 *  // execute the query in a background thread
 *  // immediately returning the futureList
@@ -11,7 +11,7 @@ package io.ebean;
 * </p>
 * <pre>{@code
 * Query q =
- *     Ebean.find(Person.class)
+ *     DB.find(Person.class)
 *       .where()
 *         .or()
 *           .like("name", "Rob%")
@@ -30,7 +30,7 @@ package io.ebean;
 * <pre>{@code
 *
 * Query q =
- *     Ebean.find(Person.class)
+ *     DB.find(Person.class)
 *       .where()
 *         .or()
 *           .like("name", "Rob%")
@@ -50,7 +50,7 @@ package io.ebean;
 * </p>
 * <pre>{@code
 * Query<Customer> q =
- *  Ebean.find(Customer.class)
+ *  DB.find(Customer.class)
 *      .where()
 *        .or()
 *          .and()
@@ -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();
+}
@@ -0,0 +1,96 @@
+package io.ebean;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * Builds a MergeOptions which is immutable and thread safe.
+ */
+public class MergeOptionsBuilder {
+
+  private static final MOptions DEFAULT_OPTIONS = new MOptions();
+
+  private Set<String> paths = new LinkedHashSet<>();
+
+  private boolean clientGeneratedIds;
+
+  private boolean deletePermanent;
+
+  /**
+   * Return the default options.
+   */
+  public static MergeOptions defaultOptions() {
+    return DEFAULT_OPTIONS;
+  }
+
+  /**
+   * 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 MergeOptions 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(){
+      this.clientGeneratedIds = false;
+      this.paths = new LinkedHashSet<>();
+      this.deletePermanent = false;
+    }
+
+    private MOptions(Set<String> paths, boolean clientGeneratedIds, boolean deletePermanent) {
+      this.paths = paths;
+      this.clientGeneratedIds = clientGeneratedIds;
+      this.deletePermanent = deletePermanent;
+    }
+
+    @Override
+    public Set<String> paths() {
+      return paths;
+    }
+
+    @Override
+    public boolean isClientGeneratedIds() {
+      return clientGeneratedIds;
+    }
+
+    @Override
+    public boolean isDeletePermanent() {
+      return deletePermanent;
+    }
+  }
+}
@@ -2,7 +2,6 @@ package io.ebean;

 import io.ebean.bean.EntityBean;

-import javax.persistence.MappedSuperclass;

 /**
 * A MappedSuperclass base class that provides convenience methods for inserting, updating and
@@ -12,15 +11,15 @@ import javax.persistence.MappedSuperclass;
 * Ebean users.
 * <p>
 * Note that there is a ebean-mocker project that enables you to use Mockito or similar
- * tools to still mock out the underlying 'default EbeanServer' for testing purposes.
+ * tools to still mock out the underlying 'default Database' for testing purposes.
 * <p>
 * You may choose not use this Model mapped superclass if you don't like the 'Active Record' style
 * or if you believe it 'pollutes' your entity beans.
 * <p>
- * You can use Dependency Injection like Guice or Spring to construct and wire a EbeanServer instance
+ * You can use Dependency Injection like Guice or Spring to construct and wire a Database instance
 * and have that same instance used with this Model and Finder. The way that works is that when the
- * DI container creates the EbeanServer instance it can be registered with the Ebean singleton. In this
- * way the EbeanServer instance can be injected as per normal Guice / Spring dependency injection and
+ * DI container creates the Database instance it can be registered with DB. In this
+ * way the Database instance can be injected as per normal Guice / Spring dependency injection and
 * that same instance also used to support the Model and Finder active record style.
 * <p>
 * If you choose to use the Model mapped superclass you will probably also chose to additionally add
@@ -74,19 +73,17 @@ import javax.persistence.MappedSuperclass;
 *
 * }</pre>
 */
-@MappedSuperclass
 public abstract class Model {

  /**
-   * Return the underlying 'default' EbeanServer.
+   * Return the underlying 'default' Database.
   * <p>
   * This provides full access to the API such as explicit transaction demarcation etc.
   * <p>
   * Example:
   * <pre>{@code
   *
-   * Transaction transaction = Customer.db().beginTransaction();
-   * try {
+   * try (Transaction transaction = Customer.db().beginTransaction()) {
   *
   *   // turn off cascade persist for this transaction
   *   transaction.setPersistCascade(false);
@@ -106,26 +103,21 @@ public abstract class Model {
   *
   *   transaction.commit();
   *
-   * } finally {
-   *   transaction.end();
   * }
   *
   * }</pre>
   */
-  public static EbeanServer db() {
-    return Ebean.getDefaultServer();
+  public static Database db() {
+    return DB.getDefault();
  }

  /**
-   * Return a named EbeanServer that is typically different to the default server.
-   * <p>
-   * If you are using multiple databases then each database has a name and maps to a single
-   * EbeanServer. You can use this method to get an EbeanServer for another database.
+   * Return a named Database that is typically different to the default database.
   *
-   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is returned.
+   * @param server The name of the Database. If this is null then the default Database is returned.
   */
-  public static EbeanServer db(String server) {
-    return Ebean.getServer(server);
+  public static Database db(String server) {
+    return DB.byName(server);
  }

  /**
@@ -148,7 +140,7 @@ public abstract class Model {
   *
   * }</pre>
   *
-   * @see EbeanServer#markAsDirty(Object)
+   * @see Database#markAsDirty(Object)
   */
  public void markAsDirty() {
    db().markAsDirty(this);
@@ -184,7 +176,7 @@ public abstract class Model {
   * 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)
+   * @see Database#save(Object)
   */
  public void save() {
    db().save(this);
@@ -204,7 +196,7 @@ public abstract class Model {
  /**
   * Update this entity.
   *
-   * @see EbeanServer#update(Object)
+   * @see Database#update(Object)
   */
  public void update() {
    db().update(this);
@@ -213,7 +205,7 @@ public abstract class Model {
  /**
   * Insert this entity.
   *
-   * @see EbeanServer#insert(Object)
+   * @see Database#insert(Object)
   */
  public void insert() {
    db().insert(this);
@@ -234,7 +226,7 @@ public abstract class Model {
   * deleted. Note that, if JDBC batch mode is used then this always returns true.
   * </p>
   *
-   * @see EbeanServer#delete(Object)
+   * @see Database#delete(Object)
   */
  public boolean delete() {
    return db().delete(this);
@@ -247,7 +239,7 @@ public abstract class Model {
   * want to perform a hard/permanent delete.
   * </p>
   *
-   * @see EbeanServer#deletePermanent(Object)
+   * @see Database#deletePermanent(Object)
   */
  public boolean deletePermanent() {
    return db().deletePermanent(this);
@@ -277,7 +269,7 @@ public abstract class Model {
  /**
   * Refreshes this entity from the database.
   *
-   * @see EbeanServer#refresh(Object)
+   * @see Database#refresh(Object)
   */
  public void refresh() {
    db().refresh(this);
@@ -1,9 +1,11 @@
 package io.ebean;

+import io.ebean.util.StringHelper;
+
 import java.io.Serializable;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;

 /**
 * Represents an Order By for a Query.
@@ -74,6 +76,15 @@ public final class OrderBy<T> implements Serializable {
    return query;
  }

+  /**
+   * Add a property with ascending order to this OrderBy.
+   */
+  public Query<T> asc(String propertyName, String collation) {
+
+    list.add(new Property(propertyName, true, collation));
+    return query;
+  }
+
  /**
   * Add a property with descending order to this OrderBy.
   */
@@ -83,6 +94,16 @@ public final class OrderBy<T> implements Serializable {
    return query;
  }

+  /**
+   * Add a property with descending order to this OrderBy.
+   */
+  public Query<T> desc(String propertyName, String collation) {
+
+    list.add(new Property(propertyName, false, collation));
+    return query;
+  }
+
+
  /**
   * Return true if the property is known to be contained in the order by clause.
   */
@@ -231,6 +252,8 @@ public final class OrderBy<T> implements Serializable {

    private boolean ascending;

+    private String collation;
+
    private String nulls;

    private String highLow;
@@ -247,17 +270,32 @@ public final class OrderBy<T> implements Serializable {
      this.highLow = highLow;
    }

+    public Property(String property, boolean ascending, String collation) {
+      this.property = property;
+      this.ascending = ascending;
+      this.collation = collation;
+    }
+
+    public Property(String property, boolean ascending, String collation, String nulls, String highLow) {
+      this.property = property;
+      this.ascending = ascending;
+      this.collation = collation;
+      this.nulls = nulls;
+      this.highLow = highLow;
+    }
+
    /**
     * Return a copy of this Property with the path trimmed.
     */
    public Property copyWithTrim(String path) {
-      return new Property(property.substring(path.length() + 1), ascending, nulls, highLow);
+      return new Property(property.substring(path.length() + 1), ascending, collation, nulls, highLow);
    }

    @Override
    public int hashCode() {
      int hc = property.hashCode();
      hc = hc * 92821 + (ascending ? 0 : 1);
+      hc = hc * 92821 + (collation == null ? 0 : collation.hashCode());
      hc = hc * 92821 + (nulls == null ? 0 : nulls.hashCode());
      hc = hc * 92821 + (highLow == null ? 0 : highLow.hashCode());
      return hc;
@@ -274,8 +312,9 @@ public final class OrderBy<T> implements Serializable {
      Property e = (Property) obj;
      if (ascending != e.ascending) return false;
      if (!property.equals(e.property)) return false;
-      if (nulls != null ? !nulls.equals(e.nulls) : e.nulls != null) return false;
-      return highLow != null ? highLow.equals(e.highLow) : e.highLow == null;
+      if (!Objects.equals(collation, e.collation)) return false;
+      if (!Objects.equals(nulls, e.nulls)) return false;
+      return Objects.equals(highLow, e.highLow);
    }

    @Override
@@ -284,7 +323,7 @@ public final class OrderBy<T> implements Serializable {
    }

    public String toStringFormat() {
-      if (nulls == null) {
+      if (nulls == null && collation == null) {
        if (ascending) {
          return property;
        } else {
@@ -292,11 +331,23 @@ public final class OrderBy<T> implements Serializable {
        }
      } else {
        StringBuilder sb = new StringBuilder();
-        sb.append(property);
+        if (collation != null)  {
+          if (collation.contains("${}")) {
+            // this is a complex collation, e.g. DB2 - we must replace the property
+            sb.append(StringHelper.replaceString(collation, "${}", property));
+          } else {
+            sb.append(property);
+            sb.append(" collate ").append(collation);
+          }
+        } else {
+          sb.append(property);
+        }
        if (!ascending) {
          sb.append(" ").append("desc");
        }
-        sb.append(" ").append(nulls).append(" ").append(highLow);
+        if (nulls != null) {
+          sb.append(" ").append(nulls).append(" ").append(highLow);
+        }
        return sb.toString();
      }
    }
@@ -319,7 +370,7 @@ public final class OrderBy<T> implements Serializable {
     * Return a copy of this property.
     */
    public Property copy() {
-      return new Property(property, ascending, nulls, highLow);
+      return new Property(property, ascending, collation, nulls, highLow);
    }

    /**
@@ -360,15 +411,15 @@ public final class OrderBy<T> implements Serializable {

    String[] chunks = orderByClause.split(",");
    for (String chunk : chunks) {
-      String[] pairs = chunk.split(" ");
-      Property p = parseProperty(pairs);
+      Property p = parseProperty(chunk);
      if (p != null) {
        list.add(p);
      }
    }
  }

-  private Property parseProperty(String[] pairs) {
+  private Property parseProperty(String chunk) {
+    String[] pairs = chunk.split(" ");
    if (pairs.length == 0) {
      return null;
    }
@@ -394,8 +445,7 @@ public final class OrderBy<T> implements Serializable {
      boolean asc = isAscending(wordList.get(1));
      return new Property(wordList.get(0), asc, wordList.get(2), wordList.get(3));
    }
-    String m = "Expecting a 1, 2 or 4 words in [" + Arrays.toString(pairs) + "] but got " + wordList;
-    throw new RuntimeException(m);
+    return new Property(chunk.trim(), true);
  }

  private boolean isAscending(String s) {
@@ -24,8 +24,7 @@ import java.util.concurrent.Future;
 *     // We want to find the first 50 new orders
 *     //  ... so we don't really need setFirstRow(0)
 *
- *     PagedList<Order> pagedList
- *       = ebeanServer.find(Order.class)
+ *     PagedList<Order> pagedList = DB.find(Order.class)
 *       .where().eq("status", Order.Status.NEW)
 *       .order().asc("id")
 *       .setFirstRow(0)
@@ -1,6 +1,7 @@
 package io.ebean;

 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;

 /**
@@ -25,7 +26,7 @@ import java.util.List;
 *   pairs.add("sj2", 1001);
 *   pairs.add("pf3", 1000);
 *
- *   List<OCachedNatKeyBean3> list = Ebean.find(OCachedNatKeyBean3.class)
+ *   List<OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
 *   .where()
 *   .eq("store", "def")
 *   .inPairs(pairs)       // IN clause with 'pairs' of values
@@ -125,7 +126,7 @@ public class Pairs {
   * Return all the value pairs.
   */
  public List<Entry> getEntries() {
-    return entries;
+    return Collections.unmodifiableList(entries);
  }

  /**
@@ -158,6 +159,7 @@ public class Pairs {
    return this;
  }

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

+    @Override
    public String toString() {
      return "{" + a + "," + b + "}";
    }
@@ -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();
@@ -76,7 +76,6 @@ class PrimaryServer {
    if (defaultServerName == null) {
      defaultServerName = "db";
    }
-    System.setProperty("ebean_db", defaultServerName);
    return defaultServerName;
  }

@@ -19,10 +19,7 @@ import java.util.function.Predicate;
 * <p>
 * <pre>{@code
 *
- * List<Order> orderList =
- *   ebeanServer.find(Order.class)
- *     .fetch("customer")
- *     .fetch("details")
+ * List<Order> orderList = DB.find(Order.class)
 *     .where()
 *       .like("customer.name","rob%")
 *       .gt("orderDate",lastWeek)
@@ -38,29 +35,14 @@ import java.util.function.Predicate;
 * <pre>{@code
 *
 * String oql =
- *   	+" fetch customer "
- *   	+" fetch details "
 *   	+" where customer.name like :custName and orderDate > :minOrderDate "
 *   	+" order by customer.id, id desc "
 *   	+" limit 50 ";
 *
- * Query<Order> query = ebeanServer.createQuery(Order.class, oql);
- * query.setParameter("custName", "Rob%");
- * query.setParameter("minOrderDate", lastWeek);
- *
- * List<Order> orderList = query.findList();
- * ...
- * }</pre>
- * <p>
- * Example: Using a named query called "with.cust.and.details"
- * </p>
- * <pre>{@code
- *
- * Query<Order> query = ebeanServer.createNamedQuery(Order.class,"with.cust.and.details");
- * query.setParameter("custName", "Rob%");
- * query.setParameter("minOrderDate", lastWeek);
- *
- * List<Order> orderList = query.findList();
+ * List<Order> orderList = DB.createQuery(Order.class, oql)
+ *   .setParameter("custName", "Rob%")
+ *   .setParameter("minOrderDate", lastWeek)
+ *   .findList();
 * ...
 * }</pre>
 * <h3>AutoTune</h3>
@@ -236,6 +218,46 @@ 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);
+
+  /**
+   * Convert the query to a UpdateQuery.
+   * <p>
+   * Typically this is used with query beans to covert a query bean
+   * query into an UpdateQuery like the examples below.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  int rowsUpdated = new QCustomer()
+   *       .name.startsWith("Rob")
+   *       .asUpdate()
+   *       .set("active", false)
+   *       .update();;
+   *
+   * }</pre>
+   *
+   * <pre>{@code
+   *
+   *   int rowsUpdated = new QContact()
+   *       .notes.note.startsWith("Make Inactive")
+   *       .email.endsWith("@foo.com")
+   *       .customer.id.equalTo(42)
+   *       .asUpdate()
+   *       .set("inactive", true)
+   *       .setRaw("email = lower(email)")
+   *       .update();
+   *
+   * }</pre>
+   */
+  UpdateQuery<T> asUpdate();
+
  /**
   * Cancel the query execution if supported by the underlying database and
   * driver.
@@ -332,6 +354,27 @@ public interface Query<T> {
   */
  Query<T> setAutoTune(boolean autoTune);

+  /**
+   * Execute the query allowing properties with invalid JSON to be collected and not fail the query.
+   * <pre>{@code
+   *
+   *   // fetch a bean with JSON content
+   *   EBasicJsonList bean= DB.find(EBasicJsonList.class)
+   *       .setId(42)
+   *       .setAllowLoadErrors()  // collect errors into bean state if we have invalid JSON
+   *       .findOne();
+   *
+   *
+   *   // get the invalid JSON errors from the bean state
+   *   Map<String, Exception> errors = server().getBeanState(bean).getLoadErrors();
+   *
+   *   // If this map is not empty tell we have invalid JSON
+   *   // and should try and fix the JSON content or inform the user
+   *
+   * }</pre>
+   */
+  Query<T> setAllowLoadErrors();
+
  /**
   * Set the default lazy loading batch size to use.
   * <p>
@@ -375,8 +418,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   * List<Customer> customers =
-   *     ebeanServer.find(Customer.class)
+   * List<Customer> customers = DB.find(Customer.class)
   *     // Only fetch the customer id, name and status.
   *     // This is described as a "Partial Object"
   *     .select("name, status")
@@ -389,6 +431,11 @@ public interface Query<T> {
   */
  Query<T> select(String fetchProperties);

+  /**
+   * Apply the fetchGroup which defines what part of the object graph to load.
+   */
+  Query<T> select(FetchGroup<T> fetchGroup);
+
  /**
   * Specify a path to fetch eagerly including specific properties.
   * <p>
@@ -399,8 +446,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   * // query orders...
-   * List<Order> orders =
-   *     ebeanServer.find(Order.class)
+   * List<Order> orders = DB.find(Order.class)
   *       // fetch the customer...
   *       // ... getting the customers name and phone number
   *       .fetch("customer", "name, phoneNumber")
@@ -415,8 +461,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   * // fetch customers (their id, name and status)
-   * List<Customer> customers =
-   *     ebeanServer.find(Customer.class)
+   * List<Customer> customers = DB.find(Customer.class)
   *     .select("name, status")
   *     .fetch("contacts", "firstName,lastName,email")
   *     .findList();
@@ -485,8 +530,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   * // fetch customers (their id, name and status)
-   * List<Customer> customers =
-   *     ebeanServer.find(Customer.class)
+   * List<Customer> customers = DB.find(Customer.class)
   *     .select("name, status")
   *     .fetch("contacts", "firstName,lastName,email", new FetchConfig().lazy(10))
   *     .findList();
@@ -507,8 +551,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   * // fetch customers (their id, name and status)
-   * List<Customer> customers =
-   *     ebeanServer.find(Customer.class)
+   * List<Customer> customers = DB.find(Customer.class)
   *     // eager fetch the contacts
   *     .fetch("contacts")
   *     .findList();
@@ -571,8 +614,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   * // fetch customers (their id, name and status)
-   * List<Customer> customers =
-   *     ebeanServer.find(Customer.class)
+   * List<Customer> customers = DB.find(Customer.class)
   *     // lazy fetch contacts with a batch size of 100
   *     .fetch("contacts", new FetchConfig().lazy(100))
   *     .findList();
@@ -592,10 +634,8 @@ public interface Query<T> {
  /**
   * Execute the query returning the list of Id's.
   * <p>
-   * This query will execute against the EbeanServer that was used to create it.
+   * This query will execute against the Database that was used to create it.
   * </p>
-   *
-   * @see EbeanServer#findIds(Query, Transaction)
   */
  @Nonnull
  <A> List<A> findIds();
@@ -616,24 +656,21 @@ public interface Query<T> {
   * the jdbc statement and resultSet are closed at the end of the iteration.
   * </p>
   * <p>
-   * This query will execute against the EbeanServer that was used to create it.
+   * This query will execute against the Database that was used to create it.
   * </p>
   * <pre>{@code
   *
-   *  Query<Customer> query =
-   *    ebeanServer.find(Customer.class)
+   *  Query<Customer> query = DB.find(Customer.class)
   *     .where().eq("status", Status.NEW)
   *     .order().asc("id");
   *
-   *  QueryIterator<Customer> it = query.findIterate();
-   *  try {
+   *  // use try with resources to ensure QueryIterator is closed
+   *
+   *  try (QueryIterator<Customer> it = query.findIterate()) {
   *    while (it.hasNext()) {
   *      Customer customer = it.next();
   *      // do something with customer ...
   *    }
-   *  } finally {
-   *    // close the underlying resources
-   *    it.close();
   *  }
   *
   * }</pre>
@@ -670,7 +707,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   *  ebeanServer.find(Customer.class)
+   *  DB.find(Customer.class)
   *     .where().eq("status", Status.NEW)
   *     .order().asc("id")
   *     .findEach((Customer customer) -> {
@@ -699,7 +736,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   *  ebeanServer.find(Customer.class)
+   *  DB.find(Customer.class)
   *     .fetch("contacts", new FetchConfig().query(2))
   *     .where().eq("status", Status.NEW)
   *     .order().asc("id")
@@ -722,18 +759,15 @@ public interface Query<T> {
  /**
   * Execute the query returning the list of objects.
   * <p>
-   * This query will execute against the EbeanServer that was used to create it.
+   * This query will execute against the Database that was used to create it.
   * </p>
   * <pre>{@code
   *
-   * List<Customer> customers =
-   *     ebeanServer.find(Customer.class)
+   * List<Customer> customers = DB.find(Customer.class)
   *     .where().ilike("name", "rob%")
   *     .findList();
   *
   * }</pre>
-   *
-   * @see EbeanServer#findList(Query, Transaction)
   */
  @Nonnull
  List<T> findList();
@@ -741,18 +775,15 @@ public interface Query<T> {
  /**
   * Execute the query returning the set of objects.
   * <p>
-   * This query will execute against the EbeanServer that was used to create it.
+   * This query will execute against the Database that was used to create it.
   * </p>
   * <pre>{@code
   *
-   * Set<Customer> customers =
-   *     ebeanServer.find(Customer.class)
+   * Set<Customer> customers = DB.find(Customer.class)
   *     .where().ilike("name", "rob%")
   *     .findSet();
   *
   * }</pre>
-   *
-   * @see EbeanServer#findSet(Query, Transaction)
   */
  @Nonnull
  Set<T> findSet();
@@ -760,7 +791,7 @@ public interface Query<T> {
  /**
   * Execute the query returning a map of the objects.
   * <p>
-   * This query will execute against the EbeanServer that was used to create it.
+   * This query will execute against the Database that was used to create it.
   * </p>
   * <p>
   * You can use setMapKey() so specify the property values to be used as keys
@@ -768,14 +799,11 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   * Map<String, Product> map =
-   *   ebeanServer.find(Product.class)
+   * Map<String, Product> map = DB.find(Product.class)
   *     .setMapKey("sku")
   *     .findMap();
   *
   * }</pre>
-   *
-   * @see EbeanServer#findMap(Query, Transaction)
   */
  @Nonnull
  <K> Map<K, T> findMap();
@@ -787,7 +815,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   *  List<String> names =
-   *    Ebean.find(Customer.class)
+   *    DB.find(Customer.class)
   *      .select("name")
   *      .orderBy().asc("name")
   *      .findSingleAttributeList();
@@ -798,7 +826,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   *  List<String> names =
-   *    Ebean.find(Customer.class)
+   *    DB.find(Customer.class)
   *      .setDistinct(true)
   *      .select("name")
   *      .where().eq("status", Customer.Status.NEW)
@@ -819,7 +847,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   *  String name =
-   *    Ebean.find(Customer.class)
+   *    DB.find(Customer.class)
   *      .select("name")
   *      .where().eq("id", 42)
   *      .findSingleAttribute();
@@ -828,6 +856,42 @@ public interface Query<T> {
   */
  <A> A findSingleAttribute();

+  /**
+   * Return true if this is countDistinct query.
+   */
+  boolean isCountDistinct();
+
+  /**
+   * Execute the query returning true if a row is found.
+   * <p>
+   * The query is executed using max rows of 1 and will only select the id property.
+   * This method is really just a convenient way to optimise a query to perform a
+   * 'does a row exist in the db' check.
+   * </p>
+   *
+   * <h2>Example using a query bean:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists =
+   *     new QContact()
+   *       .email.equalTo("rob@foo.com")
+   *       .exists();
+   *
+   * }</pre>
+   *
+   * <h2>Example:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = query()
+   *     .where().eq("email", "rob@foo.com")
+   *     .exists();
+   *
+   * }</pre>
+   *
+   * @return True if the query finds a matching row in the database
+   */
+  boolean exists();
+
  /**
   * Execute the query returning either a single bean or null (if no matching
   * bean is found).
@@ -842,8 +906,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   * // assuming the sku of products is unique...
-   * Product product =
-   *     ebeanServer.find(Product.class)
+   * Product product = DB.find(Product.class)
   *         .where().eq("sku", "aa113")
   *         .findOne();
   * ...
@@ -855,8 +918,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   * // Fetch order 1 and additionally fetch join its order details...
-   * Order order =
-   *     ebeanServer.find(Order.class)
+   * Order order = DB.find(Order.class)
   *       .setId(1)
   *       .fetch("details")
   *       .findOne();
@@ -914,11 +976,31 @@ public interface Query<T> {
   */
  int delete();

+  /**
+   * Execute as a delete query returning the number of rows deleted using the given transaction.
+   * <p>
+   * Note that if the query includes joins then the generated delete statement may not be
+   * optimal depending on the database platform.
+   * </p>
+   *
+   * @return the number of beans/rows that were deleted.
+   */
+  int delete(Transaction transaction);
+
  /**
   * Execute the UpdateQuery returning the number of rows updated.
+   *
+   * @return the number of beans/rows updated.
   */
  int update();

+  /**
+   * Execute the UpdateQuery returning the number of rows updated using the given transaction.
+   *
+   * @return the number of beans/rows updated.
+   */
+  int update(Transaction transaction);
+
  /**
   * Return the count of entities this query should return.
   * <p>
@@ -977,7 +1059,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   *  PagedList<Order> pagedList = Ebean.find(Order.class)
+   *  PagedList<Order> pagedList = DB.find(Order.class)
   *       .setFirstRow(50)
   *       .setMaxRows(20)
   *       .findPagedList();
@@ -1002,11 +1084,9 @@ public interface Query<T> {
   * // a query with a named parameter
   * String oql = "find order where status = :orderStatus";
   *
-   * Query<Order> query = ebeanServer.find(Order.class, oql);
-   *
-   * // bind the named parameter
-   * query.bind("orderStatus", OrderStatus.NEW);
-   * List<Order> list = query.findList();
+   * List<Order> list = DB.find(Order.class, oql)
+   *   .setParameter("orderStatus", OrderStatus.NEW)
+   *   .findList();
   *
   * }</pre>
   *
@@ -1024,12 +1104,9 @@ public interface Query<T> {
   * // a query with a positioned parameter
   * String oql = "where status = ? order by id desc";
   *
-   * Query<Order> query = ebeanServer.createQuery(Order.class, oql);
-   *
-   * // bind the parameter
-   * query.setParameter(1, OrderStatus.NEW);
-   *
-   * List<Order> list = query.findList();
+   * List<Order> list = DB.createQuery(Order.class, oql)
+   *   .setParameter(1, OrderStatus.NEW)
+   *   .findList();
   *
   * }</pre>
   *
@@ -1046,8 +1123,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   * Order order =
-   *     ebeanServer.find(Order.class)
+   * Order order = DB.find(Order.class)
   *     .setId(1)
   *     .fetch("details")
   *     .findOne();
@@ -1068,8 +1144,7 @@ public interface Query<T> {
   * Add a single Expression to the where clause returning the query.
   * <pre>{@code
   *
-   * List<Order> newOrders =
-   *     ebeanServer.find(Order.class)
+   * List<Order> newOrders = DB.find(Order.class)
   * 		.where().eq("status", Order.NEW)
   * 		.findList();
   * ...
@@ -1084,8 +1159,7 @@ public interface Query<T> {
   * where clause.
   * <pre>{@code
   *
-   * List<Order> orders =
-   *     ebeanServer.find(Order.class)
+   * List<Order> orders = DB.find(Order.class)
   *     .where()
   *       .eq("status", Order.NEW)
   *       .ilike("customer.name","rob%")
@@ -1131,10 +1205,7 @@ public interface Query<T> {
   * </p>
   * <pre>{@code
   *
-   * List<Customer> list =
-   *     ebeanServer.find(Customer.class)
-   *     // .fetch("orders", new FetchConfig().lazy())
-   *     // .fetch("orders", new FetchConfig().query())
+   * List<Customer> list = DB.find(Customer.class)
   *     .fetch("orders")
   *     .where().ilike("name", "rob%")
   *     .filterMany("orders").eq("status", Order.Status.NEW).gt("orderDate", lastWeek)
@@ -1148,8 +1219,7 @@ public interface Query<T> {
   * </p>
   *
   * @param propertyName the name of the many property that you want to have a filter on.
-   * @return the expression list that you add filter expressions for the many
-   * to.
+   * @return the expression list that you add filter expressions for the many to.
   */
  ExpressionList<T> filterMany(String propertyName);

@@ -1263,7 +1333,7 @@ public interface Query<T> {
   * <pre>{@code
   *
   *   List<Customer> customers =
-   *       Ebean.find(Customer.class)
+   *       DB.find(Customer.class)
   *          .setDistinct(true)
   *          .select("name")
   *          .findList();
@@ -1272,6 +1342,36 @@ public interface Query<T> {
   */
  Query<T> setDistinct(boolean isDistinct);

+  /**
+   * Extended version for setDistinct in conjunction with "findSingleAttributeList";
+   *
+   * <pre>{@code
+   *
+   *  List<CountedValue<Order.Status>> orderStatusCount =
+   *
+   *     DB.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.
   */
@@ -1305,10 +1405,8 @@ public interface Query<T> {
   *
   * // Assuming sku is unique for products...
   *
-   * Map<String,Product> productMap =
-   *     ebeanServer.find(Product.class)
-   *     // use sku for keys...
-   *     .setMapKey("sku")
+   * Map<String,Product> productMap = DB.find(Product.class)
+   *     .setMapKey("sku")  // sku map keys...
   *     .findMap();
   *
   * }</pre>
@@ -1375,6 +1473,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>
@@ -1435,12 +1542,6 @@ public interface Query<T> {
   */
  String getGeneratedSql();

-  /**
-   * executed the select with "for update" which should lock the record
-   * "on read"
-   */
-  Query<T> setForUpdate(boolean forUpdate);
-
  /**
   * Execute using "for update" clause which results in the DB locking the record.
   */
@@ -1477,11 +1578,55 @@ public interface Query<T> {
   */
  Query<T> alias(String alias);

+  /**
+   * Set the base table to use for this query.
+   * <p>
+   * Typically this is used when a table has partitioning and we wish to specify a specific
+   * partition/table to query against.
+   * </p>
+   * <pre>{@code
+   *
+   *   QOrder()
+   *   .setBaseTable("order_2019_05")
+   *   .status.equalTo(Status.NEW)
+   *   .findList();
+   *
+   * }</pre>
+   */
+  Query<T> setBaseTable(String baseTable);
+
  /**
   * Return the type of beans being queried.
   */
  Class<T> getBeanType();

+  /**
+   * Restrict the query to only return subtypes of the given inherit type.
+   *
+   * <pre>{@code
+   *
+   *   List<Animal> animals =
+   *     new QAnimal()
+   *       .name.startsWith("Fluffy")
+   *       .setInheritType(Cat.class)
+   *       .findList();
+   *
+   * }</pre>
+   *
+   * @param type An inheritance subtype of the
+   */
+  Query<T> setInheritType(Class<? extends T> type);
+
+  /**
+   * Returns the inherit type. This is normally the same as getBeanType() returns as long as no other type is set.
+   */
+  Class<? extends T> getInheritType();
+
+  /**
+   * Return the type of query being executed.
+   */
+  QueryType getQueryType();
+
  /**
   * Set true if you want to disable lazy loading.
   * <p>
@@ -1499,4 +1644,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);
+
 }
@@ -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
+}
@@ -87,7 +87,7 @@ package io.ebean;
 *     // .columnMapping("sum(d.order_qty*d.unit_price)", "totalAmount")
 *     .create();
 *
- *   List<OrderAggregate> list = Ebean.find(OrderAggregate.class)
+ *   List<OrderAggregate> list = DB.find(OrderAggregate.class)
 *       .setRawSql(rawSql)
 *       .where().gt("order.id", 0)
 *       .having().gt("totalAmount", 20)
@@ -114,7 +114,7 @@ package io.ebean;
 *     .columnMappingIgnore("'ignoreMe'")
 *     .create();
 *
- *   List<OrderAggregate> orders = Ebean.find(OrderAggregate.class)
+ *   List<OrderAggregate> orders = DB.find(OrderAggregate.class)
 *     .setRawSql(rawSql)
 *     .fetch("order", "status,orderDate", new FetchConfig().query())
 *     .fetch("order.customer", "name")
@@ -146,7 +146,7 @@ package io.ebean;
 *       .tableAliasMapping("p", "details.product")
 *       .create();
 *
- *  List<Order> ordersFromRaw = Ebean.find(Order.class)
+ *  List<Order> ordersFromRaw = DB.find(Order.class)
 *       .setRawSql(rawSql)
 *       .setParameter("maxOrderId", 2)
 *       .setParameter("productId", 1)
@@ -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
@@ -0,0 +1,40 @@
+package io.ebean;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * Used with SqlQuery to process potentially large queries reading directly from the JDBC ResultSet.
+ * <p>
+ * This provides a low level option that reads directly from the JDBC ResultSet.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ *  String sql = "select id, name, status from o_customer order by name desc";
+ *
+ *  DB.sqlQuery(sql)
+ *    .findEachRow((resultSet, rowNum) -> {
+ *
+ *      // read directly from ResultSet
+ *
+ *      long id = resultSet.getLong(1);
+ *      String name = resultSet.getString(2);
+ *
+ *      // do something interesting with the data
+ *
+ *    });
+ *
+ * }</pre>
+ */
+@FunctionalInterface
+public interface RowConsumer {
+
+  /**
+   * Read the data from the ResultSet and process it.
+   *
+   * @param resultSet The JDBC ResultSet positioned to the current row
+   * @param rowNum    The number of the current row being mapped.
+   */
+  void accept(ResultSet resultSet, int rowNum) throws SQLException;
+}
@@ -0,0 +1,62 @@
+package io.ebean;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * Used with SqlQuery to map raw JDBC ResultSet to objects.
+ * <p>
+ * This provides a low level mapping option with direct use of JDBC ResultSet
+ * with the option of having logic in the mapping. For example, only map some
+ * columns depending on the values read from other columns.
+ * </p>
+ * <p>
+ * For straight mapping into beans then DtoQuery would be the first choice as
+ * it can automatically map the ResultSet into beans.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ *    //
+ *    // A mapper from ResultSet into our CustomerDto bean
+ *    //
+ *    class CustomerMapper implements RowMapper<CustomerDto> {
+ *
+ *     @Override
+ *     public CustomerDto map(ResultSet rset, int rowNum) throws SQLException {
+ *
+ *       long id = rset.getLong(1);
+ *       String name = rset.getString(2);
+ *       String status = rset.getString(3);
+ *
+ *       return new CustomerDto(id, name, status);
+ *     }
+ *   }
+ *
+ *
+ *   //
+ *   // Then use the mapper
+ *   //
+ *
+ *   String sql = "select id, name, status from o_customer where name = ?";
+ *
+ *  CustomerDto rob = DB.sqlQuery(sql)
+ *    .setParameter(1, "Rob")
+ *    .findOne(CUSTOMER_MAPPER);
+ *
+ *
+ * }</pre>
+ *
+ * @param <T> The type the row data is mapped into.
+ */
+@FunctionalInterface
+public interface RowMapper<T> {
+
+  /**
+   * Read the data from the ResultSet and map to the return type.
+   *
+   * @param resultSet The JDBC ResultSet positioned to the current row
+   * @param rowNum    The number of the current row being mapped.
+   */
+  T map(ResultSet resultSet, int rowNum) throws SQLException;
+}
@@ -0,0 +1,53 @@
+package io.ebean;
+
+import java.net.URL;
+import java.util.Map;
+
+/**
+ * Runs DDL and SQL scripts.
+ * <p/>
+ * Typically these are scripts used for testing such as seed SQL scripts or truncate SQL scripts.
+ * <p/>
+ * Scripts are executed in their own transaction and committed on successful completion.
+ *
+ * <h3>Example of simple use</h3>
+ * <pre>{@code
+ *
+ *   Database database = DB.getDefault();
+ *   database.script().run("/scripts/test-script.sql");
+ *
+ * }</pre>
+ */
+public interface ScriptRunner {
+
+  /**
+   * Run a script given the resource path (that should start with "/").
+   */
+  void run(String path);
+
+  /**
+   * Run a script given the resource path (that should start with "/") and place holders.
+   *
+   * <pre>{@code
+   *
+   *   Map<String,String> placeholders = new HashMap<>();
+   *   placeholders.put("tableName", "e_basic");
+   *
+   *   Database database = DB.getDefault();
+   *   database.script().run("/scripts/test-script.sql", placeholders);
+   *
+   * }</pre>
+   */
+  void run(String path, Map<String, String> placeholderMap);
+
+  /**
+   * Run a DDL or SQL script given the resource.
+   */
+  void run(URL resource);
+
+  /**
+   * Run a DDL or SQL script given the resource and place holders.
+   */
+  void run(URL resource, Map<String, String> placeholderMap);
+
+}
@@ -3,40 +3,37 @@ package io.ebean;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.io.Serializable;
+import java.math.BigDecimal;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.Predicate;

 /**
- * Query object for performing native SQL queries that return SqlRow's.
- * <p>
- * Firstly note that you can use your own sql queries with <em>entity beans</em>
- * by using the SqlSelect annotation. This should be your first approach when
- * wanting to use your own SQL queries.
- * </p>
- * <p>
- * If ORM Mapping is too tight and constraining for your problem then SqlQuery
- * could be a good approach.
- * </p>
+ * Query object for performing native SQL queries that return SqlRow or directly read
+ * ResultSet using a RowMapper.
 * <p>
 * The returned SqlRow objects are similar to a LinkedHashMap with some type
 * conversion support added.
 * </p>
 * <p>
+ * Refer to {@link DtoQuery} for native sql queries returning DTO beans.
+ * </p>
+ * <p>
+ * Refer to {@link Database#findNative(Class, String)} for native sql queries returning entity beans.
+ * </p>
+ *
 * <pre>{@code
 *
- *   // its typically a good idea to use a named query
- *   // and put the sql in the orm.xml instead of in your code
+ *   // example using named parameters
 *
 *   String sql = "select id, name from customer where name like :name and status_code = :status";
 *
- *   SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
- *   sqlQuery.setParameter("name", "Acme%");
- *   sqlQuery.setParameter("status", "ACTIVE");
- *
- *   // execute the query returning a List of MapBean objects
- *   List<SqlRow> list = sqlQuery.findList();
+ *   List<SqlRow> list =
+ *     DB.sqlQuery(sql)
+ *       .setParameter("name", "Acme%")
+ *       .setParameter("status", "ACTIVE")
+ *       .findList();
 *
 * }</pre>
 */
@@ -77,17 +74,151 @@ public interface SqlQuery extends Serializable {
  @Nullable
  SqlRow findOne();

+  /**
+   * Execute the query returning a single result using the mapper.
+   *
+   * @param mapper Used to map each ResultSet row into the result object.
+   */
+  <T> T findOne(RowMapper<T> mapper);
+
+  /**
+   * Execute the query returning a list using the mapper.
+   *
+   * @param mapper Used to map each ResultSet row into the result object.
+   */
+  <T> List<T> findList(RowMapper<T> mapper);
+
+  /**
+   * Execute the query reading each row from ResultSet using the RowConsumer.
+   * <p>
+   * This provides a low level option that reads directly from the JDBC ResultSet
+   * and is good for processing very large results where (unlike findList) we don't
+   * hold all the results in memory but instead can process row by row.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  String sql = "select id, name, status from customer order by name desc";
+   *
+   *  DB.sqlQuery(sql)
+   *    .findEachRow((resultSet, rowNum) -> {
+   *
+   *      // read directly from ResultSet
+   *
+   *      long id = resultSet.getLong(1);
+   *      String name = resultSet.getString(2);
+   *
+   *      // do something interesting with the data
+   *
+   *    });
+   *
+   * }</pre>
+   *
+   * @param consumer Used to read and process each ResultSet row.
+   */
+  void findEachRow(RowConsumer consumer);
+
  /**
   * Execute the query returning an optional row.
   */
  @Nonnull
  Optional<SqlRow> findOneOrEmpty();

+  /**
+   * Execute the query returning a single scalar attribute.
+   * <pre>@{code
+   *
+   *   String sql = "select max(unit_price) from o_order_detail where order_qty > ?";
+   *
+   *   BigDecimal maxPrice = DB.sqlQuery(sql)
+   *     .setParameter(1, 2)
+   *     .findSingleAttribute(BigDecimal.class);
+   *
+   * }</pre>
+   *
+   * <p>
+   * The attributeType can be any scalar type that Ebean supports (includes javax time types, Joda types etc).
+   * </p>
+   *
+   * @param attributeType The type of the returned value
+   */
+  <T> T findSingleAttribute(Class<T> attributeType);
+
+  /**
+   * Execute the query returning a single BigDecimal value.
+   * <p>
+   * This is an alias for <code>findSingleAttribute(BigDecimal.class)</code>
+   * </p>
+   */
+  BigDecimal findSingleDecimal();
+
+  /**
+   * Execute the query returning a single Long value.
+   * <p>
+   * This is an alias for <code>findSingleAttribute(Long.class)</code>
+   * </p>
+   */
+  Long findSingleLong();
+
+  /**
+   * Execute the query returning a list of scalar attribute values.
+   *
+   * <pre>{@code
+   *
+   *   String sql =
+   *   " select (unit_price * order_qty) " +
+   *   " from o_order_detail " +
+   *   " where unit_price > ? " +
+   *   " order by (unit_price * order_qty) desc";
+   *
+   *   //
+   *   List<BigDecimal> lineAmounts =
+   *     DB.sqlQuery(sql)
+   *       .setParameter(1, 3)
+   *       .findSingleAttributeList(BigDecimal.class);
+   *
+   * }</pre>
+   *
+   * <p>
+   * The attributeType can be any scalar type that Ebean supports (includes javax time types, Joda types etc).
+   * </p>
+   *
+   * @param attributeType The type of the returned value
+   */
+  <T> List<T> findSingleAttributeList(Class<T> attributeType);
+
  /**
   * The same as bind for named parameters.
   */
  SqlQuery setParameter(String name, Object value);

+  /**
+   * Set one of more positioned parameters.
+   * <p>
+   * This is a convenient alternative to multiple calls setParameter().
+   *
+   * <pre>{@code
+   *
+   *   String sql = "select id, name from customer where name like ? and status = ?";
+   *
+   *   List<SqlRow> list =
+   *     DB.sqlQuery(sql)
+   *       .setParams("Rob", Status.NEW)
+   *       .findList();
+   *
+   *
+   *   // is the same as ...
+   *
+   *   List<SqlRow> list =
+   *     DB.sqlQuery(sql)
+   *       .setParameter(1, "Rob")
+   *       .setParameter(2, "Status.NEW)
+   *       .findList();
+   *
+   * }</pre>
+   */
+  SqlQuery setParams(Object... values);
+
  /**
   * The same as bind for positioned parameters.
   */
@@ -115,6 +246,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>
@@ -16,18 +16,90 @@ package io.ebean;
 * notify Ebean of external changes and enable Ebean to maintain it's "L2"
 * server cache.
 * </p>
- * <p>
+ *
 * <pre>{@code
 *
- * // example that uses 'named' parameters
- * String s = "UPDATE f_topic set post_count = :count where id = :id";
- * SqlUpdate update = Ebean.createSqlUpdate(s);
- * update.setParameter("id", 1);
- * update.setParameter("count", 50);
+ *   // example using 'positioned' parameters
 *
- * int modifiedCount = Ebean.execute(update);
+ *   String sql = "insert into audit_log (group, title, description) values (?, ?, ?);
 *
- * String msg = "There were " + modifiedCount + " rows updated";
+ *   int rows =
+ *     DB.sqlUpdate(sql)
+ *       .setParams("login", "new user", "user rob was created")
+ *       .executeNow();
+ *
+ * }</pre>
+ *
+ * <pre>{@code
+ *
+ *   // example using 'named' parameters
+ *
+ *   String sql = "update topic set post_count = :count where id = :id";
+ *
+ *   int rows =
+ *     DB.sqlUpdate(sql)
+ *       .setParameter("id", 1)
+ *       .setParameter("count", 50)
+ *       .execute();
+ *
+ *   String msg = "There were " + rows + " rows updated";
+ *
+ * }</pre>
+ * <p>
+ * <h3>Example: Using setNextParameter()</h3>
+ * <pre>{@code
+ *
+ *  String sql = "insert into audit_log (id, description, modified_description) values (?,?,?)";
+ *
+ *  SqlUpdate insert = DB.sqlUpdate(sql);
+ *
+ *  try (Transaction txn = DB.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>
+ * <p>
+ * An alternative to the batch mode on the transaction is to use addBatch() and executeBatch() like:
+ * </p>
+ * <pre>{@code
+ *
+ *   try (Transaction txn = DB.beginTransaction()) {
+ *
+ *     insert.setNextParameter(10000);
+ *     insert.setNextParameter("hello");
+ *     insert.setNextParameter("rob");
+ *     insert.addBatch();
+ *
+ *     insert.setNextParameter(10001);
+ *     insert.setNextParameter("goodbye");
+ *     insert.setNextParameter("rob");
+ *     insert.addBatch();
+ *
+ *     insert.setNextParameter(10002);
+ *     insert.setNextParameter("chow");
+ *     insert.setNextParameter("bob");
+ *     insert.addBatch();
+ *
+ *     int[] rows = insert.executeBatch();
+ *
+ *     txn.commit();
+ *   }
 *
 * }</pre>
 *
@@ -40,6 +112,11 @@ public interface SqlUpdate {
  /**
   * Execute the update returning the number of rows modified.
   * <p>
+   * Note that if the transaction has batch mode on then this update will use JDBC batch and may not execute until
+   * later - at commit time or a transaction flush. In this case this method returns -1 indicating that the
+   * update has been batched for later execution.
+   * </p>
+   * <p>
   * After you have executed the SqlUpdate you can bind new variables using
   * {@link #setParameter(String, Object)} etc and then execute the SqlUpdate
   * again.
@@ -54,6 +131,42 @@ public interface SqlUpdate {
   */
  int execute();

+  /**
+   * Execute the statement now regardless of the JDBC batch mode of the transaction.
+   */
+  int executeNow();
+
+  /**
+   * Execute when addBatch() has been used to batch multiple bind executions.
+   *
+   * @return The row counts for each of the batched statements.
+   */
+  int[] executeBatch();
+
+  /**
+   * Add the statement to batch processing to then later execute via executeBatch().
+   */
+  void addBatch();
+
+  /**
+   * 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 +201,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 +231,40 @@ public interface SqlUpdate {
   */
  SqlUpdate setTimeout(int secs);

+  /**
+   * Set one of more positioned parameters.
+   * <p>
+   * This is a convenient alternative to multiple setParameter() calls.
+   *
+   * <pre>{@code
+   *
+   *   String sql = "insert into audit_log (id, name, version) values (?,?,?)";
+   *
+   *   DB.sqlUpdate(sql)
+   *       .setParams(UUID.randomUUID(), "Hello", 1)
+   *       .executeNow();
+   *
+   *
+   *   // is the same as ...
+   *
+   *   DB.sqlUpdate(sql)
+   *       .setParameter(1, UUID.randomUUID())
+   *       .setParameter(2, "Hello")
+   *       .setParameter(3, 1)
+   *       .executeNow();
+   *
+   * }</pre>
+   *
+   */
+  SqlUpdate setParams(Object... values);
+
+  /**
+   * Set the next positioned parameter.
+   *
+   * @param value The value to bind
+   */
+  SqlUpdate setNextParameter(Object value);
+
  /**
   * Set a parameter via its index position.
   */
@@ -14,17 +14,17 @@ import java.sql.Connection;
 public interface Transaction extends AutoCloseable {

  /**
-   * Return the current transaction (of the default server) or null if there is
+   * Return the current transaction (of the default database) or null if there is
   * no current transaction in scope.
   * <p>
-   * This is the same as <code>Ebean.currentTransaction()</code>
+   * This is the same as <code>DB.currentTransaction()</code>
   * </p>
   * <p>
-   * This returns the current transaction for the 'default server'.  If you are using
-   * multiple EbeanServer's then use {@link EbeanServer#currentTransaction()}.
+   * This returns the current transaction for the default database.
   * </p>
-   * @see Ebean#currentTransaction()
-   * @see EbeanServer#currentTransaction()
+   *
+   * @see DB#currentTransaction()
+   * @see Database#currentTransaction()
   */
  static Transaction current() {
    return Ebean.currentTransaction();
@@ -83,7 +83,7 @@ public interface Transaction extends AutoCloseable {
   * <p>
   * This is similar to commit() but leaves the transaction "Active".
   * </p>
-   * <h3>Functions/h3>
+   * <h3>Functions</h3>
   * <ul>
   * <li>Flush the JDBC batch buffer</li>
   * <li>Call commit on the underlying JDBC connection</li>
@@ -99,7 +99,7 @@ public interface Transaction extends AutoCloseable {
   * This performs commit and completes the transaction closing underlying resources and
   * marking the transaction as "In active".
   * </p>
-   * <h3>Functions/h3>
+   * <h3>Functions</h3>
   * <ul>
   * <li>Flush the JDBC batch buffer</li>
   * <li>Call commit on the underlying JDBC connection</li>
@@ -116,7 +116,7 @@ public interface Transaction extends AutoCloseable {
   * <p>
   * This performs rollback, closes underlying resources and marks the transaction as "In active".
   * </p>
-   * <h3>Functions/h3>
+   * <h3>Functions</h3>
   * <ul>
   * <li>Call rollback on the underlying JDBC connection</li>
   * <li>Trigger any registered TransactionCallbacks</li>
@@ -136,6 +136,18 @@ public interface Transaction extends AutoCloseable {
   */
  void rollback(Throwable e) throws PersistenceException;

+  /**
+   * Set when we want nested transactions to use Savepoint's.
+   * <p>
+   * This means that for a nested transaction:
+   * <ul>
+   * <li>begin transaction maps to creating a savepoint</li>
+   * <li>commit transaction maps to releasing a savepoint</li>
+   * <li>rollback transaction maps to rollback a savepoint</li>
+   * </ul>
+   */
+  void setNestedUseSavepoint();
+
  /**
   * Mark the transaction for rollback only.
   */
@@ -151,7 +163,6 @@ public interface Transaction extends AutoCloseable {
   */
  void end();

-
  /**
   * Synonym for end() to support AutoClosable.
   */
@@ -227,13 +238,12 @@ public interface Transaction extends AutoCloseable {
   * Refer to {@link ServerConfig#setSkipCacheAfterWrite(boolean)} for configuring the default behavior
   * for using the L2 bean cache in transactions spanning multiple query/persist requests.
   * </p>
-   * <p>
+   *
   * <pre>{@code
   *
   *   // assume Customer has L2 bean caching enabled ...
   *
-   *   Transaction transaction = Ebean.beginTransaction();
-   *   try {
+   *   try (Transaction transaction = DB.beginTransaction()) {
   *
   *     // this uses L2 bean cache as the transaction
   *     // ... is considered "query only" at this point
@@ -241,7 +251,7 @@ public interface Transaction extends AutoCloseable {
   *
   *     // transaction no longer "query only" once
   *     // ... a bean has been saved etc
-   *     Ebean.save(someBean);
+   *     someBean.save();
   *
   *     // will NOT use L2 bean cache as the transaction
   *     // ... is no longer considered "query only"
@@ -261,8 +271,7 @@ public interface Transaction extends AutoCloseable {
   *     Customer.find.byId(99); // skips l2 bean cache
   *
   *
-   *   } finally {
-   *     transaction.end();
+   *     transaction.commit();
   *   }
   *
   * }</pre>
@@ -278,38 +287,68 @@ public interface Transaction extends AutoCloseable {
  boolean isSkipCache();

  /**
-   * Turn on or off statement batching. Statement batching can be transparent
-   * for drivers and databases that support getGeneratedKeys. Otherwise you may
-   * wish to specifically control when batching is used via this method.
-   * <p>
-   * Refer to <code>java.sql.PreparedStatement.addBatch();</code>
-   * <p>
-   * Note that you may also wish to use the setPersistCascade method to stop
-   * save and delete cascade behaviour. You may do this to have full control
-   * over the order of execution rather than the normal cascading fashion.
-   * </p>
-   * <p>
-   * Note that the <em>execution order</em> in batch mode may be different from
-   * non batch mode execution order. Also note that <em>insert behaviour</em>
-   * may be different depending on the JDBC driver and its support for
-   * getGeneratedKeys. That is, for JDBC drivers that do not support
-   * getGeneratedKeys you may not get back the generated IDs (used for inserting
-   * associated detail beans etc).
-   * </p>
+   * Turn on or off use of JDBC statement batching.
   * <p>
   * Calls to save(), delete(), insert() and execute() all support batch
-   * processing. This includes normal beans, MapBean, CallableSql and UpdateSql.
+   * processing. This includes normal beans, CallableSql and UpdateSql.
   * </p>
+   *
+   * <pre>{@code
+   *
+   * try (Transaction transaction = server.beginTransaction()) {
+   *
+   *   // turn on JDBC batch
+   *   transaction.setBatchMode(true);
+   *
+   *   // tune the batch size
+   *   transaction.setBatchSize(50);
+   *
+   *   ...
+   *
+   *   transaction.commit();
+   * }
+   *
+   * }</pre>
+   *
+   * <h3>getGeneratedKeys</h3>
   * <p>
-   * The flushing of the batched statements is automatic but you can call
-   * batchFlush when you like. Note that flushing occurs when a query is
-   * executed or when you mix UpdateSql and CallableSql with save and delete of
+   * Often with large batch inserts we want to turn off getGeneratedKeys. We do
+   * this via {@link #setBatchGetGeneratedKeys(boolean)}.
+   * Also note that some JDBC drivers do not support getGeneratedKeys in JDBC batch mode.
+   * </p>
+   * <pre>{@code
+   *
+   * try (Transaction transaction = server.beginTransaction()) {
+   *
+   *   transaction.setBatchMode(true);
+   *   transaction.setBatchSize(100);
+   *   // insert but don't bother getting back the generated keys
+   *   transaction.setBatchGetGeneratedKeys(false);
+   *
+   *
+   *   // perform lots of inserts ...
+   *   ...
+   *
+   *   transaction.commit();
+   * }
+   *
+   * }</pre>
+   *
+   * <h3>Flush</h3>
+   * <p>
+   * The batch is automatically flushed when it hits the batch size and also when we
+   * execute queries or when we mix UpdateSql and CallableSql with save and delete of
   * beans.
   * </p>
   * <p>
-   * Example: batch processing executing every 3 rows
+   * We use {@link #flush()} to explicitly flush the batch and we can use
+   * {@link #setBatchFlushOnQuery(boolean)} and {@link #setBatchFlushOnMixed(boolean)}
+   * to control the automatic flushing behaviour.
   * </p>
   * <p>
+   * Example: batch processing of CallableSql executing every 10 rows
+   * </p>
+   *
   * <pre>{@code
   *
   * String data = "This is a simple test of the batch processing"
@@ -322,49 +361,34 @@ public interface Transaction extends AutoCloseable {
   * CallableSql cs = new CallableSql(sql);
   * cs.registerOut(2, Types.INTEGER);
   *
-   * // (optional) inform eBean this stored procedure
+   * // (optional) inform Ebean this stored procedure
   * // inserts into a table called sp_test
   * cs.addModification("sp_test", true, false, false);
   *
-   * Transaction txn = ebeanServer.beginTransaction();
-   * txn.setBatchMode(true);
-   * txn.setBatchSize(3);
-   * try {
+   * try (Transaction txn = DB.beginTransaction()) {
+   *   txn.setBatchMode(true);
+   *   txn.setBatchSize(10);
+   *
   *   for (int i = 0; i < da.length;) {
   *     cs.setParameter(1, da[i]);
-   *     ebeanServer.execute(cs);
+   *     DB.execute(cs);
   *   }
   *
-   *   // NB: commit implicitly flushes
+   *   // Note: commit implicitly flushes
   *   txn.commit();
-   *
-   * } finally {
-   *   txn.end();
   * }
   *
   * }</pre>
   */
  void setBatchMode(boolean useBatch);

-  /**
-   * The JDBC batch mode to use for this transaction.
-   * <p>
-   * If this is NONE then JDBC batch can still be used for each request - save(), insert(), update() or delete()
-   * and this would be useful if the request cascades to detail beans.
-   * </p>
-   *
-   * @param persistBatchMode the batch mode to use for this transaction
-   * @see io.ebean.config.ServerConfig#setPersistBatch(PersistBatch)
-   */
-  void setBatch(PersistBatch persistBatchMode);
-
  /**
   * Return the batch mode at the transaction level.
   */
-  PersistBatch getBatch();
+  boolean isBatchMode();

  /**
-   * Set the JDBC batch mode to use for a save() or delete() request.
+   * Set the JDBC batch mode to use for a save() or delete() when cascading to children.
   * <p>
   * This only takes effect when batch mode on the transaction has not already meant that
   * JDBC batch mode is being used.
@@ -373,16 +397,19 @@ public interface Transaction extends AutoCloseable {
   * This is useful when the single save() or delete() cascades. For example, inserting a 'master' cascades
   * and inserts a collection of 'detail' beans. The detail beans can be inserted using JDBC batch.
   * </p>
+   * <p>
+   * This is effectively already turned on for all platforms apart from older Sql Server.
+   * </p>
   *
-   * @param batchOnCascadeMode the batch mode to use per save(), insert(), update() or delete()
+   * @param batchMode the batch mode to use per save(), insert(), update() or delete()
   * @see io.ebean.config.ServerConfig#setPersistBatchOnCascade(PersistBatch)
   */
-  void setBatchOnCascade(PersistBatch batchOnCascadeMode);
+  void setBatchOnCascade(boolean batchMode);

  /**
-   * Return the batch mode at the request level (for each save(), insert(), update() or delete()).
+   * Return the batch mode at the request level.
   */
-  PersistBatch getBatchOnCascade();
+  boolean isBatchOnCascade();

  /**
   * Specify the number of statements before a batch is flushed automatically.
@@ -432,4 +432,11 @@ public final class TxScope {
    return this;
  }

+  public boolean isBatchMode() {
+    return PersistBatch.ALL.equals(batch);
+  }
+
+  public boolean isBatchOnCascade() {
+    return PersistBatch.ALL.equals(batchOnCascade);
+  }
 }
@@ -41,7 +41,7 @@ package io.ebean;
 * <p>
 * <pre>{@code
 *
- * Update<Topic> update = Ebean.createUpdate(Topic.class, "incrementPostCount");
+ * Update<Topic> update = DB.createUpdate(Topic.class, "incrementPostCount");
 * update.setParameter("id", 1);
 * int rows = update.execute();
 *
@@ -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.
   */
@@ -12,8 +12,7 @@ package io.ebean;
 * <p>
 * <pre>{@code
 *
- *  int rows = ebeanServer
- *      .update(Customer.class)
+ *  int rows = DB.update(Customer.class)
 *      .set("status", Customer.Status.ACTIVE)
 *      .set("updtime", new Timestamp(System.currentTimeMillis()))
 *      .where()
@@ -39,8 +38,7 @@ package io.ebean;
 * <p>
 * <pre>{@code
 *
- *   int rows = ebeanServer
- *       .update(Customer.class)
+ *   int rows = DB.update(Customer.class)
 *       .set("status", Customer.Status.ACTIVE)
 *       .set("updtime", new Timestamp(System.currentTimeMillis()))
 *       .where()
@@ -73,8 +71,7 @@ public interface UpdateQuery<T> {
   * <p>
   * <pre>{@code
   *
-   *   int rows = ebeanServer
-   *      .update(Customer.class)
+   *   int rows = DB.update(Customer.class)
   *      .set("status", Customer.Status.ACTIVE)
   *      .set("updtime", new Timestamp(System.currentTimeMillis()))
   *      .where()
@@ -93,8 +90,7 @@ public interface UpdateQuery<T> {
   * <p>
   * <pre>{@code
   *
-   *   int rows = ebeanServer
-   *      .update(Customer.class)
+   *   int rows = DB.update(Customer.class)
   *      .setNull("notes")
   *      .where()
   *      .gt("id", 1000)
@@ -114,8 +110,7 @@ public interface UpdateQuery<T> {
   * <p>
   * <pre>{@code
   *
-   *   int rows = ebeanServer
-   *      .update(Customer.class)
+   *   int rows = DB.update(Customer.class)
   *      .setRaw("status = coalesce(status, 'A')")
   *      .where()
   *      .gt("id", 1000)
@@ -134,8 +129,7 @@ public interface UpdateQuery<T> {
   * </p>
   * <pre>{@code
   *
-   *   int rows = ebeanServer
-   *      .update(Customer.class)
+   *   int rows = DB.update(Customer.class)
   *      .setRaw("status = coalesce(status, ?)", Customer.Status.ACTIVE)
   *      .where()
   *      .gt("id", 1000)
@@ -154,9 +148,19 @@ public interface UpdateQuery<T> {
   */
  UpdateQuery<T> setProfileLocation(ProfileLocation profileLocation);

+  /**
+   * Set the label on the update query.
+   */
+  UpdateQuery<T> setLabel(String label);
+
  /**
   * Return the query expression list to add predicates to.
   */
  ExpressionList<T> where();

+  /**
+   * Execute the update returning the number of rows updated.
+   */
+  int update();
+
 }
@@ -1,5 +1,6 @@
 package io.ebean;

+import io.ebean.service.SpiFetchGroupService;
 import io.ebean.service.SpiProfileLocationFactory;
 import io.ebean.service.SpiRawSqlService;

@@ -15,6 +16,16 @@ class XServiceProvider {

  private static SpiProfileLocationFactory profileLocationFactory = initProfileLocation();

+  private static SpiFetchGroupService fetchGroupService = initSpiFetchGroupService();
+
+  private static SpiFetchGroupService initSpiFetchGroupService() {
+    Iterator<SpiFetchGroupService> loader = ServiceLoader.load(SpiFetchGroupService.class).iterator();
+    if (loader.hasNext()) {
+      return loader.next();
+    }
+    throw new IllegalStateException("No service implementation found for SpiFetchGroupService?");
+  }
+
  private static SpiRawSqlService initRawSql() {

    Iterator<SpiRawSqlService> loader = ServiceLoader.load(SpiRawSqlService.class).iterator();
@@ -47,4 +58,17 @@ class XServiceProvider {
    return profileLocationFactory;
  }

+  /**
+   * Return the FetchGroup with the given select clause.
+   */
+  static <T> FetchGroup<T> fetchGroupOf(Class<T> cls, String select) {
+    return fetchGroupService.of(cls, select);
+  }
+
+  /**
+   * Return the FetchGroupBuilder with the given select clause.
+   */
+  static <T> FetchGroupBuilder<T> fetchGroupOf(Class<T> cls) {
+    return fetchGroupService.of(cls);
+  }
 }
@@ -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.
   */
@@ -9,7 +9,7 @@ package io.ebean.bean;
 public interface BeanCollectionLoader {

  /**
-   * Return the name of the associated EbeanServer.
+   * Return the name of the associated Database.
   */
  String getName();

@@ -9,7 +9,7 @@ package io.ebean.bean;
 public interface BeanLoader {

  /**
-   * Return the name of the associated EbeanServer.
+   * Return the name of the associated Database.
   */
  String getName();

@@ -43,6 +43,7 @@ public final class CallStack implements Serializable {
    return hc;
  }

+  @Override
  public int hashCode() {
    return hc;
  }
@@ -52,6 +52,8 @@ public final class EntityBeanIntercept implements Serializable {
   */
  private int state;

+  private boolean forceUpdate;
+
  private boolean readOnly;

  private boolean dirty;
@@ -69,27 +71,39 @@ public final class EntityBeanIntercept implements Serializable {
  /**
   * Used when a bean is partially filled.
   */
-  private final boolean[] loadedProps;
-
-  private boolean fullyLoadedBean;
+  private static final byte FLAG_LOADED_PROP = 1;

  /**
   * Set of changed properties.
   */
-  private boolean[] changedProps;
+  private static final byte FLAG_CHANGED_PROP = 2;

  /**
   * Flags indicating if a property is a dirty embedded bean. Used to distingush
   * between an embedded bean being completely overwritten and one of its
   * embedded properties being made dirty.
   */
-  private boolean[] embeddedDirty;
+  private static final byte FLAG_EMBEDDED_DIRTY = 4;
+
+  /**
+   * Flags indicating if a property is a dirty embedded bean. Used to distingush
+   * between an embedded bean being completely overwritten and one of its
+   * embedded properties being made dirty.
+   */
+  private static final byte FLAG_ORIG_VALUE_SET = 8;
+
+  private final byte[] flags;
+
+  private boolean fullyLoadedBean;

  private Object[] origValues;

+  private Exception[] loadErrors;
+
  private int lazyLoadProperty = -1;

  private Object ownerId;
+  private int sortOrder;

  /**
   * Create a intercept with a given entity.
@@ -99,7 +113,7 @@ public final class EntityBeanIntercept implements Serializable {
   */
  public EntityBeanIntercept(Object ownerBean) {
    this.owner = (EntityBean) ownerBean;
-    this.loadedProps = new boolean[owner._ebean_getPropertyNames().length];
+    this.flags = new byte[owner._ebean_getPropertyNames().length];
  }

  /**
@@ -130,6 +144,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.
   */
@@ -196,8 +224,8 @@ public final class EntityBeanIntercept implements Serializable {
   * Check each property to see if the bean is partially loaded.
   */
  public boolean isPartial() {
-    for (boolean loadedProp : loadedProps) {
-      if (!loadedProp) {
+    for (byte flag : flags) {
+      if ((flag & FLAG_LOADED_PROP) == 0) {
        return true;
      }
    }
@@ -242,10 +270,10 @@ public final class EntityBeanIntercept implements Serializable {
   * Return true if only the Id property has been loaded.
   */
  public boolean hasIdOnly(int idIndex) {
-    for (int i = 0; i < loadedProps.length; i++) {
+    for (int i = 0; i < flags.length; i++) {
      if (i == idIndex) {
-        if (!loadedProps[i]) return false;
-      } else if (loadedProps[i]) {
+        if ((flags[i] & FLAG_LOADED_PROP) == 0) return false;
+      } else if ((flags[i] & FLAG_LOADED_PROP) != 0) {
        return false;
      }
    }
@@ -267,9 +295,9 @@ public final class EntityBeanIntercept implements Serializable {
    if (idPos > -1) {
      // For cases where properties are set on constructor
      // set every non Id property to unloaded (for lazy loading)
-      for (int i = 0; i < loadedProps.length; i++) {
+      for (int i = 0; i < flags.length; i++) {
        if (i != idPos) {
-          loadedProps[i] = false;
+          flags[i] &= ~FLAG_LOADED_PROP;
        }
      }
    }
@@ -291,6 +319,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.
   */
@@ -321,7 +363,9 @@ public final class EntityBeanIntercept implements Serializable {
    this.owner._ebean_setEmbeddedLoaded();
    this.lazyLoadProperty = -1;
    this.origValues = null;
-    this.changedProps = null;
+    for (int i = 0; i < flags.length; i++) {
+      flags[i] &= ~(FLAG_CHANGED_PROP + FLAG_ORIG_VALUE_SET);
+    }
    this.dirty = false;
  }

@@ -444,7 +488,11 @@ public final class EntityBeanIntercept implements Serializable {
    if (position == -1) {
      throw new IllegalArgumentException("Property " + propertyName + " not found");
    }
-    loadedProps[position] = loaded;
+    if (loaded) {
+      flags[position] |= FLAG_LOADED_PROP;
+    } else {
+      flags[position] &= ~FLAG_LOADED_PROP;
+    }
  }

  /**
@@ -452,22 +500,22 @@ public final class EntityBeanIntercept implements Serializable {
   * constructor.
   */
  public void setPropertyUnloaded(int propertyIndex) {
-    loadedProps[propertyIndex] = false;
+    flags[propertyIndex] &= ~FLAG_LOADED_PROP;
  }

  /**
   * Set the property to be loaded.
   */
  public void setLoadedProperty(int propertyIndex) {
-    loadedProps[propertyIndex] = true;
+    flags[propertyIndex] |= FLAG_LOADED_PROP;
  }

  /**
   * Set all properties to be loaded (post insert).
   */
  public void setLoadedPropertyAll() {
-    for (int i = 0; i < loadedProps.length; i++) {
-      loadedProps[i] = true;
+    for (int i = 0; i < flags.length; i++) {
+      flags[i] |= FLAG_LOADED_PROP;
    }
  }

@@ -475,14 +523,14 @@ public final class EntityBeanIntercept implements Serializable {
   * Return true if the property is loaded.
   */
  public boolean isLoadedProperty(int propertyIndex) {
-    return loadedProps[propertyIndex];
+    return (flags[propertyIndex] & FLAG_LOADED_PROP) != 0;
  }

  /**
   * Return true if the property is considered changed.
   */
  public boolean isChangedProperty(int propertyIndex) {
-    return (changedProps != null && changedProps[propertyIndex]);
+    return (flags[propertyIndex] & FLAG_CHANGED_PROP) != 0;
  }

  /**
@@ -490,8 +538,7 @@ public final class EntityBeanIntercept implements Serializable {
   * embedded properties is dirty.
   */
  public boolean isDirtyProperty(int propertyIndex) {
-    return (changedProps != null && changedProps[propertyIndex]
-      || embeddedDirty != null && embeddedDirty[propertyIndex]);
+    return (flags[propertyIndex] & (FLAG_CHANGED_PROP + FLAG_EMBEDDED_DIRTY)) != 0;
  }

  /**
@@ -503,43 +550,44 @@ public final class EntityBeanIntercept implements Serializable {
  }

  public void setChangedProperty(int propertyIndex) {
-    if (changedProps == null) {
-      changedProps = new boolean[owner._ebean_getPropertyNames().length];
-    }
-    changedProps[propertyIndex] = true;
+    flags[propertyIndex] |= FLAG_CHANGED_PROP;
  }

  /**
   * Set that an embedded bean has had one of its properties changed.
   */
  private void setEmbeddedPropertyDirty(int propertyIndex) {
-    if (embeddedDirty == null) {
-      embeddedDirty = new boolean[owner._ebean_getPropertyNames().length];
-    }
-    embeddedDirty[propertyIndex] = true;
+    flags[propertyIndex] |= FLAG_EMBEDDED_DIRTY;
  }

  private void setOriginalValue(int propertyIndex, Object value) {
    if (origValues == null) {
      origValues = new Object[owner._ebean_getPropertyNames().length];
    }
-    if (origValues[propertyIndex] == null) {
+    if ((flags[propertyIndex] & FLAG_ORIG_VALUE_SET) == 0) {
+      flags[propertyIndex] |= FLAG_ORIG_VALUE_SET;
      origValues[propertyIndex] = value;
    }
  }

+  /**
+   * 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.
   */
  public void setNewBeanForUpdate() {

-    if (changedProps == null) {
-      changedProps = new boolean[owner._ebean_getPropertyNames().length];
-    }
-
-    for (int i = 0; i < loadedProps.length; i++) {
-      if (loadedProps[i]) {
-        changedProps[i] = true;
+    for (int i = 0; i < flags.length; i++) {
+      if ((flags[i] & FLAG_LOADED_PROP) != 0) {
+        flags[i] |= FLAG_CHANGED_PROP;
      }
    }
    setDirty(true);
@@ -553,8 +601,8 @@ public final class EntityBeanIntercept implements Serializable {
      return null;
    }
    Set<String> props = new LinkedHashSet<>();
-    for (int i = 0; i < loadedProps.length; i++) {
-      if (loadedProps[i]) {
+    for (int i = 0; i < flags.length; i++) {
+      if ((flags[i] & FLAG_LOADED_PROP) != 0) {
        props.add(getProperty(i));
      }
    }
@@ -568,12 +616,8 @@ public final class EntityBeanIntercept implements Serializable {
    int len = getPropertyLength();
    boolean[] dirties = new boolean[len];
    for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
-        dirties[i] = true;
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
-        // an embedded property has been changed - recurse
-        dirties[i] = true;
-      }
+      // this, or an embedded property has been changed - recurse
+      dirties[i] = (flags[i] & (FLAG_CHANGED_PROP + FLAG_EMBEDDED_DIRTY)) != 0;
    }
    return dirties;
  }
@@ -593,11 +637,11 @@ public final class EntityBeanIntercept implements Serializable {
  public void addDirtyPropertyNames(Set<String> props, String prefix) {
    int len = getPropertyLength();
    for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
        // the property has been changed on this bean
        String propName = (prefix == null ? getProperty(i) : prefix + getProperty(i));
        props.add(propName);
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
        // an embedded property has been changed - recurse
        EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
        embeddedBean._ebean_getIntercept().addDirtyPropertyNames(props, getProperty(i) + ".");
@@ -613,12 +657,12 @@ public final class EntityBeanIntercept implements Serializable {
    String[] names = owner._ebean_getPropertyNames();
    int len = getPropertyLength();
    for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
        // the property has been changed on this bean
        if (propertyNames.contains(names[i])) {
          return true;
        }
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
        if (propertyNames.contains(names[i])) {
          return true;
        }
@@ -642,15 +686,16 @@ public final class EntityBeanIntercept implements Serializable {
  public void addDirtyPropertyValues(Map<String, ValuePair> dirtyValues, String prefix) {
    int len = getPropertyLength();
    for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
        // the property has been changed on this bean
        String propName = (prefix == null ? getProperty(i) : prefix + getProperty(i));
        Object newVal = owner._ebean_getField(i);
        Object oldVal = getOrigValue(i);
+        if (!areEqual(oldVal, newVal)) {
+          dirtyValues.put(propName, new ValuePair(newVal, oldVal));
+        }

-        dirtyValues.put(propName, new ValuePair(newVal, oldVal));
-
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
        // an embedded property has been changed - recurse
        EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
        embeddedBean._ebean_getIntercept().addDirtyPropertyValues(dirtyValues, getProperty(i) + ".");
@@ -664,13 +709,15 @@ public final class EntityBeanIntercept implements Serializable {
  public void addDirtyPropertyValues(BeanDiffVisitor visitor) {
    int len = getPropertyLength();
    for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
        // the property has been changed on this bean
        Object newVal = owner._ebean_getField(i);
        Object oldVal = getOrigValue(i);
-        visitor.visit(i, newVal, oldVal);
+        if (!areEqual(oldVal, newVal)) {
+          visitor.visit(i, newVal, oldVal);
+        }

-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
        // an embedded property has been changed - recurse
        EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
        visitor.visitPush(i);
@@ -693,11 +740,14 @@ 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]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
        sb.append(i).append(',');
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
        // an embedded property has been changed - recurse
        EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
        sb.append(i).append('[');
@@ -721,15 +771,12 @@ public final class EntityBeanIntercept implements Serializable {
    return sb;
  }

-  /**
-   * Return the set of property names for changed properties.
-   */
-  public boolean[] getChanged() {
-    return changedProps;
-  }
-
  public boolean[] getLoaded() {
-    return loadedProps;
+    boolean[] ret= new boolean[flags.length];
+    for (int i = 0; i < ret.length; i++) {
+      ret[i] = (flags[i] & FLAG_LOADED_PROP) != 0;
+    }
+    return ret;
  }

  /**
@@ -777,14 +824,14 @@ public final class EntityBeanIntercept implements Serializable {
   */
  private void loadBeanInternal(int loadProperty, BeanLoader loader) {

-    if (loadedProps == null || loadedProps[loadProperty]) {
+    if ((flags[loadProperty] & FLAG_LOADED_PROP) != 0) {
      // race condition where multiple threads calling preGetter concurrently
      return;
    }

    if (lazyLoadFailure) {
      // failed when batch lazy loaded by another bean in the batch
-      throw new EntityNotFoundException("Lazy loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted");
+      throw new EntityNotFoundException("(Lazy) loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted");
    }

    if (lazyLoadProperty == -1) {
@@ -843,7 +890,7 @@ public final class EntityBeanIntercept implements Serializable {
   * Called when a BeanCollection is initialised automatically.
   */
  public void initialisedMany(int propertyIndex) {
-    loadedProps[propertyIndex] = true;
+    flags[propertyIndex] |= FLAG_LOADED_PROP;
  }

  private void preGetterCallback(int propertyIndex) {
@@ -897,15 +944,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 +1096,57 @@ 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;
+  }
+
+  /**
+   * Set the load error that happened on this property.
+   */
+  public void setLoadError(int propertyIndex, Exception t) {
+    if (loadErrors == null) {
+      loadErrors = new Exception[owner._ebean_getPropertyNames().length];
+    }
+    loadErrors[propertyIndex] = t;
+    flags[propertyIndex] |= FLAG_LOADED_PROP;
+  }
+
+  /**
+   * Returns the loadErrors.
+   */
+  public Map<String, Exception> getLoadErrors() {
+    if (loadErrors == null) {
+      return null;
+    }
+    Map<String, Exception> ret = null;
+    int len = getPropertyLength();
+    for (int i = 0; i < len; i++) {
+      Exception loadError = loadErrors[i];
+      if (loadError != null) {
+        if (ret == null) {
+          ret = new LinkedHashMap<>();
+        }
+        ret.put(getProperty(i), loadError);
+      }
+    }
+    return ret;
  }
 }
@@ -0,0 +1,54 @@
+package io.ebean.cache;
+
+import java.util.Set;
+
+/**
+ * For query cache entries we additionally hold the dependent tables and timestamp for the query result.
+ * <p>
+ * We use the dependent tables and timestamp to validate that tables the query joins to have not been
+ * modified since the query cache entry was cached. If any dependent tables have since been modified
+ * the query cache entry is treated as invalid.
+ * </p>
+ */
+public class QueryCacheEntry {
+
+  private final Object value;
+
+  private final Set<String> dependentTables;
+
+  private final long timestamp;
+
+  /**
+   * Create with dependent tables and timestamp.
+   *
+   * @param value           The query result being cached
+   * @param dependentTables The extra tables the query is dependent on (joins to)
+   * @param timestamp       The timestamp that the query uses to check for modifications
+   */
+  public QueryCacheEntry(Object value, Set<String> dependentTables, long timestamp) {
+    this.value = value;
+    this.dependentTables = dependentTables;
+    this.timestamp = timestamp;
+  }
+
+  /**
+   * Return the actual query result.
+   */
+  public Object getValue() {
+    return value;
+  }
+
+  /**
+   * Return the tables the query result is dependent on.
+   */
+  public Set<String> getDependentTables() {
+    return dependentTables;
+  }
+
+  /**
+   * Return the timestamp used to check for modifications on the dependent tables.
+   */
+  public long getTimestamp() {
+    return timestamp;
+  }
+}
@@ -0,0 +1,12 @@
+package io.ebean.cache;
+
+/**
+ * Used to validate that a query cache entry is still valid based on dependent tables.
+ */
+public interface QueryCacheEntryValidate {
+
+  /**
+   * Return true if the entry is still valid based on dependent tables.
+   */
+  boolean isValid(QueryCacheEntry queryCacheEntry);
+}
@@ -0,0 +1,65 @@
+package io.ebean.cache;
+
+import io.ebean.config.CurrentTenantProvider;
+
+/**
+ * Configuration used to create ServerCache instances.
+ */
+public class ServerCacheConfig {
+
+  private final ServerCacheType type;
+  private final String cacheKey;
+  private final ServerCacheOptions cacheOptions;
+  private final CurrentTenantProvider tenantProvider;
+  private final QueryCacheEntryValidate queryCacheEntryValidate;
+
+  public ServerCacheConfig(ServerCacheType type, String cacheKey, ServerCacheOptions cacheOptions, CurrentTenantProvider tenantProvider, QueryCacheEntryValidate queryCacheEntryValidate) {
+    this.type = type;
+    this.cacheKey = cacheKey;
+    this.cacheOptions = cacheOptions;
+    this.tenantProvider = tenantProvider;
+    this.queryCacheEntryValidate = queryCacheEntryValidate;
+  }
+
+  /**
+   * Return the cache type.
+   */
+  public ServerCacheType getType() {
+    return type;
+  }
+
+  /**
+   * Return the name of the cache.
+   */
+  public String getCacheKey() {
+    return cacheKey;
+  }
+
+  /**
+   * Return the tuning options.
+   */
+  public ServerCacheOptions getCacheOptions() {
+    return cacheOptions;
+  }
+
+  /**
+   * Return the current tenant provider.
+   */
+  public CurrentTenantProvider getTenantProvider() {
+    return tenantProvider;
+  }
+
+  /**
+   * Return the service that provides validation for query cache entries.
+   */
+  public QueryCacheEntryValidate getQueryCacheEntryValidate() {
+    return queryCacheEntryValidate;
+  }
+
+  /**
+   * Return true if the cache is a query cache.
+   */
+  public boolean isQueryCache() {
+    return type == ServerCacheType.QUERY;
+  }
+}
@@ -1,7 +1,5 @@
 package io.ebean.cache;

-import io.ebean.config.CurrentTenantProvider;
-
 /**
 * Defines method for constructing caches for beans and queries.
 */
@@ -10,6 +8,15 @@ public interface ServerCacheFactory {
  /**
   * Create the cache for the given type with options.
   */
-  ServerCache createCache(ServerCacheType type, String cacheKey, CurrentTenantProvider tenantProvider, ServerCacheOptions cacheOptions);
+  ServerCache createCache(ServerCacheConfig config);

+  /**
+   * Return a ServerCacheNotify that we will send ServerCacheNotification events to.
+   * <p>
+   * This is used if a ServerCacheNotifyPlugin is not supplied.
+   * </p>
+   *
+   * @param listener The listener that should be used to process the notification events.
+   */
+  ServerCacheNotify createCacheNotify(ServerCacheNotify listener);
 }
@@ -0,0 +1,34 @@
+package io.ebean.cache;
+
+import java.util.Set;
+
+/**
+ * Notification event that dependent tables have been modified.
+ * <p>
+ * This is sent to other interested servers (in the cluster).
+ * </p>
+ */
+public class ServerCacheNotification {
+
+  private final long modifyTimestamp;
+
+  private final Set<String> dependentTables;
+
+  public ServerCacheNotification(long modifyTimestamp, Set<String> dependentTables) {
+    this.modifyTimestamp = modifyTimestamp;
+    this.dependentTables = dependentTables;
+  }
+
+  @Override
+  public String toString() {
+    return "ts:" + modifyTimestamp + " tables:" + dependentTables;
+  }
+
+  public long getModifyTimestamp() {
+    return modifyTimestamp;
+  }
+
+  public Set<String> getDependentTables() {
+    return dependentTables;
+  }
+}
@@ -0,0 +1,12 @@
+package io.ebean.cache;
+
+/**
+ * Interface for both listening to notification changes and sending them to other members of the cluster.
+ */
+public interface ServerCacheNotify {
+
+  /**
+   * Notify other server cache members of the table modifications or process the notifications.
+   */
+  void notify(ServerCacheNotification notification);
+}
@@ -0,0 +1,17 @@
+package io.ebean.cache;
+
+import io.ebean.config.ServerConfig;
+
+/**
+ * Plugin that provides a ServerCacheNotify implementation.
+ * <p>
+ * Is supplied this will be used to send the ServerCacheNotification event to other cluster members.
+ * </p>
+ */
+public interface ServerCacheNotifyPlugin {
+
+  /**
+   * Create a ServerCacheNotify implementation given the server configuration.
+   */
+  ServerCacheNotify create(ServerConfig serverConfig);
+}
@@ -12,6 +12,7 @@ public class ServerCacheOptions {
  private int maxIdleSecs;
  private int maxSecsToLive;
  private int trimFrequency;
+  private boolean nearCache;

  /**
   * Construct with no set options.
@@ -40,6 +41,14 @@ public class ServerCacheOptions {
    this.trimFrequency = cacheTuning.trimFrequency();
  }

+  /**
+   * Create with nearCache option.
+   */
+  public ServerCacheOptions(boolean nearCache, CacheBeanTuning tuning) {
+    this(tuning);
+    this.nearCache = nearCache;
+  }
+
  /**
   * Apply any settings from the default settings that have not already been
   * specifically set.
@@ -70,9 +79,33 @@ public class ServerCacheOptions {
    copy.maxIdleSecs = maxIdleSecs;
    copy.maxSecsToLive = maxSecsToLive;
    copy.trimFrequency = trimFrequency;
+    copy.nearCache = this.nearCache;
    return copy;
  }

+  /**
+   * Return a copy of this object with nearCache option.
+   */
+  public ServerCacheOptions copy(boolean nearCache) {
+    ServerCacheOptions copy = copy();
+    copy.nearCache = nearCache;
+    return copy;
+  }
+
+  /**
+   * Return true if nearCache was explicitly turned on.
+   */
+  public boolean isNearCache() {
+    return nearCache;
+  }
+
+  /**
+   * Turn on nearCache option.
+   */
+  public void setNearCache(boolean nearCache) {
+    this.nearCache = nearCache;
+  }
+
  /**
   * Return the maximum cache size.
   */
@@ -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;

 /**
@@ -21,7 +20,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
  protected boolean disableLazyLoad;

  /**
-   * The EbeanServer this is associated with. (used for lazy fetch).
+   * The Database this is associated with. (used for lazy fetch).
   */
  protected transient BeanCollectionLoader loader;

@@ -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
@@ -123,7 +123,7 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
  private void initClear() {
    synchronized (this) {
      if (map == null) {
-        if (modifyListening) {
+        if (!disableLazyLoad && modifyListening) {
          lazyLoadCollection(true);
        } else {
          map = new LinkedHashMap<>();
@@ -135,7 +135,11 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
  private void init() {
    synchronized (this) {
      if (map == null) {
-        lazyLoadCollection(false);
+        if (disableLazyLoad) {
+          map = new LinkedHashMap<>();
+        } else {
+          lazyLoadCollection(false);
+        }
      }
    }
  }
@@ -273,14 +277,16 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
    checkReadOnly();
    init();
    if (modifyListening) {
-      Object oldBean = map.put(key, value);
+      E oldBean = map.put(key, value);
      if (value != oldBean) {
        // register the add of the new and the removal of the old
        modifyAddition(value);
        modifyRemoval(oldBean);
      }
+      return oldBean;
+    } else {
+      return map.put(key, value);
    }
-    return map.put(key, value);
  }

  @Override
@@ -295,8 +301,9 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
          modifyRemoval(oldBean);
        }
      }
+    } else {
+      map.putAll(puts);
    }
-    map.putAll(puts);
  }

  @Override
@@ -116,7 +116,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
  private void initClear() {
    synchronized (this) {
      if (set == null) {
-        if (modifyListening) {
+        if (!disableLazyLoad && modifyListening) {
          lazyLoadCollection(true);
        } else {
          set = new LinkedHashSet<>();
@@ -128,7 +128,11 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
  private void init() {
    synchronized (this) {
      if (set == null) {
-        lazyLoadCollection(true);
+        if (disableLazyLoad) {
+          set = new LinkedHashSet<>();
+        } else {
+          lazyLoadCollection(true);
+        }
      }
    }
  }
@@ -377,7 +381,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
      throw new IllegalStateException("This collection is in ReadOnly mode");
    }
  }
-  
+
  @Override
  public BeanCollection<E> getShallowCopy() {
    BeanSet<E> copy = new BeanSet<>(new LinkedHashSet<>(set));
@@ -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.
   */
@@ -0,0 +1,18 @@
+package io.ebean.config;
+
+/**
+ * Used to provide some automatic configuration early in the creation of a Database.
+ */
+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);
+
+}
@@ -1,7 +1,7 @@
 package io.ebean.config;

 /**
- * Defines the AutoTune behaviour for a EbeanServer.
+ * Defines the AutoTune behaviour for a Database.
 */
 public class AutoTuneConfig {

@@ -0,0 +1,15 @@
+package io.ebean.config;
+
+/**
+ * Throw when an processing an entity bean that is not bytecode enhanced.
+ *
+ * Refer: https://ebean.io/docs/trouble-shooting#not-enhanced
+ */
+public class BeanNotEnhancedException extends IllegalStateException {
+
+  private static final long serialVersionUID = 3008101919425876799L;
+
+  public BeanNotEnhancedException(String msg) {
+    super(msg);
+  }
+}
@@ -0,0 +1,15 @@
+package io.ebean.config;
+
+/**
+ * Throw when an processing thinks a bean is not registered.
+ *
+ * Refer: https://ebean.io/docs/trouble-shooting#not-registered
+ */
+public class BeanNotRegisteredException extends IllegalStateException {
+
+  private static final long serialVersionUID = -1411298126011136552L;
+
+  public BeanNotRegisteredException(String msg) {
+    super(msg);
+  }
+}
@@ -3,7 +3,7 @@ package io.ebean.config;
 import java.util.Properties;

 /**
- * Configuration for the container that holds the EbeanServer instances.
+ * Configuration for the container that holds the Database instances.
 * <p>
 * Provides configuration for cluster communication (if clustering is used). The cluster communication is
 * used to invalidate appropriate parts of the L2 cache across the cluster.
@@ -0,0 +1,44 @@
+package io.ebean.config;
+
+import io.ebean.DatabaseFactory;
+
+/**
+ * The configuration used for creating a Database.
+ * <p>
+ * Used to programmatically construct an Database and optionally register it
+ * with the DB singleton.
+ * </p>
+ * <p>
+ * If you just use DB thout this programmatic configuration Ebean will read
+ * the application.properties file and take the configuration from there. This usually
+ * includes searching the class path and automatically registering any entity
+ * classes and listeners etc.
+ * </p>
+ * <pre>{@code
+ *
+ * DatabaseConfig config = new DatabaseConfig();
+ *
+ * // read the ebean.properties and load
+ * // those settings into this serverConfig object
+ * config.loadFromProperties();
+ *
+ * // explicitly register the entity beans to avoid classpath scanning
+ * config.addClass(Customer.class);
+ * config.addClass(User.class);
+ *
+ * Database db = DatabaseFactory.create(config);
+ *
+ * }</pre>
+ *
+ * <p>
+ * Note that ServerConfigProvider provides a standard Java ServiceLoader mechanism that can
+ * be used to apply configuration to the DatabaseConfig.
+ * </p>
+ *
+ * @author emcgreal
+ * @author rbygrave
+ * @see DatabaseFactory
+ */
+public class DatabaseConfig extends ServerConfig {
+
+}
@@ -1,11 +1,15 @@
 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;

@@ -23,39 +27,13 @@ public class DbMigrationConfig {
   */
  protected Platform platform;

-  /**
-   * Set to true if the DB migration should be generated on server start.
-   */
-  protected boolean generate;
-
-  /**
-   * The migration version name (typically FlywayDb compatible).
-   * <p>
-   * Example: 1.1.1_2
-   * <p>
-   * The version is expected to be the combination of the current pom version plus
-   * a 'feature' id. The combined version must be unique and ordered to work with
-   * FlywayDb so each developer sets a unique version so that the migration script
-   * generated is unique (typically just prior to being submitted as a merge request).
-   */
-  protected String version;
-
-  /**
-   * Description text that can be appended to the version to become the ddl script file name.
-   * <p>
-   * So if the name is "a foo table" then the ddl script file could be:
-   * "1.1.1_2__a-foo-table.sql"
-   * <p>
-   * When the DB migration relates to a git feature (merge request) then this description text
-   * is a short description of the feature.
-   */
-  protected String name;
-
  /**
   * Resource path for the migration xml and sql.
   */
  protected String migrationPath = "dbmigration";

+  protected String migrationInitPath = "dbinit";
+
  /**
   * Subdirectory the model xml files go into.
   */
@@ -70,13 +48,6 @@ public class DbMigrationConfig {

  protected String modelSuffix = ".model.xml";

-  protected boolean includeGeneratedFileComment;
-
-  /**
-   * The version of a pending drop that should be generated as the next migration.
-   */
-  protected String generatePendingDrop;
-
  /**
   * For running migration the DB table that holds migration execution status.
   */
@@ -97,6 +68,16 @@ public class DbMigrationConfig {
   */
  protected Map<String, String> runPlaceholderMap;

+  /**
+   * DB schema used for the migration (and testing).
+   */
+  protected String dbSchema;
+
+  /**
+   * Set to true if we consider this the 'default schema' (Postgres schema that matches DB username)
+   */
+  protected boolean defaultDbSchema;
+
  /**
   * DB user used to run the DB migration.
   */
@@ -116,6 +97,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>
@@ -133,6 +119,15 @@ public class DbMigrationConfig {
    this.platform = platform;
  }

+  /**
+   * Return the path for normal migrations or dbinit migrations.
+   *
+   * @param dbinitMigration When true return the path for dbinit migrations.
+   */
+  public String getMigrationPath(boolean dbinitMigration) {
+    return dbinitMigration ? migrationInitPath : migrationPath;
+  }
+
  /**
   * Return the resource path for db migrations.
   */
@@ -145,7 +140,7 @@ public class DbMigrationConfig {
   * <p>
   * The default of "dbmigration" is reasonable in most cases. You may look to set this
   * to be something like "dbmigration/myapp" where myapp gives it a unique resource path
-   * in the case there are multiple EbeanServer applications in the single classpath.
+   * in the case there are multiple Database applications in the single classpath.
   * </p>
   */
  public void setMigrationPath(String migrationPath) {
@@ -208,52 +203,6 @@ public class DbMigrationConfig {
    this.applyPrefix = applyPrefix;
  }

-  /**
-   * Return true if the generated file comment should be included.
-   */
-  public boolean isIncludeGeneratedFileComment() {
-    return includeGeneratedFileComment;
-  }
-
-  /**
-   * Set to true if the generated file comment should be included.
-   */
-  public void setIncludeGeneratedFileComment(boolean includeGeneratedFileComment) {
-    this.includeGeneratedFileComment = includeGeneratedFileComment;
-  }
-
-  /**
-   * Return the migration version (or "next") to generate pending drops for.
-   */
-  public String getGeneratePendingDrop() {
-    return generatePendingDrop;
-  }
-
-  /**
-   * Set the migration version (or "next") to generate pending drops for.
-   */
-  public void setGeneratePendingDrop(String generatePendingDrop) {
-    this.generatePendingDrop = generatePendingDrop;
-  }
-
-  /**
-   * Set the migration version.
-   * <p>
-   * Note that version set via System property or environment variable <code>ddl.migration.version</code> takes precedence.
-   */
-  public void setVersion(String version) {
-    this.version = version;
-  }
-
-  /**
-   * Set the migration name.
-   * <p>
-   * Note that name set via System property or environment variable <code>ddl.migration.name</code> takes precedence.
-   */
-  public void setName(String name) {
-    this.name = name;
-  }
-
  /**
   * Return the table name that holds the migration run details
   * (used by DB Migration runner only).
@@ -363,6 +312,39 @@ public class DbMigrationConfig {
    this.dbPassword = dbPassword;
  }

+  /**
+   * Return the DB schema to use (for migration, testing etc).
+   */
+  public String getDbSchema() {
+    String schema = readEnvironment("ddl.migration.schema");
+    if (schema != null) {
+      return schema;
+    }
+    return dbSchema;
+  }
+
+  /**
+   * Set the Db schema to use.
+   */
+  public void setDbSchema(String dbSchema) {
+    this.dbSchema = dbSchema;
+  }
+
+  /**
+   * Set the Db schema if it hasn't already been defined.
+   */
+  public void setDefaultDbSchema(String dbSchema) {
+    this.defaultDbSchema = true;
+    this.dbSchema = dbSchema;
+  }
+
+  /**
+   * Return true if this is considered the default DB schema (Postgres schema matching DB username).
+   */
+  public boolean isDefaultDbSchema() {
+    return defaultDbSchema;
+  }
+
  /**
   * Return migration versions that should be added to history without running.
   */
@@ -387,6 +369,25 @@ 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() {
+    if (ddlHeader != null && !ddlHeader.isEmpty()) {
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${version}", EbeanVersion.getVersion());
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${timestamp}", ZonedDateTime.now().format( DateTimeFormatter.ISO_INSTANT ));
+    }
+    return ddlHeader;
+  }
+
+  /**
+   * Set the header prepended to the DDL.
+   */
+  public void setDdlHeader(String ddlHeader) {
+    this.ddlHeader = ddlHeader;
+  }
+
  /**
   * Set migration versions that should have their checksum reset and not run.
   * <p>
@@ -428,70 +429,31 @@ public class DbMigrationConfig {
  public void loadSettings(PropertiesWrapper properties, String serverName) {

    migrationPath = properties.get("migration.migrationPath", migrationPath);
+    migrationInitPath = properties.get("migration.migrationInitPath", migrationInitPath);
    modelPath = properties.get("migration.modelPath", modelPath);
    applyPrefix = properties.get("migration.applyPrefix", applyPrefix);
    applySuffix = properties.get("migration.applySuffix", applySuffix);
    modelSuffix = properties.get("migration.modelSuffix", modelSuffix);
-    includeGeneratedFileComment = properties.getBoolean("migration.includeGeneratedFileComment", includeGeneratedFileComment);
-    generatePendingDrop = properties.get("migration.generatePendingDrop", generatePendingDrop);

    platform = properties.getEnum(Platform.class, "migration.platform", platform);
-
-    generate = properties.getBoolean("migration.generate", generate);
-    version = properties.get("migration.version", version);
-    name = properties.get("migration.name", name);
    patchInsertOn = properties.get("migration.patchInsertOn", patchInsertOn);
    patchResetChecksumOn = properties.get("migration.patchResetChecksumOn", patchResetChecksumOn);

    runMigration = properties.getBoolean("migration.run", runMigration);
    metaTable = properties.get("migration.metaTable", metaTable);
    runPlaceholders = properties.get("migration.placeholders", runPlaceholders);
+    dbSchema = properties.get("migration.dbSchema", dbSchema);

-    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);
-  }
-
-  /**
-   * Return the migration version (typically FlywayDb compatible).
-   * <p>
-   * Example: 1.1.1_2
-   * <p>
-   * The version is expected to be the combination of the current pom version plus
-   * a 'feature' id. The combined version must be unique and ordered to work with
-   * FlywayDb so each developer sets a unique version so that the migration script
-   * generated is unique (typically just prior to being submitted as a merge request).
-   */
-  public String getVersion() {
-    String envVersion = readEnvironment("ddl.migration.version");
-    if (!isEmpty(envVersion)) {
-      return envVersion.trim();
-    }
-    return version;
-  }
-
-  /**
-   * Return the migration name which is short description text that can be appended to
-   * the migration version to become the ddl script file name.
-   * <p>
-   * So if the name is "a foo table" then the ddl script file could be:
-   * "1.1.1_2__a-foo-table.sql"
-   * </p>
-   * <p>
-   * When the DB migration relates to a git feature (merge request) then this description text
-   * is a short description of the feature.
-   * </p>
-   */
-  public String getName() {
-    String envName = readEnvironment("ddl.migration.name");
-    if (!isEmpty(envName)) {
-      return envName.trim();
-    }
-    return name;
+    ddlHeader = properties.get("ddl.header", ddlHeader);
  }

  /**
@@ -521,10 +483,15 @@ public class DbMigrationConfig {
    runnerConfig.setMetaTable(metaTable);
    runnerConfig.setApplySuffix(applySuffix);
    runnerConfig.setMigrationPath(migrationPath);
+    runnerConfig.setMigrationInitPath(migrationInitPath);
    runnerConfig.setRunPlaceholderMap(runPlaceholderMap);
    runnerConfig.setRunPlaceholders(runPlaceholders);
    runnerConfig.setDbUsername(getDbUsername());
    runnerConfig.setDbPassword(getDbPassword());
+    runnerConfig.setDbSchema(getDbSchema());
+    if (defaultDbSchema) {
+      runnerConfig.setSetCurrentSchema(false);
+    }
    runnerConfig.setClassLoader(classLoader);
    if (patchInsertOn != null) {
      runnerConfig.setPatchInsertOn(patchInsertOn);
@@ -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;
-  }
-}
@@ -0,0 +1,355 @@
+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;
+
+  /**
+   * Set to true to force InetAddress to map to Varchar (for Postgres rather than INET)
+   */
+  private boolean databaseInetAddressVarchar;
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Return true if InetAddress should map to varchar column (rather than Postgres INET).
+   */
+  public boolean isDatabaseInetAddressVarchar() {
+    return databaseInetAddressVarchar;
+  }
+
+  /**
+   * Set to true to force InetAddress to map to varchar column.
+   */
+  public void setDatabaseInetAddressVarchar(boolean databaseInetAddressVarchar) {
+    this.databaseInetAddressVarchar = databaseInetAddressVarchar;
+  }
+
+  /**
+   * 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);
+    databaseInetAddressVarchar = p.getBoolean("databaseInetAddressVarchar", databaseInetAddressVarchar);
+
+    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;
+    }
+  }
+}
@@ -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);
+  }
 }
@@ -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);
-  }
-
-}
@@ -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();
-  }
-
-}
@@ -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);
-  }
-
-}
@@ -0,0 +1,39 @@
+package io.ebean.config;
+
+/**
+ * Provides a ServiceLoader based mechanism to configure a ServerConfig.
+ * <p>
+ * Provide an implementation and register it via the standard Java ServiceLoader mechanism
+ * via a file at <code>META-INF/services/io.ebean.config.ServerConfigProvider</code>.
+ * </p>
+ * <p>
+ * If you are using a DI container like Spring or Guice you are unlikely to use this but instead use a
+ * spring specific configuration.  When we are not using a DI container we may use this mechanism to
+ * explicitly register the entity beans and avoid classpath scanning.
+ * </p>
+ * <pre>{@code
+ *
+ * public class EbeanConfigProvider implements ServerConfigProvider {
+ *
+ *   @Override
+ *   public void apply(ServerConfig config) {
+ *
+ *     // register the entity bean classes explicitly
+ *     config.addClass(Customer.class);
+ *     config.addClass(User.class);
+ *     ...
+ *   }
+ * }
+ *
+ * }</pre>
+ */
+public interface ServerConfigProvider {
+
+  /**
+   * Apply the configuration to the ServerConfig.
+   * <p>
+   * Typically we explicitly register entity bean classes and thus avoid classpath scanning.
+   * </p>
+   */
+  void apply(ServerConfig config);
+}
@@ -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;
+  }
+ 
 }
@@ -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);
  }

  /**
@@ -2,10 +2,12 @@ package io.ebean.config.dbplatform;

 import io.ebean.BackgroundExecutor;
 import io.ebean.Query;
+import io.ebean.annotation.PartitionMode;
 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;

@@ -15,6 +17,7 @@ import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.Types;

 /**
@@ -49,7 +52,7 @@ public class DatabasePlatform {
  /**
   * The behaviour used when ending a read only transaction at read committed isolation level.
   */
-  protected OnQueryOnly onQueryOnly = OnQueryOnly.ROLLBACK;
+  protected OnQueryOnly onQueryOnly = OnQueryOnly.COMMIT;

  /**
   * The open quote used by quoted identifiers.
@@ -61,8 +64,6 @@ public class DatabasePlatform {
   */
  protected String closeQuote = "\"";

-  protected String concatOperator = "||";
-
  /**
   * When set to true all db column names and table names use quoted identifiers.
   */
@@ -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;

@@ -155,9 +176,17 @@ public class DatabasePlatform {
   * findIterate() and findVisit().
   */
  protected boolean forwardOnlyHintOnFindIterate;
+  
+  /**
+   * If set then use the CONCUR_UPDATABLE hint when creating ResultSets.
+   * 
+   * This is {@code false} for HANA
+   */
+  protected boolean supportsResultSetConcurrencyModeUpdatable = true;
+

  /**
-   * By default we use JDBC batch when cascading (except for SQL Server).
+   * By default we use JDBC batch when cascading (except for SQL Server and HANA).
   */
  protected PersistBatch persistBatchOnCascade = PersistBatch.ALL;

@@ -177,8 +206,6 @@ public class DatabasePlatform {

  protected SqlExceptionTranslator exceptionTranslator = new SqlCodeTranslator();

-  protected char[] specialLikeCharacters = { '%', '_', '\\' };
-
  /**
   * Instantiates a new database platform.
   */
@@ -192,10 +219,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 +285,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 +340,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 +389,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.
   */
@@ -404,13 +461,6 @@ public class DatabasePlatform {
    return openQuote;
  }

-  /**
-   * Return the DB concat operator.
-   */
-  public String getConcatOperator() {
-    return concatOperator;
-  }
-
  /**
   * Return the JDBC type used to store booleans.
   */
@@ -474,6 +524,31 @@ public class DatabasePlatform {
  public void setForwardOnlyHintOnFindIterate(boolean forwardOnlyHintOnFindIterate) {
    this.forwardOnlyHintOnFindIterate = forwardOnlyHintOnFindIterate;
  }
+  
+  /**
+   * Return true if the ResultSet CONCUR_UPDATABLE Hint should be used on
+   * createNativeSqlTree() PreparedStatements.
+   * <p>
+   * This specifically is required for Hana which doesn't support CONCUR_UPDATABLE
+   * </p>
+   */
+  public boolean isSupportsResultSetConcurrencyModeUpdatable() {
+    return supportsResultSetConcurrencyModeUpdatable;
+  }
+  
+  /**
+   * Set to true if the ResultSet CONCUR_UPDATABLE Hint should be used by default on createNativeSqlTree() PreparedStatements.
+   */
+  public void setSupportsResultSetConcurrencyModeUpdatable(boolean supportsResultSetConcurrencyModeUpdatable) {
+    this.supportsResultSetConcurrencyModeUpdatable = supportsResultSetConcurrencyModeUpdatable;
+  }
+
+  /**
+   * Normally not needed - overridden in CockroachPlatform.
+   */
+  public boolean isDdlCommitOnCreateIndex() {
+    return false;
+  }

  /**
   * Return the DB identity/sequence features for this platform.
@@ -572,6 +647,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 +666,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;
  }

  /**
@@ -594,6 +677,39 @@ public class DatabasePlatform {
    return persistBatchOnCascade;
  }

+  /**
+   * Create the DB schema if it does not exist.
+   */
+  public void createSchemaIfNotExists(String dbSchema, Connection connection) throws SQLException {
+    if (!schemaExists(dbSchema, connection)) {
+      Statement query = connection.createStatement();
+      try {
+        logger.info("create schema:{}", dbSchema);
+        query.executeUpdate("create schema " + dbSchema);
+      } finally {
+        JdbcClose.close(query);
+      }
+    }
+  }
+
+  /**
+   * Return true if the schema exists.
+   */
+  public boolean schemaExists(String dbSchema, Connection connection) throws SQLException {
+    ResultSet schemas = connection.getMetaData().getSchemas();
+    try {
+      while (schemas.next()) {
+        String schema = schemas.getString(1);
+        if (schema.equalsIgnoreCase(dbSchema)) {
+          return true;
+        }
+      }
+    } finally {
+      JdbcClose.close(schemas);
+    }
+    return false;
+  }
+
  /**
   * Return true if the table exists.
   */
@@ -604,19 +720,22 @@ public class DatabasePlatform {
    try {
      return tables.next();
    } finally {
-      close(tables);
+      JdbcClose.close(tables);
    }
  }

  /**
-   * Close the resultSet.
+   * Return true if partitions exist for the given table.
   */
-  protected void close(ResultSet resultSet) {
-    try {
-      resultSet.close();
-    } catch (SQLException e) {
-      logger.error("Error closing resultSet", e);
-    }
+  public boolean tablePartitionsExist(Connection connection, String table) throws SQLException {
+    return true;
+  }
+
+  /**
+   * Return the SQL to create an initial partition for the given table.
+   */
+  public String tablePartitionInit(String tableName, PartitionMode mode, String property, String singlePrimaryKey) {
+    return null;
  }

  /**
@@ -627,7 +746,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 +768,6 @@ public class DatabasePlatform {
  }

  protected void escapeLikeCharacter(char ch, StringBuilder sb) {
-    sb.append('\\').append(ch);
+    sb.append(likeEscapeChar).append(ch);
  }
 }
@@ -8,7 +8,9 @@ import java.util.regex.Pattern;
 */
 public class DbIdentity {

-  private static final Pattern TABLE_REPLACE = Pattern.compile("{table}", Pattern.LITERAL);
+  private static final String TABLE_PLACEHOLDER = "{table}";
+
+  private static final Pattern TABLE_REPLACE = Pattern.compile(TABLE_PLACEHOLDER, Pattern.LITERAL);

  /**
   * Set if this DB supports sequences. Note some DB's support both Sequences
@@ -53,7 +55,9 @@ public class DbIdentity {
    if (selectLastInsertedIdTemplate == null) {
      return null;
    }
-
+    if (!selectLastInsertedIdTemplate.contains(TABLE_PLACEHOLDER)) {
+      return selectLastInsertedIdTemplate;
+    }
    return TABLE_REPLACE.matcher(selectLastInsertedIdTemplate).replaceAll(Matcher.quoteReplacement(table));
  }

@@ -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.
   */
@@ -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,26 @@ 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 INET_NATIVE = new DbPlatformType("inet", false);
+  private static final DbPlatformType INET_VARCHAR = new DbPlatformType("varchar", 50);
+
  private static final DbPlatformType UUID_NATIVE = new DbPlatformType("uuid", false);
  @SuppressWarnings("unused")
  private static final DbPlatformType UUID_PLACEHOLDER = new DbPlatformType("uuidPlaceholder");
@@ -51,7 +69,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);
@@ -91,6 +109,7 @@ public class DbPlatformTypeMapping {
      put(DbType.JSONBLOB, new DbPlatformType("jsonblob"));
      put(DbType.JSONVARCHAR, new DbPlatformType("jsonvarchar", 1000));
      put(DbType.UUID, UUID_NATIVE);
+      put(DbType.INET, INET_NATIVE);

    } else {
      put(DbType.VARCHAR, new DbPlatformType("varchar", 255));
@@ -104,8 +123,9 @@ 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);
+      put(DbType.INET, INET_VARCHAR);
    }
  }

@@ -183,9 +203,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 {
@@ -35,6 +35,8 @@ public enum DbType {
  ARRAY(Types.ARRAY),

  UUID(ExtraDbTypes.UUID),
+  INET(ExtraDbTypes.INET),
+  CDIR(ExtraDbTypes.CDIR),

  POINT(ExtraDbTypes.POINT),
  POLYGON(ExtraDbTypes.POLYGON),
@@ -40,6 +40,9 @@ public interface ExtraDbTypes {
   */
  int JSONBlob = 5005;

+  int INET = 5020;
+  int CDIR = 5021;
+
  /**
   * Geo Point
   */
@@ -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;
+  }
+
+}
@@ -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);
  }

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

 }
@@ -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;
+  }
+
+}
--- a/Show More
+++ b/Show More