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

OneToOne inserts with idType=SEQUENCE will fail #1480
No effective change - add test with softDelete on bean with history
2024-04-21 10:51:47 +00:00 · 2018-09-20 21:35:08 +12:00 · 2018-09-20 21:32:48 +12:00 · 2018-09-20 21:10:41 +12:00 · 2018-09-20 21:09:01 +12:00 · 2018-09-20 20:24:33 +12:00
3543 changed files with 168988 additions and 103141 deletions
@@ -10,3 +10,4 @@ indent_style = space
 insert_final_newline = true
 trim_trailing_whitespace = true
 spaces_around_operators = true
+max_line_length = 130
@@ -13,10 +13,11 @@ ebean-profiling*.xml
 /db
 /mydb.db
 !src/test/ddl-review/*.sql
-
+profiling/

 # Intellij project files
 *.iml
 *.ipr
 *.iws
 .idea/
+*uuid.state
@@ -1,3 +1,4 @@
+dist: trusty
 sudo: required
 language: java
 jdk:
@@ -7,17 +8,28 @@ git:
  depth: 3

 addons:
-  postgresql: "9.4"
+  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
+
@@ -6,12 +6,12 @@ Goto [https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Web


 ## Maven cental links:
-[Maven central - ebean](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22org.avaje.ebean%22%20AND%20a%3A%22ebean%22 "maven central ebean")
+[Maven central - ebean](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22io.ebean%22%20AND%20a%3A%22ebean%22 "maven central ebean")

 [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/org.avaje.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/org.avaje.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/org.avaje.ebean/ebean-maven-plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-maven-plugin) - ebean-maven-plugin
+* [![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) - 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/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

@@ -0,0 +1,153 @@
+This is a short description how to run tests
+============================================
+
+Run tests from maven
+--------------------
+
+Just type `mvn test` - it will run the whole test suite with the settings
+from `src/test/resources/ebean.properties`. 
+
+Run tests from eclipse
+----------------------
+
+Running tests requires, that the classes are enhanced. By default, the 
+`BaseTestCase` tries to load the enhancer-agent in a very early stage. This 
+also works for most test cases, but it does not work if you try to run a 
+complete test-suite, as classes that are loaded before the enhancer-agent 
+kicks in will not get enhanced. To solve this problem, you need either the
+[Eclipse-Enhancer-Plugin](https://github.com/ebean-orm-tools/ebean-eclipse-enhancer) 
+or add the agent to your JVM arguments (Preferences->Installed JREs) or to
+your run configuration: 
+`-javaagent:<USER_HOME>/.m2/repository/io/ebean/ebean-agent/<VERSION>/ebean-agent-<VERSION>.jar=debug=0`
+
+
+Platform Tests
+==============
+
+By default, the `h2` platform is used. To test a different platform, add 
+`-Ddatasource.default=xxx` to your maven command or JVM arguments.
+
+'h2' platform
+-------------
+
+Reqires no setup
+
+run: `mvn clean test`
+
+Current status: PASS
+Tests run: 1986, Failures: 0, Errors: 0, Skipped: 16
+
+'pg' platform
+-------------
+
+Reqirements
+- a locally installed PostgreSQL server with PostGis.
+- Create a user "unit" with password "unit" and a database "unit"
+- Give the user all permissions to that db
+
+run: `mvn clean test -Ddatasource.default=pg`
+
+Current status: PASS
+Tests run: 2166, Failures: 0, Errors: 0, Skipped: 25
+
+
+
+'mysql' platform
+-------------
+
+Reqirements
+- a locally installed MySQL server.
+- Create a user "unit" with password "unit" and a database "unit"
+- Give the user all permissions to that db
+
+run: `mvn clean test -Ddatasource.default=mysql`
+
+Current status: PASS
+Tests run: 2166, Failures: 0, Errors: 0, Skipped: 33
+
+
+
+'sqlserver' platform
+--------------------
+
+Reqires an installed sqlserver - e.g. https://hub.docker.com/r/microsoft/mssql-server-linux/
+
+- Create a user "ebean" with password "ebean" and a database "ebean_unittest"
+- Adjust the connection string and/or username in ebean.properties
+  
+run: `mvn clean test -Ddatasource.default=mssql`
+
+Current status: PASS
+Tests run: 2166, Failures: 0, Errors: 0, Skipped: 39
+
+
+
+'oracle' platform
+-----------------
+
+Reqires a locally installed Oracle server.
+- Create a user "unit" with password "unit" with all permissions
+- The test wirtes directly to the "xe" SID - so do not use a productive server!
+- As the Oracle JDBC driver is only available on an oracle repository,
+  you need a special maven setup as described [here](http://docs.oracle.com/middleware/1213/core/MAVEN/config_maven_repo.htm#MAVEN9010)
+  
+run: `mvn clean test -Ddatasource.default=ora -Poracle`
+
+Current status: FAIL
+Tests run: 1986, Failures: 17, Errors: 34, Skipped: 16
+
+
+
+'db2' platform
+--------------
+
+Reqires a locally installed DB2 Express-C server.
+- Create a user "unit" with password "unit" with all permissions
+- Install the db2jcc4 driver (see pom.xml)
+
+run: `mvn clean test -Ddatasource.default=db2 -Pdb2`
+
+Current status: FAIL
+Tests run: 2166, Failures: 29, Errors: 58, Skipped: 30
+
+
+'sqlite' platform
+-----------------
+
+Reqires no setup
+
+run: `mvn clean test -Ddatasource.default=sqlite`
+
+Current status: FAIL
+Tests run: 1986, Failures: 24, Errors: 86, Skipped: 16
+
+After some time, the db locks up, every test takes 3 seconds and fails with 
+"the database file is locked"
+
+
+
+'hsqldb' platform
+-----------------
+
+Reqires no setup
+
+run: `mvn clean test -Ddatasource.default=hsqldb`
+
+Current status: FAIL
+Tests run: 1980, Failures: 3, Errors: 657, Skipped: 16
+
+
+@Rob FYI
+The problem is https://sourceforge.net/p/hsqldb/bugs/1364/
+In `InsertHandler.getPstmt` the `meta.getIdentityDbColumns()` contains
+'id' in lowercase. Changing that to uppercase gives me this result:
+`Tests run: 1986, Failures: 2, Errors: 18, Skipped: 16`
+(as quick hack I added temporary a toUpperCase to BindableIdScalar.getIdentityColumn)
+
+
+'sqlanywhere' platform
+----------------------
+
+TODO: not yet tested
+
+
@@ -4,100 +4,158 @@
  <parent>
    <groupId>org.avaje</groupId>
    <artifactId>java8-parent</artifactId>
-    <version>1.1</version>
+    <version>1.3</version>
  </parent>

-  <groupId>org.avaje.ebean</groupId>
+  <groupId>io.ebean</groupId>
  <artifactId>ebean</artifactId>
-  <version>9.3.1</version>
+  <version>11.22.5</version>
  <packaging>jar</packaging>

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

  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <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-9.3.1</tag>
+    <tag>ebean-11.22.5</tag>
  </scm>

+  <profiles>
+    <profile>
+      <!-- Note: to use this profile, you need credentials for the oracle repository in your
+        settings.xml as described here:
+        http://docs.oracle.com/middleware/1213/core/MAVEN/config_maven_repo.htm#MAVEN9010 -->
+      <id>oracle</id>
+      <dependencies>
+        <dependency>
+          <groupId>com.oracle.jdbc</groupId>
+          <artifactId>ojdbc8</artifactId>
+          <version>12.2.0.1</version>
+          <scope>test</scope>
+        </dependency>
+      </dependencies>
+      <repositories>
+        <repository>
+          <id>maven.oracle.com</id>
+          <releases>
+            <enabled>true</enabled>
+          </releases>
+          <snapshots>
+            <enabled>false</enabled>
+          </snapshots>
+          <url>https://maven.oracle.com</url>
+          <layout>default</layout>
+        </repository>
+      </repositories>
+    </profile>
+    <profile>
+      <!-- Note: to use this profile, you need to download manually the db2jcc4 driver.
+        After that, install it into your local maven repository:
+
+        mvn install:install-file \
+          -Dfile=db2jcc4.jar \
+          -DgroupId=com.ibm.jdbc \
+          -DartifactId=db2jcc4 \
+          -Dversion=4.23.42 \
+          -Dpackaging=jar
+      -->
+      <id>db2</id>
+      <dependencies>
+        <dependency>
+          <groupId>com.ibm.jdbc</groupId>
+          <artifactId>db2jcc4</artifactId>
+          <version>4.23.42</version>
+          <scope>test</scope>
+        </dependency>
+      </dependencies>
+    </profile>
+  </profiles>
  <dependencies>

+    <!--
+    Projects are expected to explicit depend on version
+    of slf4j that they want to use
+    -->
    <dependency>
-      <groupId>org.jetbrains</groupId>
-      <artifactId>annotations</artifactId>
-      <version>13.0</version>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.25</version>
+      <scope>provided</scope>
    </dependency>

+    <!--
+    Exclude snakeyaml if you desire - it is not strictly required.
+    -->
    <dependency>
-      <groupId>org.avaje.ebean</groupId>
-      <artifactId>persistence-api</artifactId>
-      <version>2.1.3</version>
+      <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
+    -->
    <dependency>
-      <groupId>org.avaje.ebean</groupId>
-      <artifactId>ebean-annotation</artifactId>
-      <version>1.4</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-datasource-api</artifactId>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-jsr305</artifactId>
      <version>1.1</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>persistence-api</artifactId>
+      <version>2.2.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-annotation</artifactId>
+      <version>4.2</version>
    </dependency>

    <dependency>
      <groupId>org.avaje</groupId>
      <artifactId>avaje-datasource</artifactId>
-      <version>1.1.3</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-classpath-scanner-api</artifactId>
-      <version>2.2</version>
+      <version>3.2.2</version>
    </dependency>

    <dependency>
      <groupId>org.avaje</groupId>
      <artifactId>avaje-classpath-scanner</artifactId>
-      <version>2.2.1</version>
+      <version>3.1.1</version>
    </dependency>

    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-dbmigration</artifactId>
-      <version>1.2.1</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-api</artifactId>
-      <version>[1.7.1,1.7.99)</version>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-migration</artifactId>
+      <version>11.9.1</version>
    </dependency>

    <dependency>
      <groupId>org.antlr</groupId>
      <artifactId>antlr4-runtime</artifactId>
-      <version>4.5.3</version>
+      <version>4.7.1</version>
    </dependency>

    <!-- Jackson core used internally by Ebean -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
-      <version>2.6.5</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.6.5</version>
+      <version>${jackson-core.version}</version>
      <scope>provided</scope>
    </dependency>

@@ -112,21 +170,21 @@
    <dependency>
      <groupId>javax.validation</groupId>
      <artifactId>validation-api</artifactId>
-      <version>1.0.0.GA</version>
+      <version>1.1.0.Final</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
-      <artifactId>servlet-api</artifactId>
-      <version>2.4</version>
+      <artifactId>javax.servlet-api</artifactId>
+      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>joda-time</groupId>
      <artifactId>joda-time</artifactId>
-      <version>1.6</version>
+      <version>2.9.7</version>
      <scope>provided</scope>
    </dependency>

@@ -134,7 +192,7 @@
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
-      <version>9.4-1202-jdbc41</version>
+      <version>42.2.2</version>
      <scope>provided</scope>
    </dependency>

@@ -147,24 +205,31 @@
      <!--<scope>test</scope>-->
    <!--</dependency>-->

-    <!--<dependency>-->
-      <!--<groupId>microsoft</groupId>-->
-      <!--<artifactId>sqlserver-jdbc</artifactId>-->
-      <!--<version>4.2</version>-->
-      <!--<scope>test</scope>-->
-    <!--</dependency>-->
-
    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-agentloader</artifactId>
-      <version>1.1.1</version>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-docker-run</artifactId>
+      <version>1.5.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
-      <groupId>org.avaje.ebean</groupId>
+      <groupId>ch.qos.logback</groupId>
+      <artifactId>logback-classic</artifactId>
+      <version>1.2.3</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-agentloader</artifactId>
+      <version>2.1.2</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
      <artifactId>ebean-agent</artifactId>
-      <version>8.1.1</version>
+      <version>11.11.1</version>
      <scope>test</scope>
    </dependency>

@@ -173,28 +238,36 @@
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
-      <version>1.4.192</version>
+      <version>1.4.196</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>org.xerial</groupId>
      <artifactId>sqlite-jdbc</artifactId>
-      <version>3.8.11.2</version>
+      <version>3.15.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.hsqldb</groupId>
      <artifactId>hsqldb</artifactId>
-      <version>2.0.0</version>
+      <version>2.3.4</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>com.microsoft.sqlserver</groupId>
+      <artifactId>mssql-jdbc</artifactId>
+      <version>6.4.0.jre8</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
-      <version>5.1.36</version>
+      <!-- Do not upgrade to 6.0.6: https://bugs.mysql.com/bug.php?id=82896 -->
+      <version>5.1.43</version>
      <scope>test</scope>
    </dependency>

@@ -209,14 +282,14 @@
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
-      <version>2.4</version>
+      <version>2.5</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.avaje.moduuid</groupId>
      <artifactId>avaje-moduuid</artifactId>
-      <version>1.2</version>
+      <version>2.1</version>
      <scope>test</scope>
    </dependency>

@@ -227,19 +300,18 @@
    <plugins>

      <plugin>
-        <groupId>org.avaje.ebean</groupId>
+        <groupId>io.ebean</groupId>
        <artifactId>ebean-maven-plugin</artifactId>
-        <version>8.1.1</version>
+        <version>11.11.1</version>
        <executions>
          <execution>
            <id>test</id>
            <phase>process-test-classes</phase>
            <configuration>
-              <classSource>target/test-classes</classSource>
              <transformArgs>debug=1</transformArgs>
            </configuration>
            <goals>
-              <goal>enhance</goal>
+              <goal>testEnhance</goal>
            </goals>
          </execution>
        </executions>
@@ -263,6 +335,11 @@
              <name>datasource.default</name>
              <value>${datasource.default}</value>
            </property>
+            <property>
+              <!-- transfer dbClockDelta parameter -->
+              <name>dbClockDelta</name>
+              <value>${dbClockDelta}</value>
+            </property>
          </systemProperties>
        </configuration>
      </plugin>
@@ -283,11 +360,11 @@
        <artifactId>maven-javadoc-plugin</artifactId>
        <version>2.9.1</version>
        <configuration>
-          <doctitle>Ebean 9</doctitle>
-          <overview>src/main/java/com/avaje/ebean/overview.html</overview>
+          <doctitle>Ebean 11</doctitle>
+          <overview>src/main/java/io/ebean/overview.html</overview>
          <source>1.8</source>
          <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
-          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util:com.avaje.ebean.dbmigration.ddlgeneration:com.avaje.ebean.dbmigration.migration:com.avaje.ebean.dbmigration.migrationreader:com.avaje.ebean.dbmigration.model</excludePackageNames>
+          <excludePackageNames>io.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames>
          <docletArtifact>
            <groupId>org.avaje</groupId>
            <artifactId>pygments-doclet</artifactId>
@@ -1,96 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.RawSql.ColumnMapping;
-
-import javax.persistence.PersistenceException;
-import java.util.ArrayList;
-
-/**
- * Parses columnMapping (select clause) mapping columns to bean properties.
- */
-final class DRawSqlColumnsParser {
-
-  private final int end;
-
-  private final String sqlSelect;
-
-  private int pos;
-
-  private int indexPos;
-
-  public static ColumnMapping parse(String sqlSelect) {
-    return new DRawSqlColumnsParser(sqlSelect).parse();
-  }
-
-  private DRawSqlColumnsParser(String sqlSelect) {
-    this.sqlSelect = sqlSelect;
-    this.end = sqlSelect.length();
-  }
-
-  private ColumnMapping parse() {
-
-    ArrayList<ColumnMapping.Column> columns = new ArrayList<>();
-    while (pos <= end) {
-      ColumnMapping.Column c = nextColumnInfo();
-      columns.add(c);
-    }
-
-    return new ColumnMapping(columns);
-  }
-
-  private ColumnMapping.Column nextColumnInfo() {
-    int start = pos;
-    nextComma();
-    String colInfo = sqlSelect.substring(start, pos++);
-    colInfo = colInfo.trim();
-
-    String[] split = colInfo.split("\\s(?=[^\\)]*(?:\\(|$))");
-    if (split.length > 1) {
-      ArrayList<String> tmp = new ArrayList<>(split.length);
-      for (String aSplit : split) {
-        if (!aSplit.trim().isEmpty()) {
-          tmp.add(aSplit.trim());
-        }
-      }
-      split = tmp.toArray(new String[tmp.size()]);
-    }
-
-    if (split.length == 0) {
-      throw new PersistenceException("Huh? Not expecting length=0 when parsing column " + colInfo);
-    }
-    if (split.length == 1) {
-      // default to column the same name as the property
-      return new ColumnMapping.Column(indexPos++, split[0], null);
-    }
-    if (split.length == 2) {
-      return new ColumnMapping.Column(indexPos++, split[0], split[1]);
-    }
-    // Ok, we now expect/require the AS keyword and it should be the
-    // second to last word in the colInfo content
-    if (!split[split.length - 2].equalsIgnoreCase("as")) {
-      throw new PersistenceException("Expecting AS keyword as second to last word when parsing column " + colInfo);
-    }
-    // build back the 'column formula' that precedes the AS keyword
-    StringBuilder sb = new StringBuilder();
-    sb.append(split[0]);
-    for (int i = 1; i < split.length - 2; i++) {
-      sb.append(" ").append(split[i]);
-    }
-    return new ColumnMapping.Column(indexPos++, sb.toString(), split[split.length - 1]);
-  }
-
-  private void nextComma() {
-    boolean inQuote = false;
-    int inbrackets = 0;
-    while (pos < end) {
-      char c = sqlSelect.charAt(pos);
-      if (c == '\'') inQuote = !inQuote;
-      else if (c == '(') inbrackets++;
-      else if (c == ')') inbrackets--;
-      else if (!inQuote && inbrackets == 0 && c == ',') {
-        return;
-      }
-      pos++;
-    }
-  }
-}
@@ -1,160 +0,0 @@
-package com.avaje.ebean;
-
-import org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-
-/**
- * Intended to be used as a base class for 'Finder' implementations that can then
- * be injected or used as public static fields on the associated entity bean.
- * <p>
- * These 'finders' are a place to organise all the finder methods for that bean type
- * and specific finder methods are expected to be added (find by unique properties etc).
- * </p>
- * <h3>Testing</h3>
- * <p>
- * For testing the mocki-ebean project has the ability to replace the finder implementation
- * <p>
- * </p>
- * <pre>{@code
- *
- * public class CustomerFinder extends Finder<Customer> {
- *
- *   public CustomerFinder() {
- *     super(Customer.class);
- *   }
- *
- *   // Add your customer finder methods ...
- *
- *   public Customer byName(String name) {
- *     return query().eq("name", name).findUnique();
- *   }
- *
- *   public List<Customer> findNew() {
- *     return query()
- *       .eq("status", Customer.Status.NEW)
- *       .orderBy("name")
- *       .findList()
- *   }
- * }
- *
- * @Entity
- * public class Customer extends BaseModel {
- *
- *   public static final CustomerFinder find = new CustomerFinder();
- *   ...
- *
- * }</pre>
- */
-public class Finder<I, T> {
-
-  /**
-   * The entity bean type.
-   */
-  private final Class<T> type;
-
-  /**
-   * The name of the EbeanServer, null for the default server.
-   */
-  private final String serverName;
-
-  /**
-   * Create with the type of the entity bean.
-   * <pre>{@code
-   *
-   * public class CustomerFinder extends Finder<Customer> {
-   *
-   *   public CustomerFinder() {
-   *     super(Customer.class);
-   *   }
-   *
-   *   // ... add extra customer specific finder methods
-   * }
-   *
-   * @Entity
-   * public class Customer extends BaseModel {
-   *
-   *   public static final CustomerFinder find = new CustomerFinder();
-   *   ...
-   *
-   * }</pre>
-   */
-  public Finder(Class<T> type) {
-    this.type = type;
-    this.serverName = null;
-  }
-
-  /**
-   * Create with the type of the entity bean and specific server name.
-   */
-  public Finder(Class<T> type, String serverName) {
-    this.type = type;
-    this.serverName = serverName;
-  }
-
-  /**
-   * Return the underlying 'default' EbeanServer.
-   * <p>
-   * This provides full access to the API such as explicit transaction demarcation etc.
-   */
-  public EbeanServer db() {
-    return Ebean.getServer(serverName);
-  }
-
-  /**
-   * Return typically a different EbeanServer to the default.
-   * <p>
-   * This is equivalent to {@link Ebean#getServer(String)}
-   *
-   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is
-   *               returned.
-   */
-  public EbeanServer db(String server) {
-    return Ebean.getServer(server);
-  }
-
-  /**
-   * Creates an entity reference for this ID.
-   * <p>
-   * Equivalent to {@link EbeanServer#getReference(Class, Object)}
-   */
-  public T ref(I id) {
-    return db().getReference(type, id);
-  }
-
-  /**
-   * Retrieves an entity by ID.
-   * <p>
-   * Equivalent to {@link EbeanServer#find(Class, Object)}
-   */
-  @Nullable
-  public T byId(I id) {
-    return db().find(type, id);
-  }
-
-  /**
-   * Delete a bean by Id.
-   * <p>
-   * Equivalent to {@link EbeanServer#delete(Class, Object)}
-   */
-  public void deleteById(I id) {
-    db().delete(type, id);
-  }
-
-  /**
-   * Retrieves all entities of the given type.
-   */
-  public List<T> all() {
-    return query().findList();
-  }
-
-  /**
-   * Creates a query.
-   * <p>
-   * Equivalent to {@link EbeanServer#find(Class)}
-   */
-  public Query<T> query() {
-    return db().find(type);
-  }
-
-}
@@ -1,35 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to specify the type of like matching used.
- */
-public enum LikeType {
-
-  /**
-   * You need to put in your own wildcards.
-   */
-  RAW,
-
-  /**
-   * The % wildcard is added to the end of the search word.
-   */
-  STARTS_WITH,
-
-  /**
-   * The % wildcard is added to the beginning of the search word.
-   */
-  ENDS_WITH,
-
-  /**
-   * The % wildcard is added to the beginning and end of the search word.
-   */
-  CONTAINS,
-
-  /**
-   * Uses equal to rather than a LIKE with wildcards.
-   * <p>
-   * This is mainly here to be available for use with ExampleExpression.
-   * </p>
-   */
-  EQUAL_TO
-}
@@ -1,888 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.bean.EntityBean;
-import com.avaje.ebean.util.ClassUtil;
-import org.jetbrains.annotations.Nullable;
-
-import javax.persistence.MappedSuperclass;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-/**
- * A MappedSuperclass base class that provides convenience methods for inserting, updating and
- * deleting beans.
- * <p>
- * By having your entity beans extend this it provides a 'Active Record' style programming model for
- * Ebean users.
- * <p>
- * Note that there is a avaje-ebeanorm-mocker project that enables you to use Mockito or similar
- * tools to still mock out the underlying 'default EbeanServer' 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
- * 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
- * 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
- * a {@link Find} as a public static field to complete the active record pattern and provide a
- * relatively nice clean way to write queries.
- * <p>
- * <h3>Typical common @MappedSuperclass</h3>
- * <pre>{@code
- *
- *     // Typically there is a common base model that has some
- *     // common properties like the ones below
- *
- *     @MappedSuperclass
- *     public class BaseModel extends Model {
- *
- *       @Id Long id;
- *
- *       @Version Long version;
- *
- *       @CreatedTimestamp Timestamp whenCreated;
- *
- *       @UpdatedTimestamp Timestamp whenUpdated;
- *
- *       ...
- *
- * }</pre>
- * <p>
- * <h3>Extend the Model</h3>
- * <pre>{@code
- *
- *     // Extend the mappedSuperclass
- *
- *     @Entity @Table(name="oto_account")
- *     public class Customer extends BaseModel {
- *
- *       // Add a static Find
- *       // ... with Long being the type of our @Id property.
- *       // ... Note the {} at the end as Find is an abstract class.
- *
- *       public static final Find<Long,Account> find = new Find<Long,Account>(){};
- *
- *       String name;
- *       ...
- *     }
- *
- * }</pre>
- * <p>
- * <h3>Modal: save()</h3>
- * <pre>{@code
- *
- *     // Active record style ... save(), delete() etc
- *     Customer customer = new Customer();
- *     customer.setName("AC234");
- *
- *     // save() method inherited from Model
- *     customer.save();
- *
- * }</pre>
- * <p>
- * <h3>Find byId</h3>
- * <pre>{@code
- *
- *     // find byId
- *     Customer customer = Customer.find.byId(42);
- *
- * }</pre>
- * <p>
- * <h3>Find where</h3>
- * <pre>{@code
- *
- *     // find where ...
- *     List<Customer> customers =
- *         Customer.find
- *         .where().gt("startDate", lastMonth)
- *         .findList();
- *
- * }</pre>
- */
-@MappedSuperclass
-public abstract class Model {
-
-  /**
-   * Return the underlying 'default' EbeanServer.
-   * <p>
-   * This provides full access to the API such as explicit transaction demarcation etc.
-   * <p>
-   * Example:
-   * <pre>{@code
-   *
-   * Transaction transaction = Customer.db().beginTransaction();
-   * try {
-   *
-   *   // turn off cascade persist for this transaction
-   *   transaction.setPersistCascade(false);
-   *
-   *   // extra control over jdbc batching for this transaction
-   *   transaction.setBatchGetGeneratedKeys(false);
-   *   transaction.setBatchMode(true);
-   *   transaction.setBatchSize(20);
-   *
-   *   Customer customer = new Customer();
-   *   customer.setName(&quot;Roberto&quot;);
-   *   customer.save();
-   *
-   *   Customer otherCustomer = new Customer();
-   *   otherCustomer.setName("Franko");
-   *   otherCustomer.save();
-   *
-   *   transaction.commit();
-   *
-   * } finally {
-   *   transaction.end();
-   * }
-   *
-   * }</pre>
-   */
-  public static EbeanServer db() {
-    return Ebean.getDefaultServer();
-  }
-
-  /**
-   * 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.
-   *
-   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is returned.
-   */
-  public static EbeanServer db(String server) {
-    return Ebean.getServer(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 = Customer.find.byId(id);
-   *
-   * // mark the bean as dirty so that a save() or update() will
-   * // increment the version property
-   * customer.markAsDirty();
-   * customer.save();
-   *
-   * }</pre>
-   *
-   * @see EbeanServer#markAsDirty(Object)
-   */
-  public void markAsDirty() {
-    db().markAsDirty(this);
-  }
-
-  /**
-   * 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
-   *   User user = ...;
-   *
-   *   // mark the email property as 'unset' so that it is not
-   *   // included in a 'stateless update'
-   *   user.markPropertyUnset("email");
-   *
-   *   user.update();
-   *
-   * }</pre>
-   *
-   * @param propertyName the name of the property on the bean to be marked as 'unset'
-   */
-  public void markPropertyUnset(String propertyName) {
-    ((EntityBean) this)._ebean_getIntercept().setPropertyLoaded(propertyName, false);
-  }
-
-  /**
-   * Insert or update this entity depending on its state.
-   * <p>
-   * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
-   * insert or an update based on that.
-   *
-   * @see EbeanServer#save(Object)
-   */
-  public void save() {
-    db().save(this);
-  }
-
-  /**
-   * Update this entity.
-   *
-   * @see EbeanServer#update(Object)
-   */
-  public void update() {
-    db().update(this);
-  }
-
-  /**
-   * Insert this entity.
-   *
-   * @see EbeanServer#insert(Object)
-   */
-  public void insert() {
-    db().insert(this);
-  }
-
-  /**
-   * Delete this bean.
-   * <p>
-   * This will return true if the bean was deleted successfully or JDBC batch is being used.
-   * </p>
-   * <p>
-   * If there is no current transaction one will be created and committed for
-   * you automatically.
-   * </p>
-   * <p>
-   * If the Bean does not have a version property (or loaded version property) and
-   * the bean does not exist then this returns false indicating that nothing was
-   * deleted. Note that, if JDBC batch mode is used then this always returns true.
-   * </p>
-   *
-   * @see EbeanServer#delete(Object)
-   */
-  public boolean delete() {
-    return db().delete(this);
-  }
-
-  /**
-   * Delete a bean permanently without soft delete.
-   * <p>
-   * This is used when the bean contains a <code>@SoftDelete</code> property and we
-   * want to perform a hard/permanent delete.
-   * </p>
-   *
-   * @see EbeanServer#deletePermanent(Object)
-   */
-  public boolean deletePermanent() {
-    return db().deletePermanent(this);
-  }
-
-  /**
-   * Perform an update using this entity against the specified server.
-   */
-  public void update(String server) {
-    db(server).update(this);
-  }
-
-  /**
-   * Perform an insert using this entity against the specified server.
-   */
-  public void insert(String server) {
-    db(server).insert(this);
-  }
-
-  /**
-   * Perform a delete using this entity against the specified server.
-   */
-  public boolean delete(String server) {
-    return db(server).delete(this);
-  }
-
-  /**
-   * Refreshes this entity from the database.
-   *
-   * @see EbeanServer#refresh(Object)
-   */
-  public void refresh() {
-    db().refresh(this);
-  }
-
-  /**
-   * A concrete implementation of Find.
-   * <p>
-   * It should be preferred to use {@link Find} instead of Finder as that can use reflection to determine the class
-   * literal type of the entity bean.
-   * </p>
-   *
-   * @param <I> type of the Id property
-   * @param <T> type of the entity bean
-   */
-  public static class Finder<I, T> extends Find<I, T> {
-
-    /**
-     * Create with the type of the entity bean.
-     * <p>
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   public static final Finder<Long,Customer> find = new Finder<Long,Customer>(Customer.class);
-     *   ...
-     *
-     * }</pre>
-     * <p>
-     * <p/>
-     * The preferred approach is to instead use <code>Find</code> as below. This approach is more DRY in that it does
-     * not require the class literal Customer.class to be passed into the constructor.
-     * <p>
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-     *   ...
-     *
-     * }</pre>
-     */
-    public Finder(Class<T> type) {
-      super(null, type);
-    }
-
-    /**
-     * Create with the type of the entity bean and specific server name.
-     */
-    public Finder(String serverName, Class<T> type) {
-      super(serverName, type);
-    }
-
-  }
-
-  /**
-   * Helper object for performing queries.
-   * <p>
-   * <p>
-   * Typically a Find instance is defined as a public static field on an entity bean class to provide a
-   * nice way to write queries.
-   * <p>
-   * <h3>Example use:</h3>
-   * <p>
-   * <pre>{@code
-   *
-   * @Entity
-   * public class Customer extends BaseModel {
-   *
-   *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-   *
-   *   ...
-   *
-   * }</pre>
-   * <p/>
-   * This enables you to write code like:
-   * <pre>{@code
-   *
-   * Customer customer = Customer.find.byId(42L);
-   *
-   * List<Customer> customers =
-   *     Customer.find
-   *         .select("name, dateOfBirth")
-   *         .findList();
-   *
-   * }</pre>
-   * <p>
-   * <h3>Kotlin</h3>
-   * In Kotlin you would typically create Find as a companion object.
-   * <pre>{@code
-   *
-   *   // kotlin
-   *   companion object : Model.Find<Long, Product>() {}
-   *
-   * }</pre>
-   *
-   * @param <I> The Id type. This is most often a {@link Long} but is also often a {@link UUID} or
-   *            {@link String}.
-   * @param <T> The entity bean type
-   */
-  public static abstract class Find<I, T> {
-
-    /**
-     * The entity bean type.
-     */
-    private final Class<T> type;
-
-    /**
-     * The name of the EbeanServer, null for the default server.
-     */
-    private final String serverName;
-
-    /**
-     * Creates a finder for entity of type <code>T</code> with ID of type <code>I</code>.
-     * <p/>
-     * Typically you create Find as a public static field on each entity bean as the example below.
-     * <p>
-     * <p/>
-     * Note that Find is an abstract class and hence <code>{}</code> is required. This is done so
-     * that the type (class literal) of the entity bean can be derived from the generics parameter.
-     * <p>
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   // Note the trailing {} as Find is an abstract class.
-     *   // We do this so that we can derive the type literal Customer.class
-     *   // via reflection
-     *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-     *   ...
-     *
-     * }</pre>
-     * <p/>
-     * This enables you to write code like:
-     * <pre>{@code
-     *
-     * Customer customer = Customer.find.byId(42L);
-     *
-     * List<Customer> customers =
-     *     Customer.find
-     *        .select("name, email, dateOfBirth")
-     *        .findList();
-     *
-     * }</pre>
-     * <p>
-     * <h3>Kotlin</h3>
-     * In Kotlin you would typically create it as a companion object.
-     * <p>
-     * <pre>{@code
-     *
-     *   // kotlin
-     *   companion object : Model.Find<Long, Product>() {}
-     *
-     * }</pre>
-     */
-    @SuppressWarnings("unchecked")
-    public Find() {
-      this.serverName = null;
-      this.type = (Class<T>) ClassUtil.getSecondArgumentType(getClass());
-    }
-
-    /**
-     * Construct passing the class literal type of the entity type.
-     */
-    protected Find(String serverName, Class<T> type) {
-      this.serverName = serverName;
-      this.type = type;
-    }
-
-    /**
-     * Return the underlying 'default' EbeanServer.
-     * <p>
-     * <p>
-     * This provides full access to the API such as explicit transaction demarcation etc.
-     */
-    public EbeanServer db() {
-      return Ebean.getServer(serverName);
-    }
-
-    /**
-     * Return typically a different EbeanServer to the default.
-     * <p>
-     * This is equivalent to {@link Ebean#getServer(String)}
-     *
-     * @param server The name of the EbeanServer. If this is null then the default EbeanServer is
-     *               returned.
-     */
-    public EbeanServer db(String server) {
-      return Ebean.getServer(server);
-    }
-
-    /**
-     * Creates a Finder for the named EbeanServer.
-     * <p>
-     * <p>
-     * Create and return a new Finder for a different server.
-     */
-    public Finder<I, T> on(String server) {
-      return new Finder<>(server, type);
-    }
-
-    /**
-     * Delete a bean by Id.
-     * <p>
-     * Equivalent to {@link EbeanServer#delete(Class, Object)}
-     */
-    public void deleteById(I id) {
-      db().delete(type, id);
-    }
-
-    /**
-     * Retrieves all entities of the given type.
-     * <p>
-     * <p>
-     * This is the same as (synonym for) {@link #findList()}
-     */
-    public List<T> all() {
-      return findList();
-    }
-
-    /**
-     * Retrieves an entity by ID.
-     * <p>
-     * <p>
-     * Equivalent to {@link EbeanServer#find(Class, Object)}
-     */
-    @Nullable
-    public T byId(I id) {
-      return db().find(type, id);
-    }
-
-    /**
-     * Creates an entity reference for this ID.
-     * <p>
-     * <p>
-     * Equivalent to {@link EbeanServer#getReference(Class, Object)}
-     */
-    public T ref(I id) {
-      return db().getReference(type, id);
-    }
-
-    /**
-     * Creates a filter for sorting and filtering lists of entities locally without going back to
-     * the database.
-     * <p>
-     * Equivalent to {@link EbeanServer#filter(Class)}
-     */
-    public Filter<T> filter() {
-      return db().filter(type);
-    }
-
-    /**
-     * Creates a query.
-     * <p>
-     * Equivalent to {@link EbeanServer#find(Class)}
-     */
-    public Query<T> query() {
-      return db().find(type);
-    }
-
-    /**
-     * Creates a query applying the path properties to set the select and fetch clauses.
-     * <p>
-     * Equivalent to {@link Query#apply(FetchPath)}
-     */
-    public Query<T> apply(FetchPath fetchPath) {
-      return db().find(type).apply(fetchPath);
-    }
-
-    /**
-     * Returns the next identity value.
-     *
-     * @see EbeanServer#nextId(Class)
-     */
-    @SuppressWarnings("unchecked")
-    public I nextId() {
-      return (I) db().nextId(type);
-    }
-
-    /**
-     * Executes a query and returns the results as a list of IDs.
-     * <p>
-     * Equivalent to {@link Query#findIds()}
-     */
-    public <A> List<A> findIds() {
-      return query().findIds();
-    }
-
-    /**
-     * Execute the query consuming each bean one at a time.
-     * <p>
-     * This is generally used to process large queries where unlike findList
-     * you do not want to hold all the results in memory at once but instead
-     * process them one at a time (requiring far less memory).
-     * </p>
-     * Equivalent to {@link Query#findEach(Consumer)}
-     */
-    public void findEach(Consumer<T> consumer) {
-      query().findEach(consumer);
-    }
-
-    /**
-     * Execute the query consuming each bean one at a time.
-     * <p>
-     * Equivalent to {@link Query#findEachWhile(Predicate)}
-     * <p>
-     * This is similar to #findEach except that you return boolean
-     * true to continue processing beans and return false to stop
-     * processing early.
-     * </p>
-     * <p>
-     * This is generally used to process large queries where unlike findList
-     * you do not want to hold all the results in memory at once but instead
-     * process them one at a time (requiring far less memory).
-     * </p>
-     * Equivalent to {@link Query#findEachWhile(Predicate)}
-     */
-    public void findEachWhile(Predicate<T> consumer) {
-      query().findEachWhile(consumer);
-    }
-
-    /**
-     * Retrieves all entities of the given type.
-     * <p>
-     * The same as {@link #all()}
-     * <p>
-     * Equivalent to {@link Query#findList()}
-     */
-    public List<T> findList() {
-      return query().findList();
-    }
-
-    /**
-     * Returns all the entities of the given type as a set.
-     * <p>
-     * Equivalent to {@link Query#findSet()}
-     */
-    public Set<T> findSet() {
-      return query().findSet();
-    }
-
-    /**
-     * Retrieves all entities of the given type as a map of objects.
-     * <p>
-     * Equivalent to {@link Query#findMap()}
-     */
-    public <K> Map<K, T> findMap() {
-      return query().findMap();
-    }
-
-    /**
-     * Executes a find row count query in a background thread.
-     * <p>
-     * Equivalent to {@link Query#findFutureCount()}
-     */
-    public FutureRowCount<T> findFutureCount() {
-      return query().findFutureCount();
-    }
-
-    /**
-     * Deprecated in favor of findFutureCount().
-     * <p>
-     * Equivalent to {@link Query#findFutureCount()}
-     */
-    public FutureRowCount<T> findFutureRowCount() {
-      return query().findFutureCount();
-    }
-
-    /**
-     * Returns the total number of entities for this type. *
-     * <p>
-     * Equivalent to {@link Query#findCount()}
-     */
-    public int findCount() {
-      return query().findCount();
-    }
-
-    /**
-     * Deprecated in favor of findCount().
-     *
-     * @deprecated
-     */
-    public int findRowCount() {
-      return query().findCount();
-    }
-
-    /**
-     * Returns the <code>ExpressionFactory</code> used by this query.
-     */
-    public ExpressionFactory getExpressionFactory() {
-      return query().getExpressionFactory();
-    }
-
-    /**
-     * Explicitly sets a comma delimited list of the properties to fetch on the 'main' entity bean,
-     * to load a partial object.
-     * <p>
-     * Equivalent to {@link Query#select(String)}
-     */
-    public Query<T> select(String fetchProperties) {
-      return query().select(fetchProperties);
-    }
-
-    /**
-     * Specifies a path to load including all its properties.
-     * <p>
-     * Equivalent to {@link Query#fetch(String)}
-     */
-    public Query<T> fetch(String path) {
-      return query().fetch(path);
-    }
-
-    /**
-     * Additionally specifies a <code>FetchConfig</code> to specify a 'query join' and/or define the
-     * lazy loading query.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, FetchConfig)}
-     */
-    public Query<T> fetch(String path, FetchConfig joinConfig) {
-      return query().fetch(path, joinConfig);
-    }
-
-    /**
-     * Specifies a path to fetch with a specific list properties to include, to load a partial
-     * object.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, String)}
-     */
-    public Query<T> fetch(String path, String fetchProperties) {
-      return query().fetch(path, fetchProperties);
-    }
-
-    /**
-     * Additionally specifies a <code>FetchConfig</code> to use a separate query or lazy loading to
-     * load this path.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, String, FetchConfig)}
-     */
-    public Query<T> fetch(String assocProperty, String fetchProperties, FetchConfig fetchConfig) {
-      return query().fetch(assocProperty, fetchProperties, fetchConfig);
-    }
-
-    /**
-     * Adds expressions to the <code>where</code> clause with the ability to chain on the
-     * <code>ExpressionList</code>.
-     * <p>
-     * Equivalent to {@link Query#where()}
-     */
-    public ExpressionList<T> where() {
-      return query().where();
-    }
-
-    /**
-     * Returns the <code>order by</code> clause so that you can append an ascending or descending
-     * property to the <code>order by</code> clause.
-     * <p>
-     * This is exactly the same as {@link #orderBy}.
-     * <p>
-     * Equivalent to {@link Query#order()}
-     */
-    public OrderBy<T> order() {
-      return query().order();
-    }
-
-    /**
-     * Sets the <code>order by</code> clause, replacing the existing <code>order by</code> clause if
-     * there is one.
-     * <p>
-     * This is exactly the same as {@link #orderBy(String)}.
-     */
-    public Query<T> order(String orderByClause) {
-      return query().order(orderByClause);
-    }
-
-    /**
-     * Returns the <code>order by</code> clause so that you can append an ascending or descending
-     * property to the <code>order by</code> clause.
-     * <p>
-     * This is exactly the same as {@link #order}.
-     * <p>
-     * Equivalent to {@link Query#orderBy()}
-     */
-    public OrderBy<T> orderBy() {
-      return query().orderBy();
-    }
-
-    /**
-     * Set the <code>order by</code> clause replacing the existing <code>order by</code> clause if
-     * there is one.
-     * <p>
-     * This is exactly the same as {@link #order(String)}.
-     */
-    public Query<T> orderBy(String orderByClause) {
-      return query().orderBy(orderByClause);
-    }
-
-    /**
-     * Sets the first row to return for this query.
-     * <p>
-     * Equivalent to {@link Query#setFirstRow(int)}
-     */
-    public Query<T> setFirstRow(int firstRow) {
-      return query().setFirstRow(firstRow);
-    }
-
-    /**
-     * Sets the maximum number of rows to return in the query.
-     * <p>
-     * Equivalent to {@link Query#setMaxRows(int)}
-     */
-    public Query<T> setMaxRows(int maxRows) {
-      return query().setMaxRows(maxRows);
-    }
-
-    /**
-     * Sets the ID value to query.
-     * <p>
-     * <p>
-     * Use this to perform a find byId query but with additional control over the query such as
-     * using select and fetch to control what parts of the object graph are returned.
-     * <p>
-     * Equivalent to {@link Query#setId(Object)}
-     */
-    public Query<T> setId(Object id) {
-      return query().setId(id);
-    }
-
-    /**
-     * Create and return a new query based on the <code>RawSql</code>.
-     * <p>
-     * Equivalent to {@link Query#setRawSql(RawSql)}
-     */
-    public Query<T> setRawSql(RawSql rawSql) {
-      return query().setRawSql(rawSql);
-    }
-
-    /**
-     * Create a query with explicit 'AutoTune' use.
-     */
-    public Query<T> setAutoTune(boolean autoTune) {
-      return query().setAutoTune(autoTune);
-    }
-
-    /**
-     * Create a query with the select with "for update" specified.
-     * <p>
-     * <p>
-     * This will typically create row level database locks on the selected rows.
-     */
-    public Query<T> setForUpdate(boolean forUpdate) {
-      return query().setForUpdate(forUpdate);
-    }
-
-    /**
-     * Create a query specifying whether the returned beans will be read-only.
-     */
-    public Query<T> setReadOnly(boolean readOnly) {
-      return query().setReadOnly(readOnly);
-    }
-
-    /**
-     * Create a query specifying if the beans should be loaded into the L2 cache.
-     */
-    public Query<T> setLoadBeanCache(boolean loadBeanCache) {
-      return query().setLoadBeanCache(loadBeanCache);
-    }
-
-    /**
-     * Create a query specifying if the L2 bean cache should be used.
-     */
-    public Query<T> setUseCache(boolean useBeanCache) {
-      return query().setUseCache(useBeanCache);
-    }
-
-    /**
-     * Create a query specifying if the L2 query cache should be used.
-     */
-    public Query<T> setUseQueryCache(boolean useQueryCache) {
-      return query().setUseQueryCache(useQueryCache);
-    }
-
-  }
-}
@@ -1,732 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.util.CamelCaseHelper;
-
-import java.io.Serializable;
-import java.sql.ResultSet;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Used to build object graphs based on a raw SQL statement (rather than
- * generated by Ebean).
- * <p>
- * If you don't want to build object graphs you can use {@link SqlQuery} instead
- * which returns {@link SqlRow} objects rather than entity beans.
- * </p>
- * <p>
- * <b>Unparsed RawSql:</b>
- * </p>
- * <p>
- * When RawSql is created via {@link RawSqlBuilder#unparsed(String)} then Ebean can not
- * modify the SQL at all. It can't add any extra expressions into the SQL.
- * </p>
- * <p>
- * <b>Parsed RawSql:</b>
- * </p>
- * <p>
- * When RawSql is created via {@link RawSqlBuilder#parse(String)} then Ebean will parse the
- * SQL and find places in the SQL where it can add extra where expressions, add
- * extra having expressions or replace the order by clause. If you want to
- * explicitly tell Ebean where these insertion points are you can place special
- * strings into your SQL ({@code ${where}} or {@code ${andWhere}} and {@code ${having}} or
- * {@code ${andHaving})}.
- * </p>
- * <p>
- * If the SQL already includes a WHERE clause put in {@code ${andWhere}} in the location
- * you want Ebean to add any extra where expressions. If the SQL doesn't have a
- * WHERE clause put {@code ${where}} in instead. Similarly you can put in {@code ${having}} or
- * {@code ${andHaving}} where you want Ebean put add extra having expressions.
- * </p>
- * <p>
- * <b>Aggregates:</b>
- * </p>
- * <p>
- * Often RawSql will be used with Aggregate functions (sum, avg, max etc). The
- * follow example shows an example based on Total Order Amount -
- * sum(d.order_qty*d.unit_price).
- * </p>
- * <p>
- * We can use a OrderAggregate bean that has a &#064;Sql to indicate it is based
- * on RawSql and not based on a real DB Table or DB View. It has some properties
- * to hold the values for the aggregate functions (sum etc) and a &#064;OneToOne
- * to Order.
- * </p>
- * <p>
- * <h3>Example OrderAggregate</h3>
- * <pre>{@code
- *  ...
- *  // @Sql indicates to that this bean
- *  // is based on RawSql rather than a table
- *
- * @Entity
- * @Sql
- * public class OrderAggregate {
- *
- *  @OneToOne
- *  Order order;
- *
- *  Double totalAmount;
- *
- *  Double totalItems;
- *
- *  // getters and setters
- *  ...
- *
- * }</pre>
- * <p>
- * <h3>Example 1:</h3>
- * <p>
- * <pre>{@code
- *
- *   String sql = " select order_id, o.status, c.id, c.name, sum(d.order_qty*d.unit_price) as totalAmount"
- *     + " from o_order o"
- *     + " join o_customer c on c.id = o.kcustomer_id "
- *     + " join o_order_detail d on d.order_id = o.id " + " group by order_id, o.status ";
- *
- *   RawSql rawSql = RawSqlBuilder.parse(sql)
- *     // map the sql result columns to bean properties
- *     .columnMapping("order_id", "order.id")
- *     .columnMapping("o.status", "order.status")
- *     .columnMapping("c.id", "order.customer.id")
- *     .columnMapping("c.name", "order.customer.name")
- *     // we don't need to map this one due to the sql column alias
- *     // .columnMapping("sum(d.order_qty*d.unit_price)", "totalAmount")
- *     .create();
- *
- *   List<OrderAggregate> list = Ebean.find(OrderAggregate.class)
- *       .setRawSql(rawSql)
- *       .where().gt("order.id", 0)
- *       .having().gt("totalAmount", 20)
- *       .findList();
- *
- *
- * }</pre>
- * <p>
- * <h3>Example 2:</h3>
- * <p>
- * The following example uses a FetchConfig().query() so that after the initial
- * RawSql query is executed Ebean executes a secondary query to fetch the
- * associated order status, orderDate along with the customer name.
- * </p>
- * <p>
- * <pre>{@code
- *
- *  String sql = " select order_id, 'ignoreMe', sum(d.order_qty*d.unit_price) as totalAmount "
- *     + " from o_order_detail d"
- *     + " group by order_id ";
- *
- *   RawSql rawSql = RawSqlBuilder.parse(sql)
- *     .columnMapping("order_id", "order.id")
- *     .columnMappingIgnore("'ignoreMe'")
- *     .create();
- *
- *   List<OrderAggregate> orders = Ebean.find(OrderAggregate.class)
- *     .setRawSql(rawSql)
- *     .fetch("order", "status,orderDate", new FetchConfig().query())
- *     .fetch("order.customer", "name")
- *     .where().gt("order.id", 0)
- *     .having().gt("totalAmount", 20)
- *     .order().desc("totalAmount")
- *     .setMaxRows(10)
- *     .findList();
- *
- * }</pre>
- * <p>
- * <h3>Example 3: tableAliasMapping</h3>
- * <p>
- * Instead of mapping each column you can map each table alias to a path using tableAliasMapping().
- * </p>
- * <pre>{@code
- *
- *   String rs = "select o.id, o.status, c.id, c.name, "+
- *               " d.id, d.order_qty, p.id, p.name " +
- *               "from o_order o join o_customer c on c.id = o.kcustomer_id " +
- *               "join o_order_detail d on d.order_id = o.id  " +
- *               "join o_product p on p.id = d.product_id  " +
- *               "where o.id <= :maxOrderId  and p.id = :productId "+
- *               "order by o.id, d.id asc";
- *
- *  RawSql rawSql = RawSqlBuilder.parse(rs)
- *       .tableAliasMapping("c", "customer")
- *       .tableAliasMapping("d", "details")
- *       .tableAliasMapping("p", "details.product")
- *       .create();
- *
- *  List<Order> ordersFromRaw = Ebean.find(Order.class)
- *       .setRawSql(rawSql)
- *       .setParameter("maxOrderId", 2)
- *       .setParameter("productId", 1)
- *       .findList();
- *
- * }</pre>
- * <p>
- * <p>
- * Note that lazy loading also works with object graphs built with RawSql.
- * </p>
- */
-public final class RawSql implements Serializable {
-
-  private static final long serialVersionUID = 1L;
-
-  private final ResultSet resultSet;
-
-  private final Sql sql;
-
-  private final ColumnMapping columnMapping;
-
-  /**
-   * Construct with a ResultSet and properties that the columns map to.
-   * <p>
-   * The properties listed in the propertyNames must be in the same order as the columns in the
-   * resultSet.
-   * <p>
-   * When a query executes this RawSql object then it will close the resultSet.
-   */
-  public RawSql(ResultSet resultSet, String... propertyNames) {
-    this.resultSet = resultSet;
-    this.sql = null;
-    this.columnMapping = new ColumnMapping(propertyNames);
-  }
-
-  protected RawSql(ResultSet resultSet, Sql sql, ColumnMapping columnMapping) {
-    this.resultSet = resultSet;
-    this.sql = sql;
-    this.columnMapping = columnMapping;
-  }
-
-  /**
-   * Return the Sql either unparsed or in parsed (broken up) form.
-   */
-  public Sql getSql() {
-    return sql;
-  }
-
-  /**
-   * Return the key;
-   */
-  public Key getKey() {
-    boolean parsed = sql != null && sql.parsed;
-    String unParsedSql = (sql == null) ? "" : sql.unparsedSql;
-    return new Key(parsed, unParsedSql, columnMapping);
-  }
-
-  /**
-   * Return the resultSet if this is a ResultSet based RawSql.
-   */
-  public ResultSet getResultSet() {
-    return resultSet;
-  }
-
-  /**
-   * Return the column mapping for the SQL columns to bean properties.
-   */
-  public ColumnMapping getColumnMapping() {
-    return columnMapping;
-  }
-
-  /**
-   * Represents the sql part of the query. For parsed RawSql the sql is broken
-   * up so that Ebean can insert extra WHERE and HAVING expressions into the
-   * SQL.
-   */
-  public static final class Sql implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
-    private final boolean parsed;
-
-    private final String unparsedSql;
-
-    private final String preFrom;
-
-    private final String preWhere;
-
-    private final boolean andWhereExpr;
-
-    private final String preHaving;
-
-    private final boolean andHavingExpr;
-
-    private final String orderByPrefix;
-
-    private final String orderBy;
-
-    private final boolean distinct;
-
-    /**
-     * Construct for unparsed SQL.
-     */
-    protected Sql(String unparsedSql) {
-      this.parsed = false;
-      this.unparsedSql = unparsedSql;
-      this.preFrom = null;
-      this.preHaving = null;
-      this.preWhere = null;
-      this.andHavingExpr = false;
-      this.andWhereExpr = false;
-      this.orderByPrefix = null;
-      this.orderBy = null;
-      this.distinct = false;
-    }
-
-    /**
-     * Construct for parsed SQL.
-     */
-    protected Sql(String unparsedSql, String preFrom, String preWhere, boolean andWhereExpr,
-                  String preHaving, boolean andHavingExpr, String orderByPrefix, String orderBy, boolean distinct) {
-
-      this.unparsedSql = unparsedSql;
-      this.parsed = true;
-      this.preFrom = preFrom;
-      this.preHaving = preHaving;
-      this.preWhere = preWhere;
-      this.andHavingExpr = andHavingExpr;
-      this.andWhereExpr = andWhereExpr;
-      this.orderByPrefix = orderByPrefix;
-      this.orderBy = orderBy;
-      this.distinct = distinct;
-    }
-
-    public String toString() {
-      if (!parsed) {
-        return "unparsed[" + unparsedSql + "]";
-      }
-      return "select[" + preFrom + "] preWhere[" + preWhere + "] preHaving[" + preHaving + "] orderBy[" + orderBy + "]";
-    }
-
-    public boolean isDistinct() {
-      return distinct;
-    }
-
-    /**
-     * Return true if the SQL is left completely unmodified.
-     * <p>
-     * This means Ebean can't add WHERE or HAVING expressions into the query -
-     * it will be left completely unmodified.
-     * </p>
-     */
-    public boolean isParsed() {
-      return parsed;
-    }
-
-    /**
-     * Return the SQL when it is unparsed.
-     */
-    public String getUnparsedSql() {
-      return unparsedSql;
-    }
-
-    /**
-     * Return the SQL prior to FROM clause.
-     */
-    public String getPreFrom() {
-      return preFrom;
-    }
-
-    /**
-     * Return the SQL prior to WHERE clause.
-     */
-    public String getPreWhere() {
-      return preWhere;
-    }
-
-    /**
-     * Return true if there is already a WHERE clause and any extra where
-     * expressions start with AND.
-     */
-    public boolean isAndWhereExpr() {
-      return andWhereExpr;
-    }
-
-    /**
-     * Return the SQL prior to HAVING clause.
-     */
-    public String getPreHaving() {
-      return preHaving;
-    }
-
-    /**
-     * Return true if there is already a HAVING clause and any extra having
-     * expressions start with AND.
-     */
-    public boolean isAndHavingExpr() {
-      return andHavingExpr;
-    }
-
-    /**
-     * Return the 'order by' keywords.
-     * This can contain additional keywords, for example 'order siblings by' as Oracle syntax.
-     */
-    public String getOrderByPrefix() {
-      return (orderByPrefix == null) ? "order by" : orderByPrefix;
-    }
-
-    /**
-     * Return the SQL ORDER BY clause.
-     */
-    public String getOrderBy() {
-      return orderBy;
-    }
-
-  }
-
-  /**
-   * Defines the column mapping for raw sql DB columns to bean properties.
-   */
-  public static final class ColumnMapping implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
-    private final LinkedHashMap<String, Column> dbColumnMap;
-
-    private final Map<String, String> propertyMap;
-
-    private final Map<String, Column> propertyColumnMap;
-
-    private final boolean parsed;
-
-    private final boolean immutable;
-
-    /**
-     * Construct from parsed sql where the columns have been identified.
-     */
-    protected ColumnMapping(List<Column> columns) {
-      this.immutable = false;
-      this.parsed = true;
-      this.propertyMap = null;
-      this.propertyColumnMap = null;
-      this.dbColumnMap = new LinkedHashMap<>();
-      for (Column c : columns) {
-        dbColumnMap.put(c.getDbColumnKey(), c);
-      }
-    }
-
-    /**
-     * Construct for unparsed sql.
-     */
-    protected ColumnMapping() {
-      this.immutable = false;
-      this.parsed = false;
-      this.propertyMap = null;
-      this.propertyColumnMap = null;
-      this.dbColumnMap = new LinkedHashMap<>();
-    }
-
-    /**
-     * Construct for ResultSet use.
-     */
-    protected ColumnMapping(String... propertyNames) {
-      this.immutable = false;
-      this.parsed = false;
-      this.propertyMap = null;
-      this.dbColumnMap = new LinkedHashMap<>();
-
-      int pos = 0;
-      for (String prop : propertyNames) {
-        dbColumnMap.put(prop, new Column(pos++, prop, null, prop));
-      }
-      propertyColumnMap = dbColumnMap;
-    }
-
-    /**
-     * Construct an immutable ColumnMapping based on collected information.
-     */
-    protected ColumnMapping(boolean parsed, LinkedHashMap<String, Column> dbColumnMap) {
-      this.immutable = true;
-      this.parsed = parsed;
-      this.dbColumnMap = dbColumnMap;
-
-      HashMap<String, Column> pcMap = new HashMap<>();
-      HashMap<String, String> pMap = new HashMap<>();
-
-      for (Column c : dbColumnMap.values()) {
-        pMap.put(c.getPropertyName(), c.getDbColumn());
-        pcMap.put(c.getPropertyName(), c);
-      }
-      this.propertyMap = Collections.unmodifiableMap(pMap);
-      this.propertyColumnMap = Collections.unmodifiableMap(pcMap);
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) return true;
-      if (o == null || getClass() != o.getClass()) return false;
-      ColumnMapping that = (ColumnMapping) o;
-      return dbColumnMap.equals(that.dbColumnMap);
-    }
-
-    @Override
-    public int hashCode() {
-      return dbColumnMap.hashCode();
-    }
-
-    /**
-     * Return true if the property is mapped.
-     */
-    public boolean contains(String property) {
-      return this.propertyColumnMap.containsKey(property);
-    }
-
-    /**
-     * Creates an immutable copy of this ColumnMapping.
-     *
-     * @throws IllegalStateException when a propertyName has not been defined for a column.
-     */
-    protected ColumnMapping createImmutableCopy() {
-
-      for (Column c : dbColumnMap.values()) {
-        c.checkMapping();
-      }
-
-      return new ColumnMapping(parsed, dbColumnMap);
-    }
-
-    protected void columnMapping(String dbColumn, String propertyName) {
-
-      if (immutable) {
-        throw new IllegalStateException("Should never happen");
-      }
-      if (!parsed) {
-        int pos = dbColumnMap.size();
-        dbColumnMap.put(dbColumn, new Column(pos, dbColumn, null, propertyName));
-      } else {
-        Column column = dbColumnMap.get(dbColumn);
-        if (column == null) {
-          String msg = "DB Column [" + dbColumn + "] not found in mapping. Expecting one of [" + dbColumnMap.keySet() + "]";
-          throw new IllegalArgumentException(msg);
-        }
-        column.setPropertyName(propertyName);
-      }
-    }
-
-    /**
-     * Returns true if the Columns where supplied by parsing the sql select
-     * clause.
-     * <p>
-     * In the case where the columns where parsed then we can do extra checks on
-     * the column mapping such as, is the column a valid one in the sql and
-     * whether all the columns in the sql have been mapped.
-     * </p>
-     */
-    public boolean isParsed() {
-      return parsed;
-    }
-
-    /**
-     * Return the number of columns in this column mapping.
-     */
-    public int size() {
-      return dbColumnMap.size();
-    }
-
-    /**
-     * Return the column mapping.
-     */
-    protected Map<String, Column> mapping() {
-      return dbColumnMap;
-    }
-
-    /**
-     * Return the mapping by DB column.
-     */
-    public Map<String, String> getMapping() {
-      return propertyMap;
-    }
-
-    /**
-     * Return the index position by bean property name.
-     */
-    public int getIndexPosition(String property) {
-      Column c = propertyColumnMap.get(property);
-      return c == null ? -1 : c.getIndexPos();
-    }
-
-    /**
-     * Return an iterator of the Columns.
-     */
-    public Iterator<Column> getColumns() {
-      return dbColumnMap.values().iterator();
-    }
-
-    /**
-     * Modify any column mappings with the given table alias to have the path prefix.
-     * <p>
-     * For example modify all mappings with table alias "c" to have the path prefix "customer".
-     * </p>
-     * <p>
-     * For the "Root type" you don't need to specify a tableAliasMapping.
-     * </p>
-     */
-    public void tableAliasMapping(String tableAlias, String path) {
-
-      String startMatch = tableAlias + ".";
-      for (Map.Entry<String, Column> entry : dbColumnMap.entrySet()) {
-        if (entry.getKey().startsWith(startMatch)) {
-          entry.getValue().tableAliasMapping(path);
-        }
-      }
-    }
-
-    /**
-     * A Column of the RawSql that is mapped to a bean property (or ignored).
-     */
-    public static class Column implements Serializable {
-
-      private static final long serialVersionUID = 1L;
-      private final int indexPos;
-      private final String dbColumn;
-
-      private final String dbAlias;
-
-      private String propertyName;
-
-      /**
-       * Construct a Column.
-       */
-      public Column(int indexPos, String dbColumn, String dbAlias) {
-        this(indexPos, dbColumn, dbAlias, derivePropertyName(dbAlias, dbColumn));
-      }
-
-      private Column(int indexPos, String dbColumn, String dbAlias, String propertyName) {
-        this.indexPos = indexPos;
-        this.dbColumn = dbColumn;
-        this.dbAlias = dbAlias;
-        if (propertyName == null && dbAlias != null) {
-          this.propertyName = dbAlias;
-        } else {
-          this.propertyName = propertyName;
-        }
-      }
-
-      protected static String derivePropertyName(String dbAlias, String dbColumn) {
-        if (dbAlias != null) {
-          return CamelCaseHelper.toCamelFromUnderscore(dbAlias);
-        }
-        int dotPos = dbColumn.indexOf('.');
-        if (dotPos > -1) {
-          dbColumn = dbColumn.substring(dotPos + 1);
-        }
-        return CamelCaseHelper.toCamelFromUnderscore(dbColumn);
-      }
-
-      private void checkMapping() {
-        if (propertyName == null) {
-          String msg = "No propertyName defined (Column mapping) for dbColumn [" + dbColumn + "]";
-          throw new IllegalStateException(msg);
-        }
-      }
-
-      @Override
-      public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        Column that = (Column) o;
-        if (indexPos != that.indexPos) return false;
-        if (!dbColumn.equals(that.dbColumn)) return false;
-        if (dbAlias != null ? !dbAlias.equals(that.dbAlias) : that.dbAlias != null) return false;
-        return propertyName != null ? propertyName.equals(that.propertyName) : that.propertyName == null;
-      }
-
-      @Override
-      public int hashCode() {
-        int result = indexPos;
-        result = 31 * result + dbColumn.hashCode();
-        result = 31 * result + (dbAlias != null ? dbAlias.hashCode() : 0);
-        result = 31 * result + (propertyName != null ? propertyName.hashCode() : 0);
-        return result;
-      }
-
-      public String toString() {
-        return dbColumn + "->" + propertyName;
-      }
-
-      /**
-       * Return the index position of this column.
-       */
-      public int getIndexPos() {
-        return indexPos;
-      }
-
-      /**
-       * Return the DB column alias if specified otherwise DB column.
-       * This is used as the key for mapping a column to a logical property.
-       */
-      public String getDbColumnKey() {
-        return (dbAlias != null) ? dbAlias : dbColumn;
-      }
-
-      /**
-       * Return the DB column name including table alias (if it has one).
-       */
-      public String getDbColumn() {
-        return dbColumn;
-      }
-
-      /**
-       * Return the bean property this column is mapped to.
-       */
-      public String getPropertyName() {
-        return propertyName;
-      }
-
-      /**
-       * Set the property name mapped to this db column.
-       */
-      private void setPropertyName(String propertyName) {
-        this.propertyName = propertyName;
-      }
-
-      /**
-       * Prepend the path to the property name.
-       * <p/>
-       * For example if path is "customer" then "name" becomes "customer.name".
-       */
-      public void tableAliasMapping(String path) {
-        if (path != null) {
-          propertyName = path + "." + propertyName;
-        }
-      }
-    }
-  }
-
-  /**
-   * A key for the RawSql object using for the query plan.
-   */
-  public static final class Key {
-
-    private final boolean parsed;
-    private final ColumnMapping columnMapping;
-    private final String unParsedSql;
-
-    Key(boolean parsed, String unParsedSql, ColumnMapping columnMapping) {
-      this.parsed = parsed;
-      this.unParsedSql = unParsedSql;
-      this.columnMapping = columnMapping;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) return true;
-      if (o == null || getClass() != o.getClass()) return false;
-
-      Key that = (Key) o;
-      return parsed == that.parsed
-        && columnMapping.equals(that.columnMapping)
-        && unParsedSql.equals(that.unParsedSql);
-    }
-
-    @Override
-    public int hashCode() {
-      int result = (parsed ? 1 : 0);
-      result = 31 * result + columnMapping.hashCode();
-      result = 31 * result + unParsedSql.hashCode();
-      return result;
-    }
-  }
-}
@@ -1,131 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.RawSql.ColumnMapping;
-import com.avaje.ebean.RawSql.Sql;
-
-import java.sql.ResultSet;
-
-/**
- * Builds RawSql instances from a SQL string and column mappings.
- * <p>
- * Note that RawSql can also be defined in ebean-orm.xml files and be used as a
- * named query.
- * </p>
- *
- * @see RawSql
- */
-public class RawSqlBuilder {
-
-  /**
-   * Special property name assigned to a DB column that should be ignored.
-   */
-  public static final String IGNORE_COLUMN = "$$_IGNORE_COLUMN_$$";
-
-  private final ResultSet resultSet;
-
-  private final Sql sql;
-
-  private final ColumnMapping columnMapping;
-
-  /**
-   * Create and return a RawSql object based on the resultSet and list of properties the columns in
-   * the resultSet map to.
-   * <p>
-   * The properties listed in the propertyNames must be in the same order as the columns in the
-   * resultSet.
-   */
-  public static RawSql resultSet(ResultSet resultSet, String... propertyNames) {
-    return new RawSql(resultSet, propertyNames);
-  }
-
-  /**
-   * 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
-   * this query.
-   */
-  public static RawSqlBuilder unparsed(String sql) {
-
-    Sql s = new Sql(sql);
-    return new RawSqlBuilder(s, new ColumnMapping());
-  }
-
-  /**
-   * Return a RawSqlBuilder parsing the sql.
-   * <p>
-   * The sql statement will be parsed so that Ebean can determine where it can
-   * insert additional WHERE or HAVING expressions.
-   * </p>
-   * <p>
-   * Additionally the selected columns are parsed to determine the column
-   * ordering. This also means additional checks can be made with the column
-   * mapping - specifically we can check that all columns are mapped and that
-   * correct column names are entered into the mapping.
-   * </p>
-   */
-  public static RawSqlBuilder parse(String sql) {
-
-    Sql sql2 = DRawSqlParser.parse(sql);
-    String select = sql2.getPreFrom();
-
-    ColumnMapping mapping = DRawSqlColumnsParser.parse(select);
-    return new RawSqlBuilder(sql2, mapping);
-  }
-
-  private RawSqlBuilder(Sql sql, ColumnMapping columnMapping) {
-    this.sql = sql;
-    this.columnMapping = columnMapping;
-    this.resultSet = null;
-  }
-
-  /**
-   * Set the mapping of a DB Column to a bean property.
-   * <p>
-   * For Unparsed SQL the columnMapping MUST be defined in the same order that
-   * the columns appear in the SQL statement.
-   * </p>
-   *
-   * @param dbColumn     the DB column that we are mapping to a bean property
-   * @param propertyName the bean property that we are mapping the DB column to.
-   */
-  public RawSqlBuilder columnMapping(String dbColumn, String propertyName) {
-    columnMapping.columnMapping(dbColumn, propertyName);
-    return this;
-  }
-
-  /**
-   * Ignore this DB column. It is not mapped to any bean property.
-   */
-  public RawSqlBuilder columnMappingIgnore(String dbColumn) {
-    return columnMapping(dbColumn, IGNORE_COLUMN);
-  }
-
-  /**
-   * Modify any column mappings with the given table alias to have the path prefix.
-   * <p>
-   * For example modify all mappings with table alias "c" to have the path prefix "customer".
-   * </p>
-   * <p>
-   * For the "Root type" you don't need to specify a tableAliasMapping.
-   * </p>
-   */
-  public RawSqlBuilder tableAliasMapping(String tableAlias, String path) {
-    columnMapping.tableAliasMapping(tableAlias, path);
-    return this;
-  }
-
-  /**
-   * Create the immutable RawSql object. Do this after all the column mapping
-   * has been defined.
-   */
-  public RawSql create() {
-    return new RawSql(resultSet, sql, columnMapping.createImmutableCopy());
-  }
-
-  /**
-   * Return the internal parsed Sql object (for testing).
-   */
-  protected Sql getSql() {
-    return sql;
-  }
-
-}
@@ -1,116 +0,0 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-import java.util.List;
-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>
- * <p>
- * The returned SqlRow objects are similar to a LinkedHashMap with some type
- * conversion support added.
- * </p>
- * <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
- *
- *   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();
- *
- * }</pre>
- */
-public interface SqlQuery extends Serializable {
-
-  /**
-   * Execute the query returning a list.
-   */
-  List<SqlRow> findList();
-
-  /**
-   * 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(Consumer<SqlRow> consumer);
-
-  /**
-   * 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(Predicate<SqlRow> consumer);
-
-  /**
-   * Execute the query returning a single row or null.
-   * <p>
-   * If this query finds 2 or more rows then it will throw a
-   * PersistenceException.
-   * </p>
-   */
-  SqlRow findUnique();
-
-  /**
-   * The same as bind for named parameters.
-   */
-  SqlQuery setParameter(String name, Object value);
-
-  /**
-   * The same as bind for positioned parameters.
-   */
-  SqlQuery setParameter(int position, Object value);
-
-  /**
-   * Set the index of the first row of the results to return.
-   */
-  SqlQuery setFirstRow(int firstRow);
-
-  /**
-   * Set the maximum number of query results to return.
-   */
-  SqlQuery setMaxRows(int maxRows);
-
-  /**
-   * 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.
-   */
-  SqlQuery 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>
-   */
-  SqlQuery setBufferFetchSizeHint(int bufferFetchSizeHint);
-
-}
@@ -1,147 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * A SqlUpdate for executing insert update or delete statements.
- * <p>
- * Provides a simple way to execute raw SQL insert update or delete statements
- * without having to resort to JDBC.
- * </p>
- * <p>
- * Supports the use of positioned or named parameters and can automatically
- * notify Ebean of the table modified so that Ebean can maintain its cache.
- * </p>
- * <p>
- * Note that {@link #setAutoTableMod(boolean)} and
- * Ebean#externalModification(String, boolean, boolean, boolean)} can be to
- * notify Ebean of external changes and enable Ebean to maintain it's "L2"
- * server cache.
- * </p>
- * <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);
- *
- * int modifiedCount = Ebean.execute(update);
- *
- * String msg = "There were " + modifiedCount + " rows updated";
- *
- * }</pre>
- *
- * @see Update
- * @see SqlQuery
- * @see CallableSql
- */
-public interface SqlUpdate {
-
-  /**
-   * Execute the update returning the number of rows modified.
-   * <p>
-   * After you have executed the SqlUpdate you can bind new variables using
-   * {@link #setParameter(String, Object)} etc and then execute the SqlUpdate
-   * again.
-   * </p>
-   * <p>
-   * For JDBC batch processing refer to
-   * {@link Transaction#setBatchMode(boolean)} and
-   * {@link Transaction#setBatchSize(int)}.
-   * </p>
-   *
-   * @see com.avaje.ebean.Ebean#execute(SqlUpdate)
-   */
-  int execute();
-
-  /**
-   * Return true if eBean should automatically deduce the table modification
-   * information and process it.
-   * <p>
-   * If this is true then cache invalidation and text index management are aware
-   * of the modification.
-   * </p>
-   */
-  boolean isAutoTableMod();
-
-  /**
-   * Set this to false if you don't want eBean to automatically deduce the table
-   * modification information and process it.
-   * <p>
-   * Set this to false if you don't want any cache invalidation or text index
-   * management to occur. You may do this when say you update only one column
-   * and you know that it is not important for cached objects or text indexes.
-   * </p>
-   */
-  SqlUpdate setAutoTableMod(boolean isAutoTableMod);
-
-  /**
-   * Return the label that can be seen in the transaction logs.
-   */
-  String getLabel();
-
-  /**
-   * Set a descriptive text that can be put into the transaction log.
-   * <p>
-   * Useful when identifying the statement in the transaction log.
-   * </p>
-   */
-  SqlUpdate setLabel(String label);
-
-  /**
-   * Return the sql statement.
-   */
-  String getSql();
-
-  /**
-   * Return the generated sql that has named parameters converted to positioned parameters.
-   */
-  String getGeneratedSql();
-
-  /**
-   * Return the timeout used to execute this statement.
-   */
-  int getTimeout();
-
-  /**
-   * Set the timeout in seconds. Zero implies no limit.
-   * <p>
-   * This will set the query timeout on the underlying PreparedStatement. If the
-   * timeout expires a SQLException will be throw and wrapped in a
-   * PersistenceException.
-   * </p>
-   */
-  SqlUpdate setTimeout(int secs);
-
-  /**
-   * Set a parameter via its index position.
-   */
-  SqlUpdate setParameter(int position, Object value);
-
-  /**
-   * Set a null parameter via its index position.
-   */
-  SqlUpdate setNull(int position, int jdbcType);
-
-  /**
-   * Set a null valued parameter using its index position.
-   */
-  SqlUpdate setNullParameter(int position, int jdbcType);
-
-  /**
-   * Set a named parameter value.
-   */
-  SqlUpdate setParameter(String name, Object param);
-
-  /**
-   * Set a named parameter that has a null value. Exactly the same as
-   * {@link #setNullParameter(String, int)}.
-   */
-  SqlUpdate setNull(String name, int jdbcType);
-
-  /**
-   * Set a named parameter that has a null value.
-   */
-  SqlUpdate setNullParameter(String name, int jdbcType);
-
-}
@@ -1,47 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Execute a TxCallable in a Transaction scope.
- * <p>
- * Use this with the {@link Ebean#execute(TxCallable)} method.
- * </p>
- * <p>
- * Note that this is basically the same as TxRunnable except that it returns an
- * Object (and you specify the return type via generics).
- * </p>
- * <p>
- * See also {@link TxRunnable}.
- * </p>
- * <p>
- * <pre>{@code
- *
- * Ebean.execute(new TxCallable<String>() {
- *   public String call() {
- *     User u1 = Ebean.find(User.class, 1);
- *     User u2 = Ebean.find(User.class, 2);
- *
- *     u1.setName("u1 mod");
- *     u2.setName("u2 mod");
- *
- *     Ebean.save(u1);
- *     Ebean.save(u2);
- *
- *     return u1.getEmail();
- *   }
- * });
- *
- * }</pre>
- *
- * @see TxRunnable
- */
-public interface TxCallable<T> {
-
-  /**
-   * Execute the method within a transaction scope returning the result.
-   * <p>
-   * If you do not want to return a result you should look to use TxRunnable
-   * instead.
-   * </p>
-   */
-  T call();
-}
@@ -1,40 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Execute a TxRunnable in a Transaction scope.
- * <p>
- * Use this with the {@link Ebean#execute(TxRunnable)} method.
- * </p>
- * <p>
- * See also {@link TxCallable}.
- * </p>
- * <p>
- * <pre>{@code
- *
- * // this run method runs in a transaction scope
- * // which by default is TxScope.REQUIRED
- *
- * Ebean.execute(new TxRunnable() {
- *   public void run() {
- *     User u1 = Ebean.find(User.class, 1);
- *     User u2 = Ebean.find(User.class, 2);
- *
- *     u1.setName("u1 mod");
- *     u2.setName("u2 mod");
- *
- *     Ebean.save(u1);
- *     Ebean.save(u2);
- *   }
- * });
- *
- * }</pre>
- *
- * @see TxCallable
- */
-public interface TxRunnable {
-
-  /**
-   * Run the method in a transaction sope.
-   */
-  void run();
-}
@@ -1,338 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.config.PersistBatch;
-
-import java.util.ArrayList;
-
-/**
- * Holds the definition of how a transactional method should run.
- * <p>
- * This information matches the features of the Transactional annotation. You
- * can use it directly with TxRunnable or TxCallable via
- * {@link Ebean#execute(TxScope, TxCallable)} or
- * {@link Ebean#execute(TxScope, TxRunnable)}.
- * </p>
- * <p>
- * This object is used internally with the enhancement of a method with
- * Transactional annotation.
- * </p>
- *
- * @see TxCallable
- * @see TxRunnable
- * @see Ebean#execute(TxScope, TxCallable)
- * @see Ebean#execute(TxScope, TxRunnable)
- */
-public final class TxScope {
-
-  TxType type;
-
-  String serverName;
-
-  TxIsolation isolation;
-
-  PersistBatch batch;
-
-  PersistBatch batchOnCascade;
-
-  int batchSize;
-
-  boolean skipGeneratedKeys;
-
-  boolean readOnly;
-
-  ArrayList<Class<? extends Throwable>> rollbackFor;
-
-  ArrayList<Class<? extends Throwable>> noRollbackFor;
-
-  /**
-   * Helper method to create a TxScope with REQUIRES.
-   */
-  public static TxScope required() {
-    return new TxScope(TxType.REQUIRED);
-  }
-
-  /**
-   * Helper method to create a TxScope with REQUIRES_NEW.
-   */
-  public static TxScope requiresNew() {
-    return new TxScope(TxType.REQUIRES_NEW);
-  }
-
-  /**
-   * Helper method to create a TxScope with MANDATORY.
-   */
-  public static TxScope mandatory() {
-    return new TxScope(TxType.MANDATORY);
-  }
-
-  /**
-   * Helper method to create a TxScope with SUPPORTS.
-   */
-  public static TxScope supports() {
-    return new TxScope(TxType.SUPPORTS);
-  }
-
-  /**
-   * Helper method to create a TxScope with NOT_SUPPORTED.
-   */
-  public static TxScope notSupported() {
-    return new TxScope(TxType.NOT_SUPPORTED);
-  }
-
-  /**
-   * Helper method to create a TxScope with NEVER.
-   */
-  public static TxScope never() {
-    return new TxScope(TxType.NEVER);
-  }
-
-  /**
-   * Create a REQUIRED transaction scope.
-   */
-  public TxScope() {
-    this.type = TxType.REQUIRED;
-  }
-
-  /**
-   * Create with a given transaction scope type.
-   */
-  public TxScope(TxType type) {
-    this.type = type;
-  }
-
-  /**
-   * Describes this TxScope instance.
-   */
-  public String toString() {
-    return "TxScope[" + type + "] readOnly[" + readOnly + "] isolation[" + isolation
-      + "] serverName[" + serverName + "] rollbackFor[" + rollbackFor + "] noRollbackFor[" + noRollbackFor + "]";
-  }
-
-  /**
-   * Return true if PersistBatch has been set.
-   */
-  public boolean isBatchSet() {
-    return batch != null && batch != PersistBatch.INHERIT;
-  }
-
-  /**
-   * Return true if batch on cascade has been set.
-   */
-  public boolean isBatchOnCascadeSet() {
-    return batchOnCascade != null && batchOnCascade != PersistBatch.INHERIT;
-  }
-
-  /**
-   * Return true if batch size has been set.
-   */
-  public boolean isBatchSizeSet() {
-    return batchSize > 0;
-  }
-
-  /**
-   * Check for batchSize being set without batch mode and use this to imply PersistBatch.ALL.
-   */
-  public void checkBatchMode() {
-    if (batchSize > 0 && notSet(batch) && notSet(batchOnCascade)) {
-      // Use setting the batchSize as implying PersistBatch.ALL for @Transactional
-      batch = PersistBatch.ALL;
-    }
-  }
-
-  /**
-   * Return true if the mode is considered not set.
-   */
-  private boolean notSet(PersistBatch batchMode) {
-    return batchMode == null || batchMode == PersistBatch.INHERIT;
-  }
-
-  /**
-   * Return the transaction type.
-   */
-  public TxType getType() {
-    return type;
-  }
-
-  /**
-   * Set the transaction type.
-   */
-  public TxScope setType(TxType type) {
-    this.type = type;
-    return this;
-  }
-
-  /**
-   * Return the batch mode.
-   */
-  public PersistBatch getBatch() {
-    return batch;
-  }
-
-  /**
-   * Set the batch mode to use.
-   */
-  public TxScope setBatch(PersistBatch batch) {
-    this.batch = batch;
-    return this;
-  }
-
-  /**
-   * Return the batch on cascade mode.
-   */
-  public PersistBatch getBatchOnCascade() {
-    return batchOnCascade;
-  }
-
-  /**
-   * Set the batch on cascade mode.
-   */
-  public TxScope setBatchOnCascade(PersistBatch batchOnCascade) {
-    this.batchOnCascade = batchOnCascade;
-    return this;
-  }
-
-  /**
-   * Return the batch size. 0 means use the default value.
-   */
-  public int getBatchSize() {
-    return batchSize;
-  }
-
-  /**
-   * Set the batch size to use.
-   */
-  public TxScope setBatchSize(int batchSize) {
-    this.batchSize = batchSize;
-    return this;
-  }
-
-  /**
-   * Set if the transaction should skip reading generated keys for inserts.
-   */
-  public TxScope setSkipGeneratedKeys() {
-    this.skipGeneratedKeys = true;
-    return this;
-  }
-
-  /**
-   * Return true if getGeneratedKeys should be skipped for this transaction.
-   */
-  public boolean isSkipGeneratedKeys() {
-    return skipGeneratedKeys;
-  }
-
-  /**
-   * Return if the transaction should be treated as read only.
-   */
-  public boolean isReadonly() {
-    return readOnly;
-  }
-
-  /**
-   * Set if the transaction should be treated as read only.
-   */
-  public TxScope setReadOnly(boolean readOnly) {
-    this.readOnly = readOnly;
-    return this;
-  }
-
-  /**
-   * Return the Isolation level this transaction should run with.
-   */
-  public TxIsolation getIsolation() {
-    return isolation;
-  }
-
-  /**
-   * Set the transaction isolation level this transaction should run with.
-   */
-  public TxScope setIsolation(TxIsolation isolation) {
-    this.isolation = isolation;
-    return this;
-  }
-
-  /**
-   * Return the serverName for this transaction. If this is null then the
-   * default server (default DataSource) will be used.
-   */
-  public String getServerName() {
-    return serverName;
-  }
-
-  /**
-   * Set the serverName (DataSource name) for which this transaction will be. If
-   * the serverName is not specified (left null) then the default server will be
-   * used.
-   */
-  public TxScope setServerName(String serverName) {
-    this.serverName = serverName;
-    return this;
-  }
-
-  /**
-   * Return the throwable's that should cause a rollback.
-   */
-  public ArrayList<Class<? extends Throwable>> getRollbackFor() {
-    return rollbackFor;
-  }
-
-  /**
-   * Set a Throwable that should explicitly cause a rollback.
-   */
-  public TxScope setRollbackFor(Class<? extends Throwable> rollbackThrowable) {
-    if (rollbackFor == null) {
-      rollbackFor = new ArrayList<>(2);
-    }
-    rollbackFor.add(rollbackThrowable);
-    return this;
-  }
-
-  /**
-   * Set multiple throwable's that will cause a rollback.
-   */
-  @SuppressWarnings("unchecked")
-  public TxScope setRollbackFor(Class<?>[] rollbackThrowables) {
-    if (rollbackFor == null) {
-      rollbackFor = new ArrayList<>(rollbackThrowables.length);
-    }
-    for (Class<?> rollbackThrowable : rollbackThrowables) {
-      rollbackFor.add((Class<? extends Throwable>) rollbackThrowable);
-    }
-    return this;
-  }
-
-  /**
-   * Return the throwable's that should NOT cause a rollback.
-   */
-  public ArrayList<Class<? extends Throwable>> getNoRollbackFor() {
-    return noRollbackFor;
-  }
-
-  /**
-   * Add a Throwable to a list that will NOT cause a rollback. You are able to
-   * call this method multiple times with different throwable's and they will
-   * added to a list.
-   */
-  public TxScope setNoRollbackFor(Class<? extends Throwable> noRollback) {
-    if (noRollbackFor == null) {
-      noRollbackFor = new ArrayList<>(2);
-    }
-    this.noRollbackFor.add(noRollback);
-    return this;
-  }
-
-  /**
-   * Set multiple throwable's that will NOT cause a rollback.
-   */
-  @SuppressWarnings("unchecked")
-  public TxScope setNoRollbackFor(Class<?>[] noRollbacks) {
-    if (noRollbackFor == null) {
-      noRollbackFor = new ArrayList<>(noRollbacks.length);
-    }
-    for (Class<?> noRollback : noRollbacks) {
-      noRollbackFor.add((Class<? extends Throwable>) noRollback);
-    }
-    return this;
-  }
-
-}
@@ -1,119 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import com.avaje.ebean.Query;
-import com.avaje.ebean.config.Platform;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Repeatable;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Assign to a property to be based on a SQL formula.
- * <p>
- * This is typically a SQL Literal value, SQL case statement, SQL function or
- * similar.
- * </p>
- * <p>
- * Any property based on a formula becomes a read only property.
- * </p>
- * <p>
- * You may also put use the Transient annotation with the Formula annotation.
- * The effect of the Transient annotation in this case is that the formula will
- * <b>NOT</b> be included in queries by default - you have to explicitly include
- * it via {@link Query#select(String)} or {@link Query#fetch(String, String, com.avaje.ebean.FetchConfig)}.
- * You may want to do this if the Formula is relatively expensive and only want
- * it included in the query when you explicitly state it.
- * </p>
- * <p>
- * <pre>{@code
- * // On the Order "master" bean
- * // ... a formula using the Order details
- * // ... sum(order_qty*unit_price)
- * @Transient
- * @Formula(select = "_b${ta}.total_amount", join = "join (select order_id, sum(order_qty*unit_price) as total_amount from o_order_detail group by order_id) as _b${ta} on _b${ta}.order_id = ${ta}.id")
- * Double totalAmount;
- *
- * }</pre>
- * <p>
- * As the totalAmount formula is also Transient it is not included by default in
- * queries - it needs to be explicitly included.
- * </p>
- * <pre>{@code
- *
- * // find by Id
- * Order o1 = Ebean.find(Order.class)
- *     .select("id, totalAmount")
- *     .setId(1).findUnique();
- *
- * // find list ... using totalAmount in the where clause
- * List<Order> list = Ebean.find(Order.class)
- *     .select("id, totalAmount")
- *     .where()
- *     .eq("status", Order.Status.NEW)
- *     .gt("totalAmount", 10)
- *     .findList();
- *
- * // as a join from customer
- * List<Customer> l0 = Ebean.find(Customer.class)
- *     .select("id, name")
- *     .fetch("orders", "status, totalAmount")
- *     .where()
- *     .gt("id", 0)
- *     .gt("orders.totalAmount", 10)
- *     .findList();
- *
- * }</pre>
- */
-@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@Repeatable(Formula.List.class)
-public @interface Formula {
-
-  /**
-   * The SQL to be used in the SELECT part of the SQL to populate a property.
-   */
-  String select();
-
-  /**
-   * OPTIONAL - the SQL to be used in the JOIN part of the SQL to support the
-   * formula.
-   * <p>
-   * This is commonly used to join a 'dynamic view' to support aggregation such
-   * as count, sum etc.
-   * </p>
-   * <p>
-   * The join string should start with either "left join" or "join".
-   * </p>
-   * <p>
-   * You will almost certainly use the "${ta}" as a place holder for the table
-   * alias of the table you are joining back to (the "base table" of the entity
-   * bean).
-   * </p>
-   * <p>
-   * The example below is used to support a total count of topics created by a
-   * user.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   * join (select user_id, count(*) as topic_count from f_topic group by user_id) as _tc on _tc.user_id = ${ta}.id
-   *
-   * }</pre>
-   */
-  String join() default "";
-
-  Platform[] platforms() default {};
-
-  /**
-   * Repeatable support for {@link Formula}.
-   */
-  @Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
-  @Retention(RetentionPolicy.RUNTIME)
-  @interface List {
-
-    Formula[] value() default {};
-  }
-
-}
@@ -1,138 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import com.avaje.ebean.TxIsolation;
-import com.avaje.ebean.TxType;
-import com.avaje.ebean.config.PersistBatch;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify transaction scoping for a method.
- * <p>
- * <b><i> This is only supported if "Enhancement" is used via javaagent, ANT
- * task or IDE enhancement plugin etc. </i></b>
- * </p>
- * <p>
- * Note: Currently there are 3 known annotations that perform this role.
- * <ul>
- * <li>EJB's javax.ejb.TransactionAttribute</li>
- * <li>Spring's org.springframework.transaction.annotation.Transactional</li>
- * <li>and this one, Ebean's own com.avaje.ebean.annotation.Transactional</li>
- * </ul>
- * Spring created their one because the EJB annotation does not support features
- * such as isolation level and specifying rollbackOn, noRollbackOn exceptions.
- * This one exists for Ebean because I agree that the standard one is
- * insufficient and don't want to include a dependency on Spring.
- * </p>
- * <p>
- * The default behaviour of EJB (and hence Spring) is to NOT ROLLBACK on checked
- * exceptions. I find this very counter-intuitive. Ebean will provide a property
- * to set the default behaviour to rollback on any exception and optionally
- * change the setting to be consistent with EJB/Spring if people wish to do so.
- * </p>
- * <p>
- * <pre>{@code
- *
- *  // a normal class
- *  public class MySimpleUserService {
- *
- *    // this method is transactional automatically handling
- *    // transaction begin, commit and rollback etc
- *    @Transactional
- *    public void runInTrans() throws IOException {
- *
- *      // tasks performed within the transaction
- *      ...
- *      // find some objects
- *      Customer cust = ebeanServer.find(Customer.class, 42);
- *
- *      Order order = ...;
- *      ...
- *      // save some objects
- *      ebeanServer.save(customer);
- *      ebeanServer.save(order);
- *    }
- *
- * }</pre>
- */
-@Target({ElementType.METHOD, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Transactional {
-
-  /**
-   * The type of transaction scoping. Defaults to REQUIRED.
-   */
-  TxType type() default TxType.REQUIRED;
-
-  /**
-   * Persist batch mode for the transaction.
-   */
-  PersistBatch batch() default PersistBatch.INHERIT;
-
-  /**
-   * Persist batch mode for the request if not set on the transaction.
-   * <p>
-   * If batch is set to NONE then batchOnCascade can be set to INSERT or ALL
-   * and then each save(), delete(), insert(), update() request that cascades
-   * to child beans can use JDBC batch.
-   * </p>
-   */
-  PersistBatch batchOnCascade() default PersistBatch.INHERIT;
-
-  /**
-   * The batch size to use when using JDBC batch mode.
-   * <p>
-   * If unset this defaults to the value set in ServerConfig.
-   * </p>
-   */
-  int batchSize() default 0;
-
-  /**
-   * Set to false when we want to skip getting generatedKeys.
-   * <p>
-   * This is typically used in the case of large batch inserts where we get a
-   * performance benefit from not calling getGeneratedKeys (as we are going to
-   * insert a lot of rows and have no need for the Id values after the insert).
-   * </p>
-   */
-  boolean getGeneratedKeys() default true;
-
-  /**
-   * The transaction isolation level this transaction should have.
-   * <p>
-   * This will only be used if this scope creates the transaction. If the
-   * transaction has already started then this will currently be ignored (you
-   * could argue that it should throw an exception).
-   * </p>
-   */
-  TxIsolation isolation() default TxIsolation.DEFAULT;
-
-  /**
-   * Set this to true if the transaction should be only contain queries.
-   */
-  boolean readOnly() default false;
-
-  /**
-   * The name of the server that you want the transaction to be created from.
-   * <p>
-   * If left blank the 'default' server is used.
-   * </p>
-   */
-  String serverName() default "";
-
-  // int timeout() default 0;
-
-  /**
-   * The Throwable's that will explicitly cause a rollback to occur.
-   */
-  Class<? extends Throwable>[] rollbackFor() default {};
-
-  /**
-   * The Throwable's that will explicitly NOT cause a rollback to occur.
-   */
-  Class<? extends Throwable>[] noRollbackFor() default {};
-
-}
@@ -1,68 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import com.avaje.ebean.config.Platform;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Repeatable;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Add an Literal to add to the where clause when a many property (List, Set or
- * Map) is loaded or refreshed.
- * <pre>{@code
- *
- * // on a OneToMany property...
- *
- * @OneToMany
- * @Where(clause = "deleted='y'")
- * List<Topic> topics;
- *
- * }</pre>
- * <p>
- * Note that you can include "${ta}" as a place holder for the table alias if
- * you need to include the table alias in the clause.
- * </p>
- * <pre>{@code
- * // ... including the ${ta} table alias placeholder...
- *
- * @OneToMany
- * @Where(clause = "${ta}.deleted='y'")
- * List<Topic> topics;
- *
- * }</pre>
- * <p>
- * This will be added to the where clause when lazy loading the OneToMany
- * property or when there is a join to that OneToMany property.
- * </p>
- */
-@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@Repeatable(Where.List.class)
-public @interface Where {
-
-  /**
-   * The clause added to the lazy load query.
-   * <p>
-   * Note that you can include "${ta}" as a place holder for the table alias if
-   * you need to include the table alias in the clause.
-   * </p>
-   */
-  String clause();
-
-  /**
-   * The platform where this annotation is active. Default: any platform
-   */
-  Platform[] platforms() default {};
-
-  /**
-   * Repeatable support for {@link Where}.
-   */
-  @Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
-  @Retention(RetentionPolicy.RUNTIME)
-  @interface List {
-
-    Where[] value() default {};
-  }
-}
@@ -1,13 +0,0 @@
-package com.avaje.ebean.bean;
-
-/**
- * A callback that can be registered to fire on getter method calls.
- * It's primary purpose is to automatically flush JDBC batch buffer.
- */
-public interface PreGetterCallback {
-
-  /**
-   * Trigger the callback.
-   */
-  void preGetterTrigger();
-}
@@ -1,52 +0,0 @@
-package com.avaje.ebean.cache;
-
-/**
- * Represents part of the "L2" server side cache.
- * <p>
- * This is used to cache beans or query results (bean collections).
- * </p>
- * <p>
- * There are 2 ServerCache's for each bean type. One is used as the 'bean cache'
- * which holds beans of a given type. The other is the 'query cache' holding
- * query results for a given type.
- * </p>
- */
-public interface ServerCache {
-
-  /**
-   * Return the value given the key.
-   */
-  Object get(Object id);
-
-  /**
-   * Put the value in the cache with a given id.
-   */
-  Object put(Object id, Object value);
-
-  /**
-   * Remove a entry from the cache given its id.
-   */
-  Object remove(Object id);
-
-  /**
-   * Clear all entries from the cache.
-   */
-  void clear();
-
-  /**
-   * Return the number of entries in the cache.
-   */
-  int size();
-
-  /**
-   * Return the hit ratio the cache is currently getting.
-   */
-  int getHitRatio();
-
-  /**
-   * Return statistics for the cache.
-   *
-   * @param reset if true the statistics are reset.
-   */
-  ServerCacheStatistics getStatistics(boolean reset);
-}
@@ -1,13 +0,0 @@
-package com.avaje.ebean.cache;
-
-/**
- * Defines method for constructing caches for beans and queries.
- */
-public interface ServerCacheFactory {
-
-  /**
-   * Create the cache for the given type with options.
-   */
-  ServerCache createCache(ServerCacheType type, String cacheKey, ServerCacheOptions cacheOptions);
-
-}
@@ -1,47 +0,0 @@
-package com.avaje.ebean.cache;
-
-/**
- * The cache service for server side caching of beans and query results.
- */
-public interface ServerCacheManager {
-
-  /**
-   * Return true if the L2 caching is local.
-   * <p>
-   * Local L2 caching means that the cache updates should occur in foreground
-   * rather than background processing.
-   * </p>
-   */
-  boolean isLocalL2Caching();
-
-  /**
-   * Return the cache for mapping natural keys to id values.
-   */
-  ServerCache getNaturalKeyCache(Class<?> beanType);
-
-  /**
-   * Return the cache for beans of a particular type.
-   */
-  ServerCache getBeanCache(Class<?> beanType);
-
-  /**
-   * Return the cache for associated many properties of a bean type.
-   */
-  ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName);
-
-  /**
-   * Return the cache for query results of a particular type of bean.
-   */
-  ServerCache getQueryCache(Class<?> beanType);
-
-  /**
-   * This clears both the bean and query cache for a given type.
-   */
-  void clear(Class<?> beanType);
-
-  /**
-   * Clear all the caches.
-   */
-  void clearAll();
-
-}
@@ -1,15 +0,0 @@
-package com.avaje.ebean.cache;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.config.ServerConfig;
-
-/**
- * The plugin interface that creates a ServerCacheFactory.
- */
-public interface ServerCachePlugin {
-
-  /**
-   * Create the ServerCacheFactory given the server config and background executor service.
-   */
-  ServerCacheFactory create(ServerConfig config, BackgroundExecutor executor);
-}
@@ -1,81 +0,0 @@
-package com.avaje.ebean.common;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.Set;
-
-/**
- * Holds sets of additions and deletions from a 'owner' List Set or Map.
- * <p>
- * These sets of additions and deletions are used to support persisting
- * ManyToMany relationships. The additions becoming inserts into the
- * intersection table and the removals becoming deletes from the intersection
- * table.
- * </p>
- */
-class ModifyHolder<E> implements Serializable {
-
-  private static final long serialVersionUID = 2572572897923801083L;
-
-  /**
-   * Deletions list for manyToMany persistence.
-   */
-  private Set<E> modifyDeletions = new LinkedHashSet<>();
-
-  /**
-   * Additions list for manyToMany persistence.
-   */
-  private Set<E> modifyAdditions = new LinkedHashSet<>();
-
-  void reset() {
-    modifyDeletions = new LinkedHashSet<>();
-    modifyAdditions = new LinkedHashSet<>();
-  }
-
-  /**
-   * Used by BeanList.addAll() methods.
-   */
-  void modifyAdditionAll(Collection<? extends E> c) {
-    if (c != null) {
-      for (E e : c) {
-        modifyAddition(e);
-      }
-    }
-  }
-
-  void modifyAddition(E bean) {
-    if (bean != null) {
-      // If it is to delete then just remove the deletion
-      if (!modifyDeletions.remove(bean)) {
-        // Insert
-        modifyAdditions.add(bean);
-      }
-    }
-  }
-
-  @SuppressWarnings("unchecked")
-  void modifyRemoval(Object bean) {
-    if (bean != null) {
-      // If it is to be added then just remove the addition
-      if (!modifyAdditions.remove(bean)) {
-        modifyDeletions.add((E) bean);
-      }
-    }
-  }
-
-  Set<E> getModifyAdditions() {
-    return modifyAdditions;
-  }
-
-  Set<E> getModifyRemovals() {
-    return modifyDeletions;
-  }
-
-  /**
-   * Return true if there additions or removals.
-   */
-  boolean hasModifications() {
-    return !modifyDeletions.isEmpty() || !modifyAdditions.isEmpty();
-  }
-}
@@ -1,42 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * API from creating and getting property values from an Immutable Compound
- * Value Object.
- * <p>
- * A Compound Value object should contain multiple properties that are stored
- * separately. If you only have a single scalar value you should instead look to
- * use {@link ScalarTypeConverter}.
- * </p>
- * <p>
- * For each property in the compound type you need to implement the
- * {@link CompoundTypeProperty} interface. These must be returned from
- * {@link #getProperties()} in the same order that the properties appear in the
- * constructor.
- * </p>
- * <p>
- * If your compound type is mutable then you should look to use the JPA Embedded
- * annotation instead of implementing this interface.
- * </p>
- * <p>
- * When using classpath search Ebean will detect and automatically register any
- * implementations of this interface (along with detecting the entity classes
- * etc).
- * </p>
- *
- * @param <V> The type of the Value Object
- * @author rbygrave
- * @see ScalarTypeConverter
- */
-public interface CompoundType<V> {
-
-  /**
-   * Create an instance of the compound type given its property values.
-   */
-  V create(Object[] propertyValues);
-
-  /**
-   * Return the properties in the order they appear in the constructor.
-   */
-  CompoundTypeProperty<V, ?>[] getProperties();
-}
@@ -1,45 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Represents a Property of a Compound Value Object.
- * <p>
- * For each property in a {@link CompoundType} you need an implementation of
- * this CompoundTypeProperty interface.
- * </p>
- *
- * @param <V> The type of the Compound value object
- * @param <P> The type of the property
- * @author rbygrave
- * @see CompoundType
- * @see ScalarTypeConverter
- */
-public interface CompoundTypeProperty<V, P> {
-
-  /**
-   * The name of this property.
-   */
-  String getName();
-
-  /**
-   * Return the property value from the containing compound value object.
-   *
-   * @param valueObject the compound value object
-   * @return the property value.
-   */
-  P getValue(V valueObject);
-
-  /**
-   * This should <b>ONLY</b> be used when the persistence type is different from
-   * the logical type returned. It most cases just return 0 and Ebean will
-   * persist the logical type.
-   * <p>
-   * Typically this should be used when the logical type is long but the
-   * persistence type is java.sql.Timestamp. In this case return
-   * java.sql.Types.TIMESTAMP (rather than 0).
-   * </p>
-   *
-   * @return Return the java.sql.Type that you want to use to persist this
-   * property or 0 and Ebean will use the logical type.
-   */
-  int getDbType();
-}
@@ -1,60 +0,0 @@
-package com.avaje.ebean.config;
-
-import java.util.Properties;
-
-/**
- * Configuration for the container that holds the EbeanServer 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.
- */
-public class ContainerConfig {
-
-  protected boolean clusterActive;
-
-  protected Properties properties;
-
-  /**
-   * Return true if clustering is active.
-   */
-  public boolean isClusterActive() {
-    return clusterActive;
-  }
-
-  /**
-   * Set to true for clustering to be active.
-   */
-  public void setClusterActive(boolean clusterActive) {
-    this.clusterActive = clusterActive;
-  }
-
-  /**
-   * Return the deployment properties.
-   */
-  public Properties getProperties() {
-    return properties;
-  }
-
-  /**
-   * Set the deployment properties.
-   */
-  public void setProperties(Properties properties) {
-    this.properties = properties;
-  }
-
-  /**
-   * Load the settings from properties.
-   */
-  public void loadFromProperties(Properties properties) {
-    this.properties = properties;
-    this.clusterActive = getProperty(properties, "ebean.cluster.active", clusterActive);
-  }
-
-  /**
-   * Return the boolean property setting.
-   */
-  protected boolean getProperty(Properties properties, String key, boolean defaultValue) {
-    return "true".equalsIgnoreCase(properties.getProperty(key, Boolean.toString(defaultValue)));
-  }
-
-}
@@ -1,12 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Provides the Tenant Id for the current request based on the current user.
- */
-public interface CurrentTenantProvider {
-
-  /**
-   * Return the Tenant Id for the current user.
-   */
-  String currentId();
-}
@@ -1,501 +0,0 @@
-package com.avaje.ebean.config;
-
-import com.avaje.ebean.EbeanServer;
-import com.avaje.ebean.dbmigration.DbMigration;
-import org.avaje.dbmigration.MigrationConfig;
-import org.avaje.dbmigration.MigrationRunner;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.Map;
-
-/**
- * Configuration for the DB migration processing.
- */
-public class DbMigrationConfig {
-
-  protected static final Logger logger = LoggerFactory.getLogger(DbMigrationConfig.class);
-
-  /**
-   * The database platform to generate migration DDL for.
-   */
-  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";
-
-  /**
-   * Subdirectory the model xml files go into.
-   */
-  protected String modelPath = "model";
-
-  protected String applySuffix = ".sql";
-
-  /**
-   * Set this to "V" to be compatible with FlywayDB.
-   */
-  protected String applyPrefix = "";
-
-  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.
-   */
-  protected String metaTable = "db_migration";
-
-  /**
-   * Flag set to true means to run any outstanding migrations on startup.
-   */
-  protected boolean runMigration;
-
-  /**
-   * Comma and equals delimited key/value placeholders to replace in DDL scripts.
-   */
-  protected String runPlaceholders;
-
-  /**
-   * Map of key/value placeholders to replace in DDL scripts.
-   */
-  protected Map<String, String> runPlaceholderMap;
-
-  /**
-   * DB user used to run the DB migration.
-   */
-  protected String dbUsername;
-
-  /**
-   * DB password used to run the DB migration.
-   */
-  protected String dbPassword;
-
-  /**
-   * Return the DB platform to generate migration DDL for.
-   * <p>
-   * We typically need to explicitly specify this as migration can often be generated
-   * when running against H2.
-   */
-  public Platform getPlatform() {
-    return platform;
-  }
-
-  /**
-   * Set the DB platform to generate migration DDL for.
-   */
-  public void setPlatform(Platform platform) {
-    this.platform = platform;
-  }
-
-  /**
-   * Return the resource path for db migrations.
-   */
-  public String getMigrationPath() {
-    return migrationPath;
-  }
-
-  /**
-   * Set the resource path for db migrations.
-   * <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.
-   * </p>
-   */
-  public void setMigrationPath(String migrationPath) {
-    this.migrationPath = migrationPath;
-  }
-
-  /**
-   * Return the relative path for the model files (defaults to model).
-   */
-  public String getModelPath() {
-    return modelPath;
-  }
-
-  /**
-   * Set the relative path for the model files.
-   */
-  public void setModelPath(String modelPath) {
-    this.modelPath = modelPath;
-  }
-
-  /**
-   * Return the model suffix (defaults to model.xml)
-   */
-  public String getModelSuffix() {
-    return modelSuffix;
-  }
-
-  /**
-   * Set the model suffix.
-   */
-  public void setModelSuffix(String modelSuffix) {
-    this.modelSuffix = modelSuffix;
-  }
-
-  /**
-   * Return the apply script suffix (defaults to sql).
-   */
-  public String getApplySuffix() {
-    return applySuffix;
-  }
-
-  /**
-   * Set the apply script suffix (defaults to sql).
-   */
-  public void setApplySuffix(String applySuffix) {
-    this.applySuffix = applySuffix;
-  }
-
-  /**
-   * Return the apply prefix.
-   */
-  public String getApplyPrefix() {
-    return applyPrefix;
-  }
-
-  /**
-   * Set the apply prefix. This might be set to "V" for use with FlywayDB.
-   */
-  public void setApplyPrefix(String applyPrefix) {
-    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).
-   */
-  public String getMetaTable() {
-    return metaTable;
-  }
-
-  /**
-   * Set the table name that holds the migration run details
-   * (used by DB Migration runner only).
-   */
-  public void setMetaTable(String metaTable) {
-    this.metaTable = metaTable;
-  }
-
-  /**
-   * Return a comma and equals delimited placeholders that are substituted in SQL scripts when running migration
-   * (used by DB Migration runner only).
-   */
-  public String getRunPlaceholders() {
-    // environment properties take precedence
-    String placeholders = readEnvironment("ddl.migration.placeholders");
-    if (placeholders != null) {
-      return placeholders;
-    }
-    return runPlaceholders;
-  }
-
-  /**
-   * Set a comma and equals delimited placeholders that are substituted in SQL scripts when running migration
-   * (used by DB Migration runner only).
-   */
-  public void setRunPlaceholders(String runPlaceholders) {
-    this.runPlaceholders = runPlaceholders;
-  }
-
-  /**
-   * Return a map of placeholder values that are substituted in SQL scripts when running migration
-   * (used by DB Migration runner only).
-   */
-  public Map<String, String> getRunPlaceholderMap() {
-    return runPlaceholderMap;
-  }
-
-  /**
-   * Set a map of placeholder values that are substituted when running migration
-   * (used by DB Migration runner only).
-   */
-  public void setRunPlaceholderMap(Map<String, String> runPlaceholderMap) {
-    this.runPlaceholderMap = runPlaceholderMap;
-  }
-
-  /**
-   * Return true if the DB migration should be run on startup.
-   */
-  public boolean isRunMigration() {
-    // environment properties take precedence
-    String run = readEnvironment("ddl.migration.run");
-    if (run != null) {
-      return "true".equalsIgnoreCase(run.trim());
-    }
-    return runMigration;
-  }
-
-  /**
-   * Set to true to run the DB migration on startup.
-   */
-  public void setRunMigration(boolean runMigration) {
-    this.runMigration = runMigration;
-  }
-
-  /**
-   * Return the DB username to use for running DB migrations.
-   */
-  public String getDbUsername() {
-    // environment properties take precedence
-    String user = readEnvironment("ddl.migration.user");
-    if (user != null) {
-      return user;
-    }
-    return dbUsername;
-  }
-
-  /**
-   * Set the DB username to use for running DB migrations.
-   */
-  public void setDbUsername(String dbUsername) {
-    this.dbUsername = dbUsername;
-  }
-
-  /**
-   * Return the DB password to use for running DB migrations.
-   */
-  public String getDbPassword() {
-    String user = readEnvironment("ddl.migration.password");
-    if (user != null) {
-      return user;
-    }
-    return dbPassword;
-  }
-
-  /**
-   * Set the DB password to use for running DB migrations.
-   */
-  public void setDbPassword(String dbPassword) {
-    this.dbPassword = dbPassword;
-  }
-
-  /**
-   * Load the settings from the PropertiesWrapper.
-   */
-  public void loadSettings(PropertiesWrapper properties, String serverName) {
-
-    migrationPath = properties.get("migration.migrationPath", migrationPath);
-    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);
-
-    runMigration = properties.getBoolean("migration.run", runMigration);
-    metaTable = properties.get("migration.metaTable", metaTable);
-    runPlaceholders = properties.get("migration.placeholders", runPlaceholders);
-
-    String adminUser = properties.get("datasource." + serverName + ".username", dbUsername);
-    adminUser = properties.get("datasource." + serverName + ".adminusername", adminUser);
-    dbUsername = properties.get("migration.dbusername", adminUser);
-
-    String adminPwd = properties.get("datasource." + serverName + ".password", dbPassword);
-    adminPwd = properties.get("datasource." + serverName + ".adminpassword", adminPwd);
-    dbPassword = properties.get("migration.dbpassword", adminPwd);
-  }
-
-  /**
-   * Return true if the migration should be generated.
-   * <p>
-   * It is expected that when an environment variable <code>ddl.migration.enabled</code>
-   * is set to <code>true</code> then the DB migration will generate the migration DDL.
-   * </p>
-   */
-  public boolean isGenerateOnStart() {
-
-    // environment properties take precedence
-    String envGenerate = readEnvironment("ddl.migration.generate");
-    if (envGenerate != null) {
-      return "true".equalsIgnoreCase(envGenerate.trim());
-    }
-    return generate;
-  }
-
-  /**
-   * Called by EbeanServer on start.
-   * <p>
-   * If enabled this generates the migration xml and DDL scripts.
-   * </p>
-   */
-  public void generateOnStart(EbeanServer server) {
-
-    if (isGenerateOnStart()) {
-      if (platform == null) {
-        logger.warn("No platform set for migration DDL generation");
-      } else {
-        // generate the migration xml and platform specific DDL
-        DbMigration migration = new DbMigration(server);
-        migration.setPlatform(platform);
-        try {
-          migration.generateMigration();
-        } catch (Exception e) {
-          throw new RuntimeException("Error generating DB migration", e);
-        }
-      }
-    }
-  }
-
-  /**
-   * 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;
-  }
-
-  /**
-   * Return the system or environment property.
-   */
-  protected String readEnvironment(String key) {
-
-    String val = System.getProperty(key);
-    if (val == null) {
-      val = System.getenv(key);
-    }
-    return val;
-  }
-
-  /**
-   * Return true if the string is null or empty.
-   */
-  protected boolean isEmpty(String val) {
-    return val == null || val.trim().isEmpty();
-  }
-
-  /**
-   * Create the MigrationRunner to run migrations if necessary.
-   */
-  public MigrationRunner createRunner(ClassLoader classLoader) {
-
-    MigrationConfig runnerConfig = new MigrationConfig();
-    runnerConfig.setMetaTable(metaTable);
-    runnerConfig.setApplySuffix(applySuffix);
-    runnerConfig.setMigrationPath(migrationPath);
-    runnerConfig.setRunPlaceholderMap(runPlaceholderMap);
-    runnerConfig.setRunPlaceholders(runPlaceholders);
-    runnerConfig.setDbUsername(getDbUsername());
-    runnerConfig.setDbPassword(getDbPassword());
-    runnerConfig.setClassLoader(classLoader);
-    return new MigrationRunner(runnerConfig);
-  }
-}
@@ -1,123 +0,0 @@
-package com.avaje.ebean.config;
-
-import com.avaje.ebean.config.dbplatform.DbType;
-import com.avaje.ebean.config.dbplatform.IdType;
-
-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;
-  }
-}
@@ -1,44 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * The JPA naming convention where column names match property names and table
- * names match entity names.
- * <p>
- * The JPA specification states that the in the case of no annotations the name
- * of the class will be take as the table name and the name of a property will
- * be taken as the name of the column.
- * </p>
- *
- * @author emcgreal
- */
-public class MatchingNamingConvention extends AbstractNamingConvention {
-
-  /**
-   * Create with a sequence format of "{table}_seq".
-   */
-  public MatchingNamingConvention() {
-    super();
-  }
-
-  /**
-   * Instantiates with a specific format for DB sequences.
-   *
-   * @param sequenceFormat the sequence format
-   */
-  public MatchingNamingConvention(String sequenceFormat) {
-    super(sequenceFormat);
-  }
-
-  public String getColumnFromProperty(Class<?> beanClass, String propertyName) {
-    return propertyName;
-  }
-
-  public TableName getTableNameByConvention(Class<?> beanClass) {
-
-    return new TableName(getCatalog(), getSchema(), beanClass.getSimpleName());
-  }
-
-  public String getPropertyFromColumn(Class<?> beanClass, String dbColumnName) {
-    return dbColumnName;
-  }
-}
@@ -1,148 +0,0 @@
-package com.avaje.ebean.config;
-
-import java.util.Properties;
-
-public class PropertiesWrapper {
-
-  protected final Properties properties;
-
-  protected final String prefix;
-
-  protected final String serverName;
-
-  protected final PropertyMap propertyMap;
-
-  /**
-   * Construct with a prefix, serverName and properties.
-   */
-  public PropertiesWrapper(String prefix, String serverName, Properties properties) {
-    this.serverName = serverName;
-    this.prefix = prefix;
-    this.propertyMap = PropertyMapLoader.load(null, properties);
-    this.properties = propertyMap.asProperties();
-  }
-
-  /**
-   * 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);
-  }
-
-  /**
-   * Return the serverName (optional).
-   */
-  public String getServerName() {
-    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.
-   */
-  public String get(String key) {
-    return get(key, null);
-  }
-
-  /**
-   * Get a property with a default value.
-   * <p>
-   * This performs a search using the prefix and server name (if supplied) to search for the property
-   * value in order based on:
-   * <pre>{@code
-   *   prefix.serverName.key
-   *   prefix.key
-   *   key
-   * }</pre>
-   * </p>
-   */
-  public String get(String key, String defaultValue) {
-
-    String value = null;
-    if (serverName != null && prefix != null) {
-      value = propertyMap.get(prefix + "." + serverName + "." + key, null);
-    }
-    if (value == null && prefix != null) {
-      value = propertyMap.get(prefix + "." + key, null);
-    }
-    if (value == null) {
-      value = propertyMap.get(key, null);
-    }
-    return value == null ? defaultValue : value;
-  }
-
-  /**
-   * Return a double property value.
-   */
-  public double getDouble(String key, double defaultValue) {
-
-    String value = get(key, String.valueOf(defaultValue));
-    return Double.parseDouble(value);
-  }
-
-  /**
-   * Return an int property value.
-   */
-  public int getInt(String key, int defaultValue) {
-
-    String value = get(key, String.valueOf(defaultValue));
-    return Integer.parseInt(value);
-  }
-
-  /**
-   * Return a long property value.
-   */
-  public long getLong(String key, long defaultValue) {
-
-    String value = get(key, String.valueOf(defaultValue));
-    return Long.parseLong(value);
-  }
-
-  /**
-   * Return a boolean property value.
-   */
-  public boolean getBoolean(String key, boolean defaultValue) {
-
-    String value = get(key, String.valueOf(defaultValue));
-    return Boolean.parseBoolean(value);
-  }
-
-  /**
-   * Return a Enum property value.
-   */
-  public <T extends Enum<T>> T getEnum(Class<T> enumType, String key, T defaultValue) {
-    String level = get(key, null);
-    return (level == null) ? defaultValue : Enum.valueOf(enumType, level.toUpperCase());
-  }
-
-}
@@ -1,178 +0,0 @@
-package com.avaje.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,167 +0,0 @@
-package com.avaje.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"));
-  }
-
-  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,159 +0,0 @@
-package com.avaje.ebean.config;
-
-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);
-
-  /**
-   * 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 = otherProps.replace("\\", "/");
-      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(fileName + " found in file system");
-        return new FileInputStream(f);
-      } else {
-        InputStream in = findInClassPath(fileName);
-        if (in != null) {
-          logger.debug(fileName + " found in classpath");
-        }
-        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);
-  }
-
-}
@@ -1,68 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Used to convert between a value object and a known scalar type. The value
- * object is the logical type used in your application and the scalar type is
- * the value used to persist than to the DB.
- * <p>
- * The Value object should be immutable and scalar (aka not compound) and
- * converts to and from a known scalar type which Ebean will use to persist the
- * value.
- * </p>
- * <p>
- * This is an easier alternative to implementing the
- * com.avaje.ebean.server.type.ScalarType interface.
- * </p>
- * <p>
- * Note that Ebean will automatically try to detect Immutable Scalar Value
- * Objects and automatically support them via reflection. This however would not
- * be appropriate when the logical type is different from the type you wish to
- * use for persistence - for example, if the logical type was long and you
- * wanted to use java.sql.Timestamp for persistence. In this case you would want
- * to implement this interface rather than let Ebean automatically support that
- * type via reflection.
- * </p>
- * <p>
- * If you want to support a Compound Type rather than a Scalar Type refer to
- * {@link CompoundType}.
- * </p>
- *
- * @param <B> The value object type.
- * @param <S> The scalar object type that is used to persist the value object.
- * @author rbygrave
- * @see CompoundType
- * @see CompoundTypeProperty
- */
-public interface ScalarTypeConverter<B, S> {
-
-  /**
-   * Return the value to represent null. Typically this is actually null but for
-   * scala.Option and similar type converters this actually returns an instance
-   * representing "None".
-   */
-  B getNullValue();
-
-  /**
-   * Convert the scalar type value into the value object.
-   * <p>
-   * This typically occurs when Ebean reads the value from a resultSet or other
-   * data source.
-   * </p>
-   *
-   * @param scalarType the value from the data source
-   */
-  B wrapValue(S scalarType);
-
-  /**
-   * Convert the value object into a scalar value that Ebean knows how to
-   * persist.
-   * <p>
-   * This typically occurs when Ebean is persisting the value object to the data
-   * store.
-   * </p>
-   *
-   * @param beanType the value object
-   */
-  S unwrapValue(B beanType);
-
-}
@@ -1,19 +0,0 @@
-package com.avaje.ebean.config;
-
-import javax.sql.DataSource;
-
-/**
- * For multi-tenancy via DB supply the DataSource given the tenantId.
- */
-public interface TenantDataSourceProvider {
-
-  /**
-   * Return the DataSource to use for the given current tenant.
-   */
-  DataSource dataSource(String tenantId);
-
-  /**
-   * Shutdown all the DataSources.
-   */
-  void shutdown(boolean deregisterDriver);
-}
@@ -1,40 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * The mode to use for multi-tenancy.
- */
-public enum TenantMode {
-
-  /**
-   * No multi-tenancy.
-   */
-  NONE(false),
-
-  /**
-   * Each Tenant has their own Database (javax.sql.DataSource)
-   */
-  DB(true),
-
-  /**
-   * Each Tenant has their own Database schema.
-   */
-  SCHEMA(true),
-
-  /**
-   * Tenants share tables but have a discriminator/partition column that partitions the data.
-   */
-  PARTITION(false);
-
-  boolean dynamicDataSource;
-
-  TenantMode(boolean dynamicDataSource) {
-    this.dynamicDataSource = dynamicDataSource;
-  }
-
-  /**
-   * Return true if the DataSource is not available on bootup.
-   */
-  public boolean isDynamicDataSource() {
-    return dynamicDataSource;
-  }
-}
@@ -1,42 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.DB2Ddl;
-
-import javax.sql.DataSource;
-import java.sql.Types;
-
-/**
- * DB2 specific platform.
- */
-public class DB2Platform extends DatabasePlatform {
-
-  public DB2Platform() {
-    super();
-    this.name = "db2";
-    this.maxTableNameLength = 18;
-    this.maxConstraintNameLength = 18;
-    this.sqlLimiter = new Db2SqlLimiter();
-    this.platformDdl = new DB2Ddl(this);
-
-    this.dbIdentity.setSupportsGetGeneratedKeys(true);
-    this.dbIdentity.setSupportsSequence(true);
-
-    booleanDbType = Types.BOOLEAN;
-    dbTypeMap.put(DbType.REAL, new DbPlatformType("real"));
-    dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint"));
-    dbTypeMap.put(DbType.DECIMAL, new DbPlatformType("decimal", 15));
-  }
-
-  /**
-   * Return a DB2 specific sequence IdGenerator that supports batch fetching
-   * sequence values.
-   */
-  @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be,
-                                                       DataSource ds, String seqName, int batchSize) {
-
-    return new DB2SequenceIdGenerator(be, ds, seqName, batchSize);
-  }
-
-}
@@ -1,605 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.Query;
-import com.avaje.ebean.config.CustomDbTypeMapping;
-import com.avaje.ebean.config.DbTypeConfig;
-import com.avaje.ebean.config.PersistBatch;
-import com.avaje.ebean.config.Platform;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.PlatformDdl;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.sql.DataSource;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Types;
-
-/**
- * Database platform specific settings.
- */
-public class DatabasePlatform {
-
-  private static final Logger logger = LoggerFactory.getLogger(DatabasePlatform.class);
-
-  /**
-   * Behavior used when ending a query only transaction (at read committed isolation level).
-   */
-  public enum OnQueryOnly {
-
-    /**
-     * Rollback the transaction.
-     */
-    ROLLBACK,
-
-    /**
-     * Commit the transaction
-     */
-    COMMIT
-  }
-
-
-  /**
-   * Set to true for MySql, no other jdbc drivers need this workaround.
-   */
-  protected boolean useExtraTransactionOnIterateSecondaryQueries;
-
-  /**
-   * The behaviour used when ending a read only transaction at read committed isolation level.
-   */
-  protected OnQueryOnly onQueryOnly = OnQueryOnly.ROLLBACK;
-
-  /**
-   * The open quote used by quoted identifiers.
-   */
-  protected String openQuote = "\"";
-
-  /**
-   * The close quote used by quoted identifiers.
-   */
-  protected String closeQuote = "\"";
-
-  /**
-   * For limit/offset, row_number etc limiting of SQL queries.
-   */
-  protected SqlLimiter sqlLimiter = new LimitOffsetSqlLimiter();
-
-  /**
-   * Limit/offset support for SqlQuery only.
-   */
-  protected BasicSqlLimiter basicSqlLimiter = new BasicSqlLimitOffset();
-
-  /**
-   * Mapping of JDBC to Database types.
-   */
-  protected DbPlatformTypeMapping dbTypeMap = new DbPlatformTypeMapping();
-
-  /**
-   * Default values for DB columns.
-   */
-  protected DbDefaultValue dbDefaultValue = new DbDefaultValue();
-
-  /**
-   * Set to true if the DB has native UUID type support.
-   */
-  protected boolean nativeUuidType;
-
-  /**
-   * Defines DB identity/sequence features.
-   */
-  protected DbIdentity dbIdentity = new DbIdentity();
-
-  /**
-   * The history support for this database platform.
-   */
-  protected DbHistorySupport historySupport;
-
-  /**
-   * The JDBC type to map booleans to (by default).
-   */
-  protected int booleanDbType = Types.BOOLEAN;
-
-  /**
-   * The JDBC type to map Blob to.
-   */
-  protected int blobDbType = Types.BLOB;
-
-  /**
-   * The JDBC type to map Clob to.
-   */
-  protected int clobDbType = Types.CLOB;
-
-  /**
-   * For Oracle treat empty strings as null.
-   */
-  protected boolean treatEmptyStringsAsNull;
-
-  /**
-   * The database platform name.
-   */
-  protected String name = "generic";
-
-  protected String columnAliasPrefix = "c";
-
-  protected String tableAliasPlaceHolder = "${ta}";
-
-  /**
-   * Use a BackTick ` at the beginning and end of table or column names that you
-   * want to use quoted identifiers for. The backticks get converted to the
-   * appropriate characters in convertQuotedIdentifiers
-   */
-  private static final char BACK_TICK = '`';
-
-  /**
-   * The like clause. Can be overridden to disable default escape character.
-   */
-  protected String likeClause = "like ?";
-
-  protected DbEncrypt dbEncrypt;
-
-  protected boolean idInExpandedForm;
-
-  protected boolean selectCountWithAlias;
-
-  /**
-   * If set then use the FORWARD ONLY hint when creating ResultSets for
-   * findIterate() and findVisit().
-   */
-  protected boolean forwardOnlyHintOnFindIterate;
-
-  /**
-   * By default we use JDBC batch when cascading (except for SQL Server).
-   */
-  protected PersistBatch persistBatchOnCascade = PersistBatch.ALL;
-
-  protected PlatformDdl platformDdl;
-
-  /**
-   * The maximum length of table names - used specifically when derived
-   * default table names for intersection tables.
-   */
-  protected int maxTableNameLength = 60;
-
-  /**
-   * A value of 60 is a reasonable default for all databases except
-   * Oracle (limited to 30) and DB2 (limited to 18).
-   */
-  protected int maxConstraintNameLength = 60;
-
-  protected boolean supportsNativeIlike;
-
-  /**
-   * Instantiates a new database platform.
-   */
-  public DatabasePlatform() {
-  }
-
-  /**
-   * Configure UUID Storage etc based on ServerConfig settings.
-   */
-  public void configure(DbTypeConfig config) {
-    addGeoTypes(config.getGeometrySRID());
-    configureIdType(config.getIdType());
-    dbTypeMap.config(nativeUuidType, config.getDbUuid());
-    for (CustomDbTypeMapping mapping : config.getCustomTypeMappings()) {
-      if (platformMatch(mapping.getPlatform())) {
-        dbTypeMap.put(mapping.getType(), parse(mapping.getColumnDefinition()));
-      }
-    }
-  }
-
-  protected void configureIdType(IdType idType) {
-    if (idType != null) {
-      this.dbIdentity.setIdType(idType);
-    }
-  }
-
-  protected void addGeoTypes(int srid) {
-    // default has no geo type support
-  }
-
-  private DbPlatformType parse(String columnDefinition) {
-    return DbPlatformType.parse(columnDefinition);
-  }
-
-  private boolean platformMatch(Platform platform) {
-    return platform == null || platform.name().equalsIgnoreCase(name);
-  }
-
-  /**
-   * Return true if this matches the given platform.
-   */
-  public boolean isPlatform(Platform platform) {
-    return platform.name().equalsIgnoreCase(name);
-  }
-
-  /**
-   * Return the name of the DatabasePlatform.
-   * <p>
-   * "generic" is returned when no specific database platform has been set or
-   * found.
-   * </p>
-   */
-  public String getName() {
-    return name;
-  }
-
-  /**
-   * Return true if this database platform supports native ILIKE expression.
-   */
-  public boolean isSupportsNativeIlike() {
-    return supportsNativeIlike;
-  }
-
-  /**
-   * Return the maximum table name length.
-   * <p>
-   * This is used when deriving names of intersection tables.
-   * </p>
-   */
-  public int getMaxTableNameLength() {
-    return maxTableNameLength;
-  }
-
-  /**
-   * Return the maximum constraint name allowed for the platform.
-   */
-  public int getMaxConstraintNameLength() {
-    return maxConstraintNameLength;
-  }
-
-  /**
-   * Return the platform specific DDL.
-   */
-  public PlatformDdl getPlatformDdl() {
-    return platformDdl;
-  }
-
-  /**
-   * Create and return a DDL handler for generating DDL scripts.
-   */
-  public DdlHandler createDdlHandler(ServerConfig serverConfig) {
-    return platformDdl.createDdlHandler(serverConfig);
-  }
-
-  /**
-   * Return true if the JDBC driver does not allow additional queries to execute
-   * when a resultSet is being 'streamed' as is the case with findEach() etc.
-   * <p>
-   * Honestly, this is a workaround for a stupid MySql JDBC driver limitation.
-   * </p>
-   */
-  public boolean useExtraTransactionOnIterateSecondaryQueries() {
-    return useExtraTransactionOnIterateSecondaryQueries;
-  }
-
-  /**
-   * Return a DB Sequence based IdGenerator.
-   *
-   * @param be        the BackgroundExecutor that can be used to load the sequence if
-   *                  desired
-   * @param ds        the DataSource
-   * @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) {
-    return null;
-  }
-
-  /**
-   * Return the behaviour to use when ending a read only transaction.
-   */
-  public OnQueryOnly getOnQueryOnly() {
-    return onQueryOnly;
-  }
-
-  /**
-   * Set the behaviour to use when ending a read only transaction.
-   */
-  public void setOnQueryOnly(OnQueryOnly onQueryOnly) {
-    this.onQueryOnly = onQueryOnly;
-  }
-
-  /**
-   * Return the DbEncrypt handler for this DB platform.
-   */
-  public DbEncrypt getDbEncrypt() {
-    return dbEncrypt;
-  }
-
-  /**
-   * Set the DbEncrypt handler for this DB platform.
-   */
-  public void setDbEncrypt(DbEncrypt dbEncrypt) {
-    this.dbEncrypt = dbEncrypt;
-  }
-
-  /**
-   * Return the history support for this database platform.
-   */
-  public DbHistorySupport getHistorySupport() {
-    return historySupport;
-  }
-
-  /**
-   * Set the history support for this database platform.
-   */
-  public void setHistorySupport(DbHistorySupport historySupport) {
-    this.historySupport = historySupport;
-  }
-
-  /**
-   * Return true if the DB supports native UUID.
-   */
-  public boolean isNativeUuidType() {
-    return nativeUuidType;
-  }
-
-  /**
-   * Return the mapping of JDBC to DB types.
-   *
-   * @return the db type map
-   */
-  public DbPlatformTypeMapping getDbTypeMap() {
-    return dbTypeMap;
-  }
-
-  /**
-   * Return the mapping for DB column default values.
-   */
-  public DbDefaultValue getDbDefaultValue() {
-    return dbDefaultValue;
-  }
-
-  /**
-   * Return the column alias prefix.
-   */
-  public String getColumnAliasPrefix() {
-    return columnAliasPrefix;
-  }
-
-  /**
-   * Set the column alias prefix.
-   */
-  public void setColumnAliasPrefix(String columnAliasPrefix) {
-    this.columnAliasPrefix = columnAliasPrefix;
-  }
-
-  /**
-   * Return the table alias placeholder.
-   */
-  public String getTableAliasPlaceHolder() {
-    return tableAliasPlaceHolder;
-  }
-
-  /**
-   * Set the table alias placeholder.
-   */
-  public void setTableAliasPlaceHolder(String tableAliasPlaceHolder) {
-    this.tableAliasPlaceHolder = tableAliasPlaceHolder;
-  }
-
-  /**
-   * Return the close quote for quoted identifiers.
-   *
-   * @return the close quote
-   */
-  public String getCloseQuote() {
-    return closeQuote;
-  }
-
-  /**
-   * Return the open quote for quoted identifiers.
-   *
-   * @return the open quote
-   */
-  public String getOpenQuote() {
-    return openQuote;
-  }
-
-  /**
-   * Return the JDBC type used to store booleans.
-   *
-   * @return the boolean db type
-   */
-  public int getBooleanDbType() {
-    return booleanDbType;
-  }
-
-  /**
-   * Return the data type that should be used for Blob.
-   * <p>
-   * This is typically Types.BLOB but for Postgres is Types.LONGVARBINARY for
-   * example.
-   * </p>
-   */
-  public int getBlobDbType() {
-    return blobDbType;
-  }
-
-  /**
-   * Return the data type that should be used for Clob.
-   * <p>
-   * This is typically Types.CLOB but for Postgres is Types.VARCHAR.
-   * </p>
-   */
-  public int getClobDbType() {
-    return clobDbType;
-  }
-
-  /**
-   * Return true if empty strings should be treated as null.
-   *
-   * @return true, if checks if is treat empty strings as null
-   */
-  public boolean isTreatEmptyStringsAsNull() {
-    return treatEmptyStringsAsNull;
-  }
-
-  /**
-   * Return true if a compound ID in (...) type expression needs to be in
-   * expanded form of (a=? and b=?) or (a=? and b=?) or ... rather than (a,b) in
-   * ((?,?),(?,?),...);
-   */
-  public boolean isIdInExpandedForm() {
-    return idInExpandedForm;
-  }
-
-  /**
-   * Return true if the ResultSet TYPE_FORWARD_ONLY Hint should be used on
-   * findIterate() and findVisit() PreparedStatements.
-   * <p>
-   * This specifically is required for MySql when processing large results.
-   * </p>
-   */
-  public boolean isForwardOnlyHintOnFindIterate() {
-    return forwardOnlyHintOnFindIterate;
-  }
-
-  /**
-   * Set to true if the ResultSet TYPE_FORWARD_ONLY Hint should be used by default on findIterate PreparedStatements.
-   */
-  public void setForwardOnlyHintOnFindIterate(boolean forwardOnlyHintOnFindIterate) {
-    this.forwardOnlyHintOnFindIterate = forwardOnlyHintOnFindIterate;
-  }
-
-  /**
-   * Return the DB identity/sequence features for this platform.
-   *
-   * @return the db identity
-   */
-  public DbIdentity getDbIdentity() {
-    return dbIdentity;
-  }
-
-  /**
-   * Return the SqlLimiter used to apply additional sql around a query to limit
-   * its results.
-   * <p>
-   * Basically add the clauses for limit/offset, rownum, row_number().
-   * </p>
-   *
-   * @return the sql limiter
-   */
-  public SqlLimiter getSqlLimiter() {
-    return sqlLimiter;
-  }
-
-  /**
-   * Return the BasicSqlLimiter for limit/offset of SqlQuery queries.
-   */
-  public BasicSqlLimiter getBasicSqlLimiter() {
-    return basicSqlLimiter;
-  }
-
-  /**
-   * Set the DB TRUE literal (from the registered boolean ScalarType)
-   */
-  public void setDbTrueLiteral(String dbTrueLiteral) {
-    this.dbDefaultValue.setTrue(dbTrueLiteral);
-  }
-
-  /**
-   * Set the DB FALSE literal (from the registered boolean ScalarType)
-   */
-  public void setDbFalseLiteral(String dbFalseLiteral) {
-    this.dbDefaultValue.setFalse(dbFalseLiteral);
-  }
-
-  /**
-   * Convert backticks to the platform specific open quote and close quote
-   * <p>
-   * Specific plugins may implement this method to cater for platform specific
-   * naming rules.
-   * </p>
-   *
-   * @param dbName the db name
-   * @return the string
-   */
-  public String convertQuotedIdentifiers(String dbName) {
-    // Ignore null values e.g. schema name or catalog
-    if (dbName != null && !dbName.isEmpty()) {
-      if (dbName.charAt(0) == BACK_TICK) {
-        if (dbName.charAt(dbName.length() - 1) == BACK_TICK) {
-
-          String quotedName = getOpenQuote();
-          quotedName += dbName.substring(1, dbName.length() - 1);
-          quotedName += getCloseQuote();
-
-          return quotedName;
-
-        } else {
-          logger.error("Missing backquote on [" + dbName + "]");
-        }
-      }
-    }
-    return dbName;
-  }
-
-  /**
-   * Set to true if select count against anonymous view requires an alias.
-   */
-  public boolean isSelectCountWithAlias() {
-    return selectCountWithAlias;
-  }
-
-  public String completeSql(String sql, Query<?> query) {
-    if (Boolean.TRUE.equals(query.isForUpdate())) {
-      sql = withForUpdate(sql);
-    }
-
-    return sql;
-  }
-
-  protected String withForUpdate(String sql) {
-    // silently assume the database does not support the "for update" clause.
-    logger.info("it seems your database does not support the 'for update' clause");
-
-    return sql;
-  }
-
-  /**
-   * Returns the like clause used by this database platform.
-   * <p>
-   * This may include an escape clause to disable a default escape character.
-   */
-  public String getLikeClause() {
-    return likeClause;
-  }
-
-  /**
-   * Return the platform default JDBC batch mode for persist cascade.
-   */
-  public PersistBatch getPersistBatchOnCascade() {
-    return persistBatchOnCascade;
-  }
-
-  /**
-   * Return true if the table exists.
-   */
-  public boolean tableExists(Connection connection, String catalog, String schema, String table) throws SQLException {
-
-    DatabaseMetaData metaData = connection.getMetaData();
-    ResultSet tables = metaData.getTables(catalog, schema, table, null);
-    try {
-      return tables.next();
-    } finally {
-      close(tables);
-    }
-  }
-
-  /**
-   * Close the resultSet.
-   */
-  protected void close(ResultSet resultSet) {
-    try {
-      resultSet.close();
-    } catch (SQLException e) {
-      logger.error("Error closing resultSet", e);
-    }
-  }
-}
@@ -1,70 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/**
- * DB Column default values mapping to database platform specific literals.
- */
-public class DbDefaultValue {
-
-  /**
-   * The key for FALSE.
-   */
-  public static final String FALSE = "false";
-
-  /**
-   * The key for TRUE.
-   */
-  public static final String TRUE = "true";
-
-  /**
-   * The key for the NOW / current timestamp.
-   */
-  public static final String NOW = "now";
-
-  protected Map<String, String> map = new LinkedHashMap<>();
-
-  /**
-   * Set the DB now function.
-   */
-  public void setNow(String dbFunction) {
-    put(NOW, dbFunction);
-  }
-
-  /**
-   * Set the DB false literal.
-   */
-  public void setFalse(String dbFalseLiteral) {
-    put(FALSE, dbFalseLiteral);
-  }
-
-  /**
-   * Set the DB true literal.
-   */
-  public void setTrue(String dbTrueLiteral) {
-    put(TRUE, dbTrueLiteral);
-  }
-
-  /**
-   * Add an translation entry.
-   */
-  public void put(String dbLiteral, String dbTranslated) {
-    map.put(dbLiteral, dbTranslated);
-  }
-
-  /**
-   * Convert the DB default literal to platform specific type or function.
-   * <p>
-   * This is intended for the DB column default clause in DDL.
-   * </p>
-   */
-  public String convert(String dbDefaultLiteral) {
-    if (dbDefaultLiteral == null) {
-      return null;
-    }
-    String val = map.get(dbDefaultLiteral);
-    return val != null ? val : dbDefaultLiteral;
-  }
-
-}
@@ -1,8 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-/**
- * Runtime support for @History with H2.
- */
-public class H2HistorySupport extends DbViewHistorySupport {
-
-}
@@ -1,49 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.H2Ddl;
-
-import javax.sql.DataSource;
-
-/**
- * H2 specific platform.
- */
-public class H2Platform extends DatabasePlatform {
-
-  public H2Platform() {
-    super();
-    this.name = "h2";
-    this.dbEncrypt = new H2DbEncrypt();
-    this.platformDdl = new H2Ddl(this);
-    this.historySupport = new H2HistorySupport();
-    this.nativeUuidType = true;
-    this.dbDefaultValue.setNow("now()");
-
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(true);
-    this.dbIdentity.setSupportsSequence(true);
-    this.dbIdentity.setSupportsIdentity(true);
-
-    // like ? escape'' not working in the latest version H2 so just using no
-    // escape clause for now noting that backslash is an escape char for like in H2
-    this.likeClause = "like ?";
-
-    dbTypeMap.put(DbType.UUID, new DbPlatformType("uuid", false));
-  }
-
-  /**
-   * Return a H2 specific sequence IdGenerator that supports batch fetching
-   * sequence values.
-   */
-  @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds,
-                                                       String seqName, int batchSize) {
-
-    return new H2SequenceIdGenerator(be, ds, seqName, batchSize);
-  }
-
-  @Override
-  protected String withForUpdate(String sql) {
-    return sql + " for update";
-  }
-}
@@ -1,33 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.HsqldbDdl;
-
-import javax.sql.DataSource;
-
-/**
- * H2 specific platform.
- */
-public class HsqldbPlatform extends DatabasePlatform {
-
-  public HsqldbPlatform() {
-    super();
-    this.name = "hsqldb";
-    this.dbEncrypt = new H2DbEncrypt();
-    this.platformDdl = new HsqldbDdl(this);
-
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(true);
-    this.dbIdentity.setSupportsSequence(true);
-    this.dbIdentity.setSupportsIdentity(true);
-
-    dbTypeMap.put(DbType.INTEGER, new DbPlatformType("integer", false));
-  }
-
-  @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
-
-    return new H2SequenceIdGenerator(be, ds, seqName, batchSize);
-  }
-
-}
@@ -1,49 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.config.PersistBatch;
-
-/**
- * Microsoft SQL Server 2000 specific platform.
- * <p>
- * <ul>
- * <li>supportsGetGeneratedKeys = false</li>
- * <li>Use select @@IDENTITY to return the generated Id instead</li>
- * <li>Uses LIMIT OFFSET clause</li>
- * <li>Uses [ & ] for quoted identifiers</li>
- * </ul>
- * </p>
- */
-public class MsSqlServer2000Platform extends DatabasePlatform {
-
-  public MsSqlServer2000Platform() {
-    super();
-    this.name = "mssqlserver2000";
-    this.persistBatchOnCascade = PersistBatch.NONE;
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(false);
-    this.dbIdentity.setSelectLastInsertedIdTemplate("select @@IDENTITY as X");
-    this.dbIdentity.setSupportsIdentity(true);
-
-    this.openQuote = "[";
-    this.closeQuote = "]";
-
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("bit default 0"));
-
-    dbTypeMap.put(DbType.BIGINT, new DbPlatformType("numeric", 19));
-    dbTypeMap.put(DbType.REAL, new DbPlatformType("float(16)"));
-    dbTypeMap.put(DbType.DOUBLE, new DbPlatformType("float(32)"));
-    dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint"));
-    dbTypeMap.put(DbType.DECIMAL, new DbPlatformType("numeric", 28));
-
-    dbTypeMap.put(DbType.BLOB, new DbPlatformType("image"));
-    dbTypeMap.put(DbType.CLOB, new DbPlatformType("text"));
-    dbTypeMap.put(DbType.LONGVARBINARY, new DbPlatformType("image"));
-    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("text"));
-
-    dbTypeMap.put(DbType.DATE, new DbPlatformType("datetime"));
-    dbTypeMap.put(DbType.TIME, new DbPlatformType("datetime"));
-    dbTypeMap.put(DbType.TIMESTAMP, new DbPlatformType("datetime"));
-
-  }
-
-}
@@ -1,55 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.config.PersistBatch;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.MsSqlServerDdl;
-
-/**
- * Microsoft SQL Server 2005 specific platform.
- * <p>
- * <ul>
- * <li>supportsGetGeneratedKeys = true</li>
- * <li>Uses LIMIT OFFSET clause</li>
- * <li>Uses [ & ] for quoted identifiers</li>
- * </ul>
- * </p>
- */
-public class MsSqlServer2005Platform extends DatabasePlatform {
-
-  public MsSqlServer2005Platform() {
-    super();
-    this.name = "mssqlserver2005";
-    // effectively disable persistBatchOnCascade mode for SQL Server
-    // due to lack of support for getGeneratedKeys in batch mode
-    this.persistBatchOnCascade = PersistBatch.NONE;
-    this.idInExpandedForm = true;
-    this.selectCountWithAlias = true;
-    this.sqlLimiter = new MsSqlServer2005SqlLimiter();
-    this.platformDdl = new MsSqlServerDdl(this);
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(true);
-    this.dbIdentity.setSupportsIdentity(true);
-
-    this.openQuote = "[";
-    this.closeQuote = "]";
-
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("bit default 0"));
-
-    dbTypeMap.put(DbType.INTEGER, new DbPlatformType("integer", false));
-    dbTypeMap.put(DbType.BIGINT, new DbPlatformType("numeric", 19));
-    dbTypeMap.put(DbType.REAL, new DbPlatformType("float(16)"));
-    dbTypeMap.put(DbType.DOUBLE, new DbPlatformType("float(32)"));
-    dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint"));
-    dbTypeMap.put(DbType.DECIMAL, new DbPlatformType("numeric", 28));
-
-    dbTypeMap.put(DbType.BLOB, new DbPlatformType("image"));
-    dbTypeMap.put(DbType.CLOB, new DbPlatformType("text"));
-    dbTypeMap.put(DbType.LONGVARBINARY, new DbPlatformType("image"));
-    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("text"));
-
-    dbTypeMap.put(DbType.DATE, new DbPlatformType("date"));
-    dbTypeMap.put(DbType.TIME, new DbPlatformType("time"));
-    dbTypeMap.put(DbType.TIMESTAMP, new DbPlatformType("datetime2"));
-
-  }
-
-}
@@ -1,78 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-/**
- * Use top and row_number() function to limit sql results.
- */
-public class MsSqlServer2005SqlLimiter implements SqlLimiter {
-
-  final String rowNumberWindowAlias;
-
-  /**
-   * Specify the name of the rowNumberWindowAlias.
-   */
-  public MsSqlServer2005SqlLimiter(String rowNumberWindowAlias) {
-    this.rowNumberWindowAlias = rowNumberWindowAlias;
-  }
-
-  public MsSqlServer2005SqlLimiter() {
-    this("as limitresult");
-  }
-
-  public SqlLimitResponse limit(SqlLimitRequest request) {
-
-    StringBuilder sb = new StringBuilder(500);
-
-    int firstRow = request.getFirstRow();
-
-    int lastRow = request.getMaxRows();
-    if (lastRow > 0) {
-      lastRow = lastRow + firstRow;
-    }
-
-    if (firstRow < 1) {
-      // just use top n
-      sb.append(" select ");
-      if (request.isDistinct()) {
-        sb.append("distinct ");
-      }
-      sb.append(" top ").append(lastRow).append(" ");
-      sb.append(request.getDbSql());
-      return new SqlLimitResponse(sb.toString(), false);
-    }
-
-    /*
-     * SELECT * FROM (SELECT TOP 20 ROW_NUMBER() OVER (ORDER BY ...) AS rn, ...)
-     * AS limitresult WHERE rn >= 11 AND rn <= 20
-     */
-
-    sb.append("select * ").append(NEW_LINE).append("from ( ");
-
-    sb.append("select ");
-    if (request.isDistinct()) {
-      sb.append("distinct ");
-    }
-    sb.append("top ").append(lastRow);
-    sb.append(" row_number() over (order by ");
-    sb.append(request.getDbOrderBy());
-    sb.append(") as rn, ");
-    sb.append(request.getDbSql());
-
-    sb.append(NEW_LINE).append(") ");
-    sb.append(rowNumberWindowAlias);
-    sb.append(" where ");
-    if (firstRow > 0) {
-      sb.append(" rn > ").append(firstRow);
-      if (lastRow > 0) {
-        sb.append(" and ");
-      }
-    }
-    if (lastRow > 0) {
-      sb.append(" rn <= ").append(lastRow);
-    }
-
-    String sql = request.getDbPlatform().completeSql(sb.toString(), request.getOrmQuery());
-
-    return new SqlLimitResponse(sql, true);
-  }
-
-}
@@ -1,8 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-/**
- * Runtime support for @History with MySql.
- */
-public class MySqlHistorySupport extends DbViewHistorySupport {
-
-}
@@ -1,65 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.MySqlDdl;
-
-import javax.sql.DataSource;
-import java.sql.Types;
-
-/**
- * MySQL specific platform.
- * <p>
- * <ul>
- * <li>supportsGetGeneratedKeys = true</li>
- * <li>Uses LIMIT OFFSET clause</li>
- * <li>Uses ` for quoted identifiers</li>
- * </ul>
- * </p>
- */
-public class MySqlPlatform extends DatabasePlatform {
-
-  public MySqlPlatform() {
-    super();
-    this.name = "mysql";
-    this.useExtraTransactionOnIterateSecondaryQueries = true;
-    this.likeClause = "like ? escape''";
-    this.selectCountWithAlias = true;
-    this.dbEncrypt = new MySqlDbEncrypt();
-    this.platformDdl = new MySqlDdl(this);
-    this.historySupport = new MySqlHistorySupport();
-
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(true);
-    this.dbIdentity.setSupportsIdentity(true);
-    this.dbIdentity.setSupportsSequence(false);
-
-    this.openQuote = "`";
-    this.closeQuote = "`";
-
-    this.forwardOnlyHintOnFindIterate = true;
-    this.booleanDbType = Types.BIT;
-
-    dbTypeMap.put(DbType.BIT, new DbPlatformType("tinyint(1) default 0"));
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("tinyint(1) default 0"));
-    dbTypeMap.put(DbType.TIMESTAMP, new DbPlatformType("datetime(6)"));
-    dbTypeMap.put(DbType.CLOB, new MySqlClob());
-    dbTypeMap.put(DbType.BLOB, new MySqlBlob());
-    dbTypeMap.put(DbType.BINARY, new DbPlatformType("binary", 255));
-    dbTypeMap.put(DbType.VARBINARY, new DbPlatformType("varbinary", 255));
-  }
-
-  /**
-   * Return null in case there is a sequence annotation.
-   */
-  @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be,
-                                                       DataSource ds, String seqName, int batchSize) {
-
-    return null;
-  }
-
-  @Override
-  protected String withForUpdate(String sql) {
-    return sql + " for update";
-  }
-}
@@ -1,67 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.Oracle10Ddl;
-
-import javax.sql.DataSource;
-import java.sql.Types;
-
-/**
- * Oracle10 and greater specific platform.
- */
-public class OraclePlatform extends DatabasePlatform {
-
-  public OraclePlatform() {
-    super();
-    this.name = "oracle";
-    this.maxTableNameLength = 30;
-    this.maxConstraintNameLength = 30;
-    this.dbEncrypt = new OracleDbEncrypt();
-    this.sqlLimiter = new RownumSqlLimiter();
-    this.basicSqlLimiter = new BasicSqlAnsiLimiter();
-    this.platformDdl = new Oracle10Ddl(this);
-    this.historySupport = new OracleDbHistorySupport();
-
-    // Not using getGeneratedKeys as instead we will
-    // batch load sequences which enables JDBC batch execution
-    dbIdentity.setSupportsGetGeneratedKeys(false);
-    dbIdentity.setIdType(IdType.SEQUENCE);
-    dbIdentity.setSupportsSequence(true);
-
-    this.treatEmptyStringsAsNull = true;
-
-    this.openQuote = "\"";
-    this.closeQuote = "\"";
-
-    booleanDbType = Types.INTEGER;
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("number(1) default 0"));
-
-    dbTypeMap.put(DbType.INTEGER, new DbPlatformType("number", 10));
-    dbTypeMap.put(DbType.BIGINT, new DbPlatformType("number", 19));
-    dbTypeMap.put(DbType.REAL, new DbPlatformType("number", 19, 4));
-    dbTypeMap.put(DbType.DOUBLE, new DbPlatformType("number", 19, 4));
-    dbTypeMap.put(DbType.SMALLINT, new DbPlatformType("number", 5));
-    dbTypeMap.put(DbType.TINYINT, new DbPlatformType("number", 3));
-    dbTypeMap.put(DbType.DECIMAL, new DbPlatformType("number", 38));
-
-    dbTypeMap.put(DbType.VARCHAR, new DbPlatformType("varchar2", 255));
-
-    dbTypeMap.put(DbType.LONGVARBINARY, new DbPlatformType("blob"));
-    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("clob"));
-    dbTypeMap.put(DbType.VARBINARY, new DbPlatformType("raw", 255));
-    dbTypeMap.put(DbType.BINARY, new DbPlatformType("raw", 255));
-
-    dbTypeMap.put(DbType.TIME, new DbPlatformType("timestamp"));
-  }
-
-  @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
-
-    return new OracleSequenceIdGenerator(be, ds, seqName, batchSize);
-  }
-
-  @Override
-  protected String withForUpdate(String sql) {
-    return sql + " for update";
-  }
-}
@@ -1,25 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-
-import javax.sql.DataSource;
-
-/**
- * Oracle specific sequence Id Generator.
- */
-public class OracleSequenceIdGenerator extends SequenceIdGenerator {
-
-  private final String baseSql;
-
-  /**
-   * Construct given a dataSource and sql to return the next sequence value.
-   */
-  public OracleSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
-    super(be, ds, seqName, batchSize);
-    this.baseSql = "select " + seqName + ".nextval, a from (select level as a FROM dual CONNECT BY level <= ";
-  }
-
-  public String getSql(int batchSize) {
-    return baseSql + batchSize + ")";
-  }
-}
@@ -1,99 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.PostgresDdl;
-
-import javax.sql.DataSource;
-import java.sql.Types;
-
-/**
- * Postgres v9 specific platform.
- * <p>
- * Uses serial types and getGeneratedKeys.
- * </p>
- */
-public class PostgresPlatform extends DatabasePlatform {
-
-  public PostgresPlatform() {
-    super();
-    this.name = "postgres";
-    this.supportsNativeIlike = true;
-    this.likeClause = "like ? escape''";
-    this.selectCountWithAlias = true;
-    this.blobDbType = Types.LONGVARBINARY;
-    this.clobDbType = Types.VARCHAR;
-    this.nativeUuidType = true;
-
-    this.dbEncrypt = new PostgresDbEncrypt();
-    this.historySupport = new PostgresHistorySupport();
-    this.platformDdl = new PostgresDdl(this);
-
-    // Use Identity and getGeneratedKeys
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(true);
-    this.dbIdentity.setSupportsSequence(true);
-
-    //this.columnAliasPrefix = "as c";
-
-    this.openQuote = "\"";
-    this.closeQuote = "\"";
-
-    DbPlatformType dbTypeText = new DbPlatformType("text");
-    DbPlatformType dbBytea = new DbPlatformType("bytea", false);
-
-    dbTypeMap.put(DbType.UUID, new DbPlatformType("uuid", false));
-    dbTypeMap.put(DbType.HSTORE, new DbPlatformType("hstore", false));
-    dbTypeMap.put(DbType.JSON, new DbPlatformType("json", false));
-    dbTypeMap.put(DbType.JSONB, new DbPlatformType("jsonb", false));
-
-    dbTypeMap.put(DbType.INTEGER, new DbPlatformType("integer", false));
-    dbTypeMap.put(DbType.DOUBLE, new DbPlatformType("float"));
-    dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint"));
-    dbTypeMap.put(DbType.DECIMAL, new DbPlatformType("decimal", 38));
-    dbTypeMap.put(DbType.TIMESTAMP, new DbPlatformType("timestamptz"));
-
-    dbTypeMap.put(DbType.BINARY, dbBytea);
-    dbTypeMap.put(DbType.VARBINARY, dbBytea);
-
-    dbTypeMap.put(DbType.BLOB, dbBytea);
-    dbTypeMap.put(DbType.CLOB, dbTypeText);
-    dbTypeMap.put(DbType.LONGVARBINARY, dbBytea);
-    dbTypeMap.put(DbType.LONGVARCHAR, dbTypeText);
-  }
-
-  protected void addGeoTypes(int srid) {
-    dbTypeMap.put(DbType.POINT, geoType("point", srid));
-    dbTypeMap.put(DbType.POLYGON, geoType("polygon", srid));
-    dbTypeMap.put(DbType.LINESTRING, geoType("linestring", srid));
-    dbTypeMap.put(DbType.MULTIPOINT, geoType("multipoint", srid));
-    dbTypeMap.put(DbType.MULTILINESTRING, geoType("multilinestring", srid));
-    dbTypeMap.put(DbType.MULTIPOLYGON, geoType("multipolygon", srid));
-  }
-
-  private DbPlatformType geoType(String type, int srid) {
-    return new DbPlatformType("geometry(" + type + "," + srid + ")");
-  }
-
-  /**
-   * Return a DdlHandler instance for generating DDL for the specific platform.
-   */
-  public DdlHandler createDdlHandler(ServerConfig serverConfig) {
-    return this.platformDdl.createDdlHandler(serverConfig);
-  }
-
-  /**
-   * Create a Postgres specific sequence IdGenerator.
-   */
-  @Override
-  public PlatformIdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
-
-    return new PostgresSequenceIdGenerator(be, ds, seqName, batchSize);
-  }
-
-  @Override
-  protected String withForUpdate(String sql) {
-    return sql + " for update";
-  }
-}
@@ -1,25 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-
-import javax.sql.DataSource;
-
-/**
- * Postgres specific sequence Id Generator.
- */
-public class PostgresSequenceIdGenerator extends SequenceIdGenerator {
-
-  private final String baseSql;
-
-  /**
-   * Construct given a dataSource and sql to return the next sequence value.
-   */
-  public PostgresSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
-    super(be, ds, seqName, batchSize);
-    this.baseSql = "select nextval('" + seqName + "'), s.generate_series from (select generate_series from generate_series(1,";
-  }
-
-  public String getSql(int batchSize) {
-    return baseSql + batchSize + ") ) as s";
-  }
-}
@@ -1,28 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.SQLiteDdl;
-
-import java.sql.Types;
-
-public class SQLitePlatform extends DatabasePlatform {
-
-  public SQLitePlatform() {
-    super();
-    this.name = "sqlite";
-    this.platformDdl = new SQLiteDdl(this);
-
-    this.dbIdentity.setIdType(IdType.IDENTITY);
-    this.dbIdentity.setSupportsGetGeneratedKeys(false);
-    this.dbIdentity.setSupportsSequence(false);
-    this.dbIdentity.setSelectLastInsertedIdTemplate("select last_insert_rowid()");
-
-    this.booleanDbType = Types.INTEGER;
-
-    dbTypeMap.put(DbType.BIT, new DbPlatformType("int default 0"));
-    dbTypeMap.put(DbType.BOOLEAN, new DbPlatformType("int default 0"));
-    dbTypeMap.put(DbType.BIGINT, new DbPlatformType("integer"));
-    dbTypeMap.put(DbType.SMALLINT, new DbPlatformType("integer"));
-
-  }
-
-}
@@ -1,240 +0,0 @@
-package com.avaje.ebean.config.dbplatform;
-
-import com.avaje.ebean.BackgroundExecutor;
-import com.avaje.ebean.Transaction;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.persistence.PersistenceException;
-import javax.sql.DataSource;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.ArrayList;
-
-/**
- * Database sequence based IdGenerator.
- */
-public abstract class SequenceIdGenerator implements PlatformIdGenerator {
-
-  private static final Logger logger = LoggerFactory.getLogger(SequenceIdGenerator.class);
-
-  /**
-   * Used to synchronise the idList access.
-   */
-  protected final Object monitor = new Object();
-
-  /**
-   * Used to synchronise background loading (loadBatchInBackground).
-   */
-  protected final Object backgroundLoadMonitor = new Object();
-
-  /**
-   * The actual sequence name.
-   */
-  protected final String seqName;
-
-  protected final DataSource dataSource;
-
-  protected final BackgroundExecutor backgroundExecutor;
-
-  protected final ArrayList<Long> idList = new ArrayList<>(50);
-
-  protected final int batchSize;
-
-  protected int currentlyBackgroundLoading;
-
-  /**
-   * Construct given a dataSource and sql to return the next sequence value.
-   */
-  public SequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
-    this.backgroundExecutor = be;
-    this.dataSource = ds;
-    this.seqName = seqName;
-    this.batchSize = batchSize;
-  }
-
-  public abstract String getSql(int batchSize);
-
-  /**
-   * Returns the sequence name.
-   */
-  public String getName() {
-    return seqName;
-  }
-
-  /**
-   * Returns true.
-   */
-  public boolean isDbSequence() {
-    return true;
-  }
-
-  /**
-   * 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>
-   */
-  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));
-  }
-
-  /**
-   * Return the next Id.
-   * <p>
-   * If a Transaction has been passed in use the Connection from it.
-   * </p>
-   */
-  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();
-        }
-      }
-
-      return nextId;
-    }
-  }
-
-  /**
-   * 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;
-      }
-
-      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);
-    }
-
-    synchronized (monitor) {
-      for (Long newId : newIds) {
-        idList.add(newId);
-      }
-    }
-  }
-
-  /**
-   * Get more Id's by executing a query and reading the Id's returned.
-   */
-  protected ArrayList<Long> getMoreIds(int loadSize, Transaction t) {
-
-    String sql = getSql(loadSize);
-
-    ArrayList<Long> newIds = new ArrayList<>(loadSize);
-
-    boolean useTxnConnection = t != null;
-
-    Connection c = null;
-    PreparedStatement pstmt = null;
-    ResultSet rset = null;
-    try {
-      c = useTxnConnection ? t.getConnection() : dataSource.getConnection();
-
-      pstmt = c.prepareStatement(sql);
-      rset = pstmt.executeQuery();
-      while (rset.next()) {
-        newIds.add(rset.getLong(1));
-      }
-      if (newIds.isEmpty()) {
-        throw new PersistenceException("Always expecting more than 1 row from " + sql);
-      }
-
-      return newIds;
-
-    } 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);
-        System.out.println(msg);
-        return newIds;
-      } else {
-        throw new PersistenceException("Error getting sequence nextval", e);
-      }
-    } finally {
-      if (useTxnConnection) {
-        closeResources(null, pstmt, rset);
-      } else {
-        closeResources(c, pstmt, rset);
-      }
-    }
-  }
-
-  /**
-   * 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);
-    }
-  }
-
-}
@@ -1,562 +0,0 @@
-package com.avaje.ebean.dbmigration;
-
-import com.avaje.ebean.Ebean;
-import com.avaje.ebean.EbeanServer;
-import com.avaje.ebean.config.DbConstraintNaming;
-import com.avaje.ebean.config.DbMigrationConfig;
-import com.avaje.ebean.config.Platform;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.config.dbplatform.DB2Platform;
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-import com.avaje.ebean.config.dbplatform.H2Platform;
-import com.avaje.ebean.config.dbplatform.MsSqlServer2005Platform;
-import com.avaje.ebean.config.dbplatform.MySqlPlatform;
-import com.avaje.ebean.config.dbplatform.OraclePlatform;
-import com.avaje.ebean.config.dbplatform.PostgresPlatform;
-import com.avaje.ebean.config.dbplatform.SQLitePlatform;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
-import com.avaje.ebean.dbmigration.migration.Migration;
-import com.avaje.ebean.dbmigration.migrationreader.MigrationXmlWriter;
-import com.avaje.ebean.dbmigration.model.CurrentModel;
-import com.avaje.ebean.dbmigration.model.MConfiguration;
-import com.avaje.ebean.dbmigration.model.MigrationModel;
-import com.avaje.ebean.dbmigration.model.MigrationVersion;
-import com.avaje.ebean.dbmigration.model.ModelContainer;
-import com.avaje.ebean.dbmigration.model.ModelDiff;
-import com.avaje.ebean.dbmigration.model.PlatformDdlWriter;
-import com.avaje.ebeaninternal.api.SpiEbeanServer;
-import com.avaje.ebeaninternal.extraddl.model.DdlScript;
-import com.avaje.ebeaninternal.extraddl.model.ExtraDdl;
-import com.avaje.ebeaninternal.extraddl.model.ExtraDdlXmlReader;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Generates DB Migration xml and sql scripts.
- * <p>
- * Reads the prior migrations and compares with the current model of the EbeanServer
- * and generates a migration 'diff' in the form of xml document with the logical schema
- * changes and a series of sql scripts to apply, rollback the applied changes if necessary
- * and drop objects (drop tables, drop columns).
- * </p>
- * <p>
- * This does not run the migration or ddl scripts but just generates them.
- * </p>
- * <pre>{@code
- *
- *       DbMigration migration = new DbMigration();
- *       migration.setPathToResources("src/main/resources");
- *       migration.setPlatform(DbPlatformName.ORACLE);
- *
- *       migration.generateMigration();
- *
- * }</pre>
- */
-public class DbMigration {
-
-  protected static final Logger logger = LoggerFactory.getLogger(DbMigration.class);
-
-  private static final String initialVersion = "1.0";
-
-  private static final String GENERATED_COMMENT = "THIS IS A GENERATED FILE - DO NOT MODIFY";
-
-  /**
-   * Set to true if DbMigration run with online EbeanServer instance.
-   */
-  protected final boolean online;
-
-  protected SpiEbeanServer server;
-
-  protected DbMigrationConfig migrationConfig;
-
-  protected String pathToResources = "src/main/resources";
-
-  protected DatabasePlatform databasePlatform;
-
-  protected List<Pair> platforms = new ArrayList<>();
-
-  protected ServerConfig serverConfig;
-
-  protected DbConstraintNaming constraintNaming;
-
-  /**
-   * Create for offline migration generation.
-   */
-  public DbMigration() {
-    this.online = false;
-  }
-
-  /**
-   * Create using online EbeanServer.
-   */
-  public DbMigration(EbeanServer server) {
-    this.online = true;
-    setServer(server);
-  }
-
-  /**
-   * Set the path from the current working directory to the application resources.
-   * <p>
-   * This defaults to maven style 'src/main/resources'.
-   */
-  public void setPathToResources(String pathToResources) {
-    this.pathToResources = pathToResources;
-  }
-
-  /**
-   * Set the server to use to determine the current model.
-   * Typically this is not called explicitly.
-   */
-  public void setServer(EbeanServer ebeanServer) {
-    this.server = (SpiEbeanServer) ebeanServer;
-    setServerConfig(server.getServerConfig());
-  }
-
-  /**
-   * Set the serverConfig to use. Typically this is not called explicitly.
-   */
-  public void setServerConfig(ServerConfig config) {
-    if (this.serverConfig == null) {
-      this.serverConfig = config;
-    }
-    if (migrationConfig == null) {
-      this.migrationConfig = serverConfig.getMigrationConfig();
-    }
-    if (constraintNaming == null) {
-      this.constraintNaming = serverConfig.getConstraintNaming();
-    }
-  }
-
-  /**
-   * Set the specific platform to generate DDL for.
-   * <p>
-   * If not set this defaults to the platform of the default server.
-   * </p>
-   */
-  public void setPlatform(Platform platform) {
-    setPlatform(getPlatform(platform));
-  }
-
-  /**
-   * Set the specific platform to generate DDL for.
-   * <p>
-   * If not set this defaults to the platform of the default server.
-   * </p>
-   */
-  public void setPlatform(DatabasePlatform databasePlatform) {
-    this.databasePlatform = databasePlatform;
-    if (!online) {
-      DbOffline.setPlatform(databasePlatform.getName());
-    }
-  }
-
-  /**
-   * Add an additional platform to write the migration DDL.
-   * <p>
-   * Use this when you want to generate sql scripts for multiple database platforms
-   * from the migration (e.g. generate migration sql for MySql, Postgres and Oracle).
-   * </p>
-   */
-  public void addPlatform(Platform platform, String prefix) {
-    platforms.add(new Pair(getPlatform(platform), prefix));
-  }
-
-  /**
-   * Generate the next migration xml file and associated apply and rollback sql scripts.
-   * <p>
-   * This does not run the migration or ddl scripts but just generates them.
-   * </p>
-   * <h3>Example: Run for a single specific platform</h3>
-   * <pre>{@code
-   *
-   *       DbMigration migration = new DbMigration();
-   *       migration.setPathToResources("src/main/resources");
-   *       migration.setPlatform(DbPlatformName.ORACLE);
-   *
-   *       migration.generateMigration();
-   *
-   * }</pre>
-   * <p>
-   * <h3>Example: Run migration generating DDL for multiple platforms</h3>
-   * <pre>{@code
-   *
-   *       DbMigration migration = new DbMigration();
-   *       migration.setPathToResources("src/main/resources");
-   *
-   *       migration.addPlatform(DbPlatformName.POSTGRES, "pg");
-   *       migration.addPlatform(DbPlatformName.MYSQL, "mysql");
-   *       migration.addPlatform(DbPlatformName.ORACLE, "mysql");
-   *
-   *       migration.generateMigration();
-   *
-   * }</pre>
-   */
-  public void generateMigration() throws IOException {
-
-    // use this flag to stop other plugins like full DDL generation
-    if (!online) {
-      DbOffline.setGenerateMigration();
-      if (databasePlatform == null && !platforms.isEmpty()) {
-        // for multiple platform generation set the general platform
-        // to H2 so that it runs offline without DB connection
-        setPlatform(platforms.get(0).platform);
-      }
-    }
-    setDefaults();
-    try {
-      Request request = createRequest();
-
-      if (platforms.isEmpty()) {
-        generateExtraDdl(request.migrationDir, databasePlatform);
-      }
-
-      String pendingVersion = generatePendingDrop();
-      if (pendingVersion != null) {
-        generatePendingDrop(request, pendingVersion);
-      } else {
-        generateDiff(request);
-      }
-
-    } finally {
-      if (!online) {
-        DbOffline.reset();
-      }
-    }
-  }
-
-  /**
-   * Generate "repeatable" migration scripts.
-   * <p>
-   * These take scrips from extra-dll.xml (typically views) and outputs "repeatable"
-   * migration scripts (starting with "R__") to be run by FlywayDb or Ebean's own
-   * migration runner.
-   * </p>
-   */
-  private void generateExtraDdl(File migrationDir, DatabasePlatform dbPlatform) throws IOException {
-
-    if (dbPlatform != null) {
-      ExtraDdl extraDdl = ExtraDdlXmlReader.read("/extra-ddl.xml");
-      if (extraDdl != null) {
-        List<DdlScript> ddlScript = extraDdl.getDdlScript();
-        for (DdlScript script : ddlScript) {
-          if (ExtraDdlXmlReader.matchPlatform(dbPlatform.getName(), script.getPlatforms())) {
-            writeExtraDdl(migrationDir, script);
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Write (or override) the "repeatable" migration script.
-   */
-  private void writeExtraDdl(File migrationDir, DdlScript script) throws IOException {
-
-    String fullName = repeatableMigrationName(script.getName());
-
-    logger.info("writing repeatable script {}", fullName);
-
-    File file = new File(migrationDir, fullName);
-    FileWriter writer = new FileWriter(file);
-    writer.write(script.getValue());
-    writer.flush();
-    writer.close();
-  }
-
-  private String repeatableMigrationName(String scriptName) {
-    return "R__" + scriptName.replace(' ', '_') + migrationConfig.getApplySuffix();
-  }
-
-  /**
-   * Generate the diff migration.
-   */
-  private void generateDiff(Request request) throws IOException {
-
-    List<String> pendingDrops = request.getPendingDrops();
-    if (!pendingDrops.isEmpty()) {
-      logger.info("Pending un-applied drops in versions {}", pendingDrops);
-    }
-
-    Migration migration = request.createDiffMigration();
-    if (migration == null) {
-      logger.info("no changes detected - no migration written");
-    } else {
-      // there were actually changes to write
-      generateMigration(request, migration, null);
-    }
-  }
-
-  /**
-   * Generate the migration based on the pendingDrops from a prior version.
-   */
-  private void generatePendingDrop(Request request, String pendingVersion) throws IOException {
-
-    Migration migration = request.migrationForPendingDrop(pendingVersion);
-
-    generateMigration(request, migration, pendingVersion);
-
-    List<String> pendingDrops = request.getPendingDrops();
-    if (!pendingDrops.isEmpty()) {
-      logger.info("... remaining pending un-applied drops in versions {}", pendingDrops);
-    }
-  }
-
-  private Request createRequest() {
-    return new Request();
-  }
-
-  private class Request {
-
-    final File migrationDir;
-    final File modelDir;
-    final MigrationModel migrationModel;
-    final CurrentModel currentModel;
-    final ModelContainer migrated;
-    final ModelContainer current;
-
-    private Request() {
-      this.migrationDir = getMigrationDirectory();
-      this.modelDir = getModelDirectory(migrationDir);
-      this.migrationModel = new MigrationModel(modelDir, migrationConfig.getModelSuffix());
-      this.migrated = migrationModel.read();
-      this.currentModel = new CurrentModel(server, constraintNaming);
-      this.current = currentModel.read();
-    }
-
-    /**
-     * Return the migration for the pending drops for a given version.
-     */
-    public Migration migrationForPendingDrop(String pendingVersion) {
-
-      Migration migration = migrated.migrationForPendingDrop(pendingVersion);
-
-      // register any remaining pending drops
-      migrated.registerPendingHistoryDropColumns(current);
-      return migration;
-    }
-
-    /**
-     * Return the list of versions that have pending un-applied drops.
-     */
-    public List<String> getPendingDrops() {
-      return migrated.getPendingDrops();
-    }
-
-    /**
-     * Create and return the diff of the current model to the migration model.
-     */
-    public Migration createDiffMigration() {
-      ModelDiff diff = new ModelDiff(migrated);
-      diff.compareTo(current);
-      return diff.isEmpty() ? null : diff.getMigration();
-    }
-  }
-
-  private void generateMigration(Request request, Migration dbMigration, String dropsFor) throws IOException {
-
-    String fullVersion = getFullVersion(request.migrationModel, dropsFor);
-
-    logger.info("generating migration:{}", fullVersion);
-    if (!writeMigrationXml(dbMigration, request.modelDir, fullVersion)) {
-      logger.warn("migration already exists, not generating DDL");
-
-    } else {
-      if (!platforms.isEmpty()) {
-        writeExtraPlatformDdl(fullVersion, request.currentModel, dbMigration, request.migrationDir);
-
-      } else if (databasePlatform != null) {
-        // writer needs the current model to provide table/column details for
-        // history ddl generation (triggers, history tables etc)
-        DdlWrite write = new DdlWrite(new MConfiguration(), request.current);
-        PlatformDdlWriter writer = createDdlWriter(databasePlatform, "");
-        writer.processMigration(dbMigration, write, request.migrationDir, fullVersion);
-      }
-    }
-  }
-
-  /**
-   * Return true if the next pending drop changeSet should be generated as the next migration.
-   */
-  private String generatePendingDrop() {
-
-    String nextDrop = System.getProperty("ddl.migration.pendingDropsFor");
-    if (nextDrop != null) {
-      return nextDrop;
-    }
-    return migrationConfig.getGeneratePendingDrop();
-  }
-
-  /**
-   * Return the full version for the migration being generated.
-   * <p>
-   * The full version can contain a comment suffix after a "__" double underscore.
-   */
-  private String getFullVersion(MigrationModel migrationModel, String dropsFor) {
-
-    String version = migrationConfig.getVersion();
-    if (version == null) {
-      version = migrationModel.getNextVersion(initialVersion);
-    }
-
-    String fullVersion = migrationConfig.getApplyPrefix() + version;
-    if (migrationConfig.getName() != null) {
-      fullVersion += "__" + toUnderScore(migrationConfig.getName());
-
-    } else if (dropsFor != null) {
-      fullVersion += "__" + toUnderScore("dropsFor_" + MigrationVersion.trim(dropsFor));
-
-    } else if (version.equals(initialVersion)) {
-      fullVersion += "__initial";
-    }
-    return fullVersion;
-  }
-
-  /**
-   * Replace spaces with underscores.
-   */
-  private String toUnderScore(String name) {
-    return name.replace(' ', '_');
-  }
-
-  /**
-   * Write any extra platform ddl.
-   */
-  protected void writeExtraPlatformDdl(String fullVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
-
-    for (Pair pair : platforms) {
-      DdlWrite platformBuffer = new DdlWrite(new MConfiguration(), currentModel.read());
-      PlatformDdlWriter platformWriter = createDdlWriter(pair);
-      File subPath = platformWriter.subPath(writePath, pair.prefix);
-      platformWriter.processMigration(dbMigration, platformBuffer, subPath, fullVersion);
-
-      generateExtraDdl(subPath, pair.platform);
-    }
-  }
-
-  private PlatformDdlWriter createDdlWriter(Pair pair) {
-    return createDdlWriter(pair.platform, pair.prefix);
-  }
-
-  private PlatformDdlWriter createDdlWriter(DatabasePlatform platform, String prefix) {
-    return new PlatformDdlWriter(platform, serverConfig, prefix, migrationConfig);
-  }
-
-  /**
-   * Write the migration xml.
-   */
-  protected boolean writeMigrationXml(Migration dbMigration, File resourcePath, String fullVersion) {
-
-    String modelFile = fullVersion + migrationConfig.getModelSuffix();
-    File file = new File(resourcePath, modelFile);
-    if (file.exists()) {
-      return false;
-    }
-    String comment = migrationConfig.isIncludeGeneratedFileComment() ? GENERATED_COMMENT : null;
-    MigrationXmlWriter xmlWriter = new MigrationXmlWriter(comment);
-    xmlWriter.write(dbMigration, file);
-    return true;
-  }
-
-  /**
-   * Set default server and platform if necessary.
-   */
-  protected void setDefaults() {
-    if (server == null) {
-      setServer(Ebean.getDefaultServer());
-    }
-    if (databasePlatform == null && platforms.isEmpty()) {
-      // not explicitly set not set a list of platforms so
-      // default to the platform of the default server
-      databasePlatform = server.getDatabasePlatform();
-      logger.debug("set platform to {}", databasePlatform.getName());
-    }
-  }
-
-  /**
-   * Return the file path to write the xml and sql to.
-   */
-  protected File getMigrationDirectory() {
-
-    // path to src/main/resources in typical maven project
-    File resourceRootDir = new File(pathToResources);
-    String resourcePath = migrationConfig.getMigrationPath();
-
-    // expect to be a path to something like - src/main/resources/dbmigration/model
-    File path = new File(resourceRootDir, resourcePath);
-    if (!path.exists()) {
-      if (!path.mkdirs()) {
-        logger.debug("Unable to ensure migration directory exists at {}", path.getAbsolutePath());
-      }
-    }
-    return path;
-  }
-
-  /**
-   * Return the model directory (relative to the migration directory).
-   */
-  protected File getModelDirectory(File migrationDirectory) {
-    String modelPath = migrationConfig.getModelPath();
-    if (modelPath == null || modelPath.isEmpty()) {
-      return migrationDirectory;
-    }
-    File modelDir = new File(migrationDirectory, migrationConfig.getModelPath());
-    if (!modelDir.exists() && !modelDir.mkdirs()) {
-      logger.debug("Unable to ensure migration model directory exists at {}", modelDir.getAbsolutePath());
-    }
-    return modelDir;
-  }
-
-  /**
-   * Return the DatabasePlatform given the platform key.
-   */
-  protected DatabasePlatform getPlatform(Platform platform) {
-    switch (platform) {
-      case H2:
-        return new H2Platform();
-      case POSTGRES:
-        return new PostgresPlatform();
-      case MYSQL:
-        return new MySqlPlatform();
-      case ORACLE:
-        return new OraclePlatform();
-      case SQLSERVER:
-        return new MsSqlServer2005Platform();
-      case DB2:
-        return new DB2Platform();
-      case SQLITE:
-        return new SQLitePlatform();
-
-      default:
-        throw new IllegalArgumentException("Platform missing? " + platform);
-    }
-  }
-
-  /**
-   * Holds a platform and prefix. Used to generate multiple platform specific DDL
-   * for a single migration.
-   */
-  public static class Pair {
-
-    /**
-     * The platform to generate the DDL for.
-     */
-    public final DatabasePlatform platform;
-
-    /**
-     * A prefix included into the file/resource names indicating the platform.
-     */
-    public final String prefix;
-
-    public Pair(DatabasePlatform platform, String prefix) {
-      this.platform = platform;
-      this.prefix = prefix;
-    }
-  }
-
-}
@@ -1,273 +0,0 @@
-package com.avaje.ebean.dbmigration;
-
-import com.avaje.ebean.Transaction;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.dbmigration.model.CurrentModel;
-import com.avaje.ebeaninternal.api.SpiEbeanServer;
-import com.avaje.ebeaninternal.extraddl.model.ExtraDdlXmlReader;
-import org.avaje.dbmigration.ddl.DdlRunner;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.persistence.PersistenceException;
-import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.LineNumberReader;
-import java.io.Reader;
-import java.sql.Connection;
-import java.sql.SQLException;
-
-/**
- * Controls the generation and execution of "Create All" and "Drop All" DDL scripts.
- * <p>
- * Typically the "Create All" DDL is executed for running tests etc and has nothing to do
- * with DB Migration (diff based) DDL.
- */
-public class DdlGenerator {
-
-  private static final Logger log = LoggerFactory.getLogger(DdlGenerator.class);
-
-  private final SpiEbeanServer server;
-
-  private final boolean generateDdl;
-  private final boolean runDdl;
-  private final boolean createOnly;
-
-  private CurrentModel currentModel;
-  private String dropAllContent;
-  private String createAllContent;
-
-  public DdlGenerator(SpiEbeanServer server, ServerConfig serverConfig) {
-    this.server = server;
-    this.generateDdl = serverConfig.isDdlGenerate();
-    this.createOnly = serverConfig.isDdlCreateOnly();
-    if (serverConfig.getTenantMode().isDynamicDataSource() && serverConfig.isDdlRun()) {
-      log.warn("DDL can't be run on startup with TenantMode " + serverConfig.getTenantMode());
-      this.runDdl = false;
-    } else {
-      this.runDdl = serverConfig.isDdlRun();
-    }
-  }
-
-  /**
-   * Generate the DDL and then run the DDL based on property settings
-   * (ebean.ddl.generate and ebean.ddl.run etc).
-   */
-  public void execute(boolean online) {
-    generateDdl();
-    if (online) {
-      runDdl();
-    }
-  }
-
-  /**
-   * Generate the DDL drop and create scripts if the properties have been set.
-   */
-  protected void generateDdl() {
-    if (generateDdl) {
-      if (!createOnly) {
-        writeDrop(getDropFileName());
-      }
-      writeCreate(getCreateFileName());
-    }
-  }
-
-  /**
-   * Run the DDL drop and DDL create scripts if properties have been set.
-   */
-  protected void runDdl() {
-
-    if (runDdl) {
-      try {
-        runInitSql();
-        runDropSql();
-        runCreateSql();
-        runSeedSql();
-
-      } catch (IOException e) {
-        String msg = "Error reading drop/create script from file system";
-        throw new RuntimeException(msg, e);
-      }
-    }
-  }
-
-  /**
-   * Execute all the DDL statements in the script.
-   */
-  public int runScript(boolean expectErrors, String content, String scriptName) {
-
-    DdlRunner runner = new DdlRunner(expectErrors, scriptName);
-
-    Transaction transaction = server.createTransaction();
-    Connection connection = transaction.getConnection();
-    try {
-      if (expectErrors) {
-        connection.setAutoCommit(true);
-      }
-      int count = runner.runAll(content, connection);
-      if (expectErrors) {
-        connection.setAutoCommit(false);
-      }
-      transaction.commit();
-      return count;
-
-    } catch (SQLException e) {
-      throw new PersistenceException("Failed to run script", e);
-
-    } finally {
-      transaction.end();
-    }
-  }
-
-  protected void runDropSql() throws IOException {
-    if (!createOnly) {
-      if (dropAllContent == null) {
-        dropAllContent = readFile(getDropFileName());
-      }
-      runScript(true, dropAllContent, getDropFileName());
-    }
-  }
-
-  protected void runCreateSql() throws IOException {
-    if (createAllContent == null) {
-      createAllContent = readFile(getCreateFileName());
-    }
-    runScript(false, createAllContent, getCreateFileName());
-
-    String ignoreExtraDdl = System.getProperty("ebean.ignoreExtraDdl");
-    if (!"true".equalsIgnoreCase(ignoreExtraDdl)) {
-      String extraApply = ExtraDdlXmlReader.buildExtra(server.getDatabasePlatform().getName());
-      if (extraApply != null) {
-        runScript(false, extraApply, "extra-dll");
-      }
-    }
-  }
-
-  protected void runInitSql() throws IOException {
-    runResourceScript(server.getServerConfig().getDdlInitSql());
-  }
-
-  protected void runSeedSql() throws IOException {
-    runResourceScript(server.getServerConfig().getDdlSeedSql());
-  }
-
-  protected void runResourceScript(String sqlScript) throws IOException {
-
-    if (sqlScript != null) {
-      InputStream is = getClassLoader().getResourceAsStream(sqlScript);
-      if (is != null) {
-        String content = readContent(new InputStreamReader(is));
-        runScript(false, content, sqlScript);
-      }
-    }
-  }
-
-  /**
-   * Return the classLoader to use to read sql scripts as resources.
-   */
-  protected ClassLoader getClassLoader() {
-    ClassLoader cl = Thread.currentThread().getContextClassLoader();
-    if (cl == null) {
-      cl = this.getClassLoader();
-    }
-    return cl;
-  }
-
-  protected void writeDrop(String dropFile) {
-
-    try {
-      writeFile(dropFile, generateDropAllDdl());
-    } catch (IOException e) {
-      throw new PersistenceException("Error generating Drop DDL", e);
-    }
-  }
-
-  protected void writeCreate(String createFile) {
-
-    try {
-      writeFile(createFile, generateCreateAllDdl());
-    } catch (IOException e) {
-      throw new PersistenceException("Error generating Create DDL", e);
-    }
-  }
-
-  protected String generateDropAllDdl() {
-
-    try {
-      dropAllContent = currentModel().getDropAllDdl();
-      return dropAllContent;
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  protected String generateCreateAllDdl() {
-
-    try {
-      createAllContent = currentModel().getCreateDdl();
-      return createAllContent;
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  protected String getDropFileName() {
-    return server.getName() + "-drop-all.sql";
-  }
-
-  protected String getCreateFileName() {
-    return server.getName() + "-create-all.sql";
-  }
-
-  protected CurrentModel currentModel() {
-    if (currentModel == null) {
-      currentModel = new CurrentModel(server);
-    }
-    return currentModel;
-  }
-
-  protected void writeFile(String fileName, String fileContent) throws IOException {
-
-    File f = new File(fileName);
-
-    FileWriter fw = new FileWriter(f);
-    try {
-      fw.write(fileContent);
-      fw.flush();
-    } finally {
-      fw.close();
-    }
-  }
-
-  protected String readFile(String fileName) throws IOException {
-
-    File f = new File(fileName);
-    if (!f.exists()) {
-      return null;
-    }
-
-    return readContent(new FileReader(f));
-  }
-
-  protected String readContent(Reader reader) throws IOException {
-
-    StringBuilder buf = new StringBuilder();
-
-    LineNumberReader lineReader = new LineNumberReader(reader);
-    try {
-      String s;
-      while ((s = lineReader.readLine()) != null) {
-        buf.append(s).append("\n");
-      }
-      return buf.toString();
-
-    } finally {
-      lineReader.close();
-    }
-  }
-
-}
@@ -1,116 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration;
-
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.BaseTableDdl;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.PlatformDdl;
-import com.avaje.ebean.dbmigration.migration.AddColumn;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.AddTableComment;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.ChangeSet;
-import com.avaje.ebean.dbmigration.migration.CreateIndex;
-import com.avaje.ebean.dbmigration.migration.CreateTable;
-import com.avaje.ebean.dbmigration.migration.DropColumn;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.migration.DropIndex;
-import com.avaje.ebean.dbmigration.migration.DropTable;
-
-import java.io.IOException;
-import java.util.List;
-
-/**
- *
- */
-public class BaseDdlHandler implements DdlHandler {
-
-  protected final TableDdl tableDdl;
-
-  public BaseDdlHandler(ServerConfig serverConfig, PlatformDdl platformDdl) {
-    this.tableDdl = new BaseTableDdl(serverConfig, platformDdl);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, ChangeSet changeSet) throws IOException {
-
-    List<Object> changeSetChildren = changeSet.getChangeSetChildren();
-    for (Object change : changeSetChildren) {
-      if (change instanceof CreateTable) {
-        generate(writer, (CreateTable) change);
-      } else if (change instanceof DropTable) {
-        generate(writer, (DropTable) change);
-      } else if (change instanceof AddTableComment) {
-        generate(writer, (AddTableComment) change);
-      } else if (change instanceof CreateIndex) {
-        generate(writer, (CreateIndex) change);
-      } else if (change instanceof DropIndex) {
-        generate(writer, (DropIndex) change);
-      } else if (change instanceof AddColumn) {
-        generate(writer, (AddColumn) change);
-      } else if (change instanceof DropColumn) {
-        generate(writer, (DropColumn) change);
-      } else if (change instanceof AlterColumn) {
-        generate(writer, (AlterColumn) change);
-      } else if (change instanceof AddHistoryTable) {
-        generate(writer, (AddHistoryTable) change);
-      } else if (change instanceof DropHistoryTable) {
-        generate(writer, (DropHistoryTable) change);
-      }
-    }
-  }
-
-  @Override
-  public void generateExtra(DdlWrite write) throws IOException {
-    tableDdl.generateExtra(write);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, CreateTable createTable) throws IOException {
-    tableDdl.generate(writer, createTable);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, DropTable dropTable) throws IOException {
-    tableDdl.generate(writer, dropTable);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, AddTableComment addTableComment) throws IOException {
-    tableDdl.generate(writer, addTableComment);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, AddColumn addColumn) throws IOException {
-    tableDdl.generate(writer, addColumn);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, DropColumn dropColumn) throws IOException {
-    tableDdl.generate(writer, dropColumn);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, AlterColumn alterColumn) throws IOException {
-    tableDdl.generate(writer, alterColumn);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException {
-    tableDdl.generate(writer, addHistoryTable);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException {
-    tableDdl.generate(writer, dropHistoryTable);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, CreateIndex createIndex) throws IOException {
-    tableDdl.generate(writer, createIndex);
-  }
-
-  @Override
-  public void generate(DdlWrite writer, DropIndex dropIndex) throws IOException {
-    tableDdl.generate(writer, dropIndex);
-  }
-
-}
@@ -1,28 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration;
-
-import com.avaje.ebean.dbmigration.migration.AddColumn;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.DropColumn;
-
-import java.io.IOException;
-
-/**
- * Write DDL for AddColumn , DropColumn or AlterColumn.
- */
-public interface ColumnDdl {
-
-  /**
-   * Write the add column change.
-   */
-  void generate(DdlWrite writer, AddColumn addColumn) throws IOException;
-
-  /**
-   * Write the drop column change.
-   */
-  void generate(DdlWrite writer, DropColumn dropColumn) throws IOException;
-
-  /**
-   * Write the alter column changes.
-   */
-  void generate(DdlWrite writer, AlterColumn alterColumn) throws IOException;
-}
@@ -1,45 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration;
-
-import com.avaje.ebean.dbmigration.migration.AddColumn;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.AddTableComment;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.ChangeSet;
-import com.avaje.ebean.dbmigration.migration.CreateIndex;
-import com.avaje.ebean.dbmigration.migration.CreateTable;
-import com.avaje.ebean.dbmigration.migration.DropColumn;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.migration.DropIndex;
-import com.avaje.ebean.dbmigration.migration.DropTable;
-
-import java.io.IOException;
-
-/**
- * DDL generation interface.
- */
-public interface DdlHandler {
-
-  void generate(DdlWrite writer, ChangeSet changeSet) throws IOException;
-
-  void generate(DdlWrite writer, CreateTable createTable) throws IOException;
-
-  void generate(DdlWrite writer, DropTable dropTable) throws IOException;
-
-  void generate(DdlWrite writer, AddTableComment addTableComment) throws IOException;
-
-  void generate(DdlWrite writer, AddColumn addColumn) throws IOException;
-
-  void generate(DdlWrite writer, DropColumn dropColumn) throws IOException;
-
-  void generate(DdlWrite writer, AlterColumn alterColumn) throws IOException;
-
-  void generate(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException;
-
-  void generate(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException;
-
-  void generate(DdlWrite writer, CreateIndex createIndex) throws IOException;
-
-  void generate(DdlWrite writer, DropIndex dropIndex) throws IOException;
-
-  void generateExtra(DdlWrite write) throws IOException;
-}
@@ -1,113 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration;
-
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.BaseDdlBuffer;
-import com.avaje.ebean.dbmigration.model.MConfiguration;
-import com.avaje.ebean.dbmigration.model.MTable;
-import com.avaje.ebean.dbmigration.model.ModelContainer;
-
-/**
- * Write context holding the buffers for both apply and rollback DDL.
- */
-public class DdlWrite {
-
-  private final ModelContainer currentModel;
-
-  private final DdlBuffer applyDropDependencies;
-
-  private final DdlBuffer apply;
-
-  private final DdlBuffer applyForeignKeys;
-
-  private final DdlBuffer applyHistory;
-
-  private final DdlBuffer dropAllForeignKeys;
-
-  private final DdlBuffer dropAll;
-
-  /**
-   * Create without any configuration or current model (no history support).
-   */
-  public DdlWrite() {
-    this(new MConfiguration(), new ModelContainer());
-  }
-
-  /**
-   * Create with a configuration.
-   */
-  public DdlWrite(MConfiguration configuration, ModelContainer currentModel) {
-    this.currentModel = currentModel;
-    this.applyDropDependencies = new BaseDdlBuffer(configuration);
-    this.apply = new BaseDdlBuffer(configuration);
-    this.applyForeignKeys = new BaseDdlBuffer(configuration);
-    this.applyHistory = new BaseDdlBuffer(configuration);
-    this.dropAllForeignKeys = new BaseDdlBuffer(configuration);
-    this.dropAll = new BaseDdlBuffer(configuration);
-  }
-
-  /**
-   * Return the Table information from the current model.
-   * <p>
-   * This is typically required for the history support (used to determine the list of columns
-   * included in the history when creating or recreating the associated trigger/stored procedure).
-   * </p>
-   */
-  public MTable getTable(String tableName) {
-    return currentModel.getTable(tableName);
-  }
-
-  /**
-   * Return true if the apply buffers are all empty.
-   */
-  public boolean isApplyEmpty() {
-    return apply.getBuffer().isEmpty()
-      && applyForeignKeys.getBuffer().isEmpty()
-      && applyHistory.getBuffer().isEmpty()
-      && applyDropDependencies.getBuffer().isEmpty();
-  }
-
-  /**
-   * Return the buffer that APPLY DDL is written to.
-   */
-  public DdlBuffer apply() {
-    return apply;
-  }
-
-  /**
-   * Return the buffer that executes early to drop dependencies like views etc.
-   */
-  public DdlBuffer applyDropDependencies() {
-    return applyDropDependencies;
-  }
-
-  /**
-   * Return the buffer that APPLY DDL is written to for foreign keys and their associated indexes.
-   * <p>
-   * Statements added to this buffer are executed after all the normal apply statements and
-   * typically 'add foreign key' is added to this buffer.
-   */
-  public DdlBuffer applyForeignKeys() {
-    return applyForeignKeys;
-  }
-
-  /**
-   * Return the buffer that apply history DDL is written to.
-   */
-  public DdlBuffer applyHistory() {
-    return applyHistory;
-  }
-
-  /**
-   * Return the buffer used for the 'drop all DDL' for dropping foreign keys and associated indexes.
-   */
-  public DdlBuffer dropAllForeignKeys() {
-    return dropAllForeignKeys;
-  }
-
-  /**
-   * Return the buffer used for the 'drop all DDL' to drop tables, views and history triggers etc.
-   */
-  public DdlBuffer dropAll() {
-    return dropAll;
-  }
-
-}
@@ -1,75 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration;
-
-import com.avaje.ebean.dbmigration.migration.AddColumn;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.AddTableComment;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.CreateIndex;
-import com.avaje.ebean.dbmigration.migration.CreateTable;
-import com.avaje.ebean.dbmigration.migration.DropColumn;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.migration.DropIndex;
-import com.avaje.ebean.dbmigration.migration.DropTable;
-
-import java.io.IOException;
-
-/**
- * Write table DDL.
- */
-public interface TableDdl {
-
-  /**
-   * Generate the create table change.
-   */
-  void generate(DdlWrite writer, CreateTable createTable) throws IOException;
-
-  /**
-   * Write the drop column change.
-   */
-  void generate(DdlWrite writer, DropTable dropTable) throws IOException;
-
-  /**
-   * Write the add column change.
-   */
-  void generate(DdlWrite writer, AddColumn addColumn) throws IOException;
-
-  /**
-   * Write the alter column changes.
-   */
-  void generate(DdlWrite writer, AlterColumn alterColumn) throws IOException;
-
-  /**
-   * Write the drop column change.
-   */
-  void generate(DdlWrite writer, DropColumn dropColumn) throws IOException;
-
-  /**
-   * Write the AddTableComment change.
-   */
-  void generate(DdlWrite writer, AddTableComment addTableComment) throws IOException;
-
-  /**
-   * Write the AddHistoryTable change.
-   */
-  void generate(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException;
-
-  /**
-   * Write the DropHistoryTable change.
-   */
-  void generate(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException;
-
-  /**
-   * Generate the create index change.
-   */
-  void generate(DdlWrite writer, CreateIndex createIndex) throws IOException;
-
-  /**
-   * Write the drop index change.
-   */
-  void generate(DdlWrite writer, DropIndex dropIndex) throws IOException;
-
-  /**
-   * Generate any extra DDL such as regeneration of history triggers.
-   */
-  void generateExtra(DdlWrite write) throws IOException;
-}
@@ -1,881 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.DbConstraintNaming;
-import com.avaje.ebean.config.NamingConvention;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.config.dbplatform.IdType;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
-import com.avaje.ebean.dbmigration.ddlgeneration.TableDdl;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.util.IndexSet;
-import com.avaje.ebean.dbmigration.migration.AddColumn;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.AddTableComment;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.Column;
-import com.avaje.ebean.dbmigration.migration.CreateIndex;
-import com.avaje.ebean.dbmigration.migration.CreateTable;
-import com.avaje.ebean.dbmigration.migration.DropColumn;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.migration.DropIndex;
-import com.avaje.ebean.dbmigration.migration.DropTable;
-import com.avaje.ebean.dbmigration.migration.ForeignKey;
-import com.avaje.ebean.dbmigration.migration.UniqueConstraint;
-import com.avaje.ebean.dbmigration.model.MTable;
-import com.avaje.ebean.util.StringHelper;
-
-import java.io.IOException;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Base implementation for 'create table' and 'alter table' statements.
- */
-public class BaseTableDdl implements TableDdl {
-
-  protected final DbConstraintNaming naming;
-
-  protected final NamingConvention namingConvention;
-
-  protected final PlatformDdl platformDdl;
-
-  protected final String historyTableSuffix;
-
-  /**
-   * Used to check that indexes on foreign keys should be skipped as a unique index on the columns
-   * already exists.
-   */
-  protected IndexSet indexSet = new IndexSet();
-
-  /**
-   * Used when unique constraints specifically for OneToOne can't be created normally (MsSqlServer).
-   */
-  protected List<Column> externalUnique = new ArrayList<>();
-
-  // counters used when constraint names are truncated due to maximum length
-  // and these counters are used to keep the constraint name unique
-  protected int countCheck;
-  protected int countUnique;
-  protected int countForeignKey;
-  protected int countIndex;
-
-  /**
-   * Base tables that have associated history tables that need their triggers/functions regenerated as
-   * columns have been added, removed, included or excluded.
-   */
-  protected Map<String, HistoryTableUpdate> regenerateHistoryTriggers = new LinkedHashMap<>();
-
-  /**
-   * Construct with a naming convention and platform specific DDL.
-   */
-  public BaseTableDdl(ServerConfig serverConfig, PlatformDdl platformDdl) {
-    this.namingConvention = serverConfig.getNamingConvention();
-    this.naming = serverConfig.getConstraintNaming();
-    this.historyTableSuffix = serverConfig.getHistoryTableSuffix();
-    this.platformDdl = platformDdl;
-    this.platformDdl.configure(serverConfig);
-  }
-
-  /**
-   * Reset counters and index set for each table processed.
-   */
-  protected void reset() {
-    indexSet.clear();
-    externalUnique.clear();
-    countCheck = 0;
-    countUnique = 0;
-    countForeignKey = 0;
-    countIndex = 0;
-  }
-
-  /**
-   * Generate the appropriate 'create table' and matching 'drop table' statements
-   * and add them to the appropriate 'apply' and 'rollback' buffers.
-   */
-  @Override
-  public void generate(DdlWrite writer, CreateTable createTable) throws IOException {
-
-    reset();
-
-    String tableName = lowerTableName(createTable.getName());
-    List<Column> columns = createTable.getColumn();
-    List<Column> pk = determinePrimaryKeyColumns(columns);
-
-    boolean singleColumnPrimaryKey = (pk.size() == 1);
-    boolean useIdentity = false;
-    boolean useSequence = false;
-
-    if (singleColumnPrimaryKey) {
-      IdType useDbIdentityType = platformDdl.useIdentityType(createTable.getIdentityType());
-      useIdentity = (IdType.IDENTITY == useDbIdentityType);
-      useSequence = (IdType.SEQUENCE == useDbIdentityType);
-    }
-
-    DdlBuffer apply = writer.apply();
-    apply.append("create table ").append(tableName).append(" (");
-    writeTableColumns(apply, columns, useIdentity);
-    writeCheckConstraints(apply, createTable);
-    writeUniqueConstraints(apply, createTable);
-    writeCompoundUniqueConstraints(apply, createTable);
-    if (!pk.isEmpty()) {
-      // defined on the columns
-      writePrimaryKeyConstraint(apply, createTable.getPkName(), toColumnNames(pk));
-    }
-    if (platformDdl.isInlineForeignKeys()) {
-      writeInlineForeignKeys(writer, createTable);
-    }
-
-    apply.newLine().append(")");
-    addTableCommentInline(apply, createTable);
-    apply.endOfStatement();
-
-    addComments(apply, createTable);
-
-    writeUniqueOneToOneConstraints(writer, createTable);
-
-    if (isTrue(createTable.isWithHistory())) {
-      // create history with rollback before the
-      // associated drop table is written to rollback
-      createWithHistory(writer, createTable.getName());
-    }
-
-    // add drop table to the rollback buffer - do this before
-    // we drop the related sequence (if sequences are used)
-    dropTable(writer.dropAll(), tableName);
-
-    if (useSequence) {
-      String pkCol = pk.get(0).getName();
-      writeSequence(writer, createTable, pkCol);
-    }
-
-    // add blank line for a bit of whitespace between tables
-    apply.end();
-    writer.dropAll().end();
-
-    if (!platformDdl.isInlineForeignKeys()) {
-      writeAddForeignKeys(writer, createTable);
-    }
-  }
-
-  /**
-   * Add table and column comments (separate from the create table statement).
-   */
-  private void addComments(DdlBuffer apply, CreateTable createTable) throws IOException {
-    if (!platformDdl.isInlineComments()) {
-      String tableComment = createTable.getComment();
-      if (!StringHelper.isNull(tableComment)) {
-        platformDdl.addTableComment(apply, createTable.getName(), tableComment);
-      }
-
-      List<Column> columns = createTable.getColumn();
-      for (Column column : columns) {
-        if (!StringHelper.isNull(column.getComment())) {
-          platformDdl.addColumnComment(apply, createTable.getName(), column.getName(), column.getComment());
-        }
-      }
-    }
-  }
-
-  /**
-   * Add the table comment inline with the create table statement.
-   */
-  private void addTableCommentInline(DdlBuffer apply, CreateTable createTable) throws IOException {
-    if (platformDdl.isInlineComments()) {
-      String tableComment = createTable.getComment();
-      if (!StringHelper.isNull(tableComment)) {
-        platformDdl.inlineTableComment(apply, tableComment);
-      }
-    }
-  }
-
-  private void writeTableColumns(DdlBuffer apply, List<Column> columns, boolean useIdentity) throws IOException {
-    platformDdl.writeTableColumns(apply, columns, useIdentity);
-  }
-
-  /**
-   * Specific handling of OneToOne unique constraints for MsSqlServer.
-   * For all other DB platforms these unique constraints are done inline as per normal.
-   */
-  protected void writeUniqueOneToOneConstraints(DdlWrite write, CreateTable createTable) throws IOException {
-
-    String tableName = createTable.getName();
-    for (Column col : externalUnique) {
-      String uqName = col.getUniqueOneToOne();
-      String[] columnNames = {col.getName()};
-      write.apply()
-        .append(platformDdl.alterTableAddUniqueConstraint(tableName, uqName, columnNames))
-        .endOfStatement();
-
-      write.dropAllForeignKeys()
-        .append(platformDdl.dropIndex(uqName, tableName))
-        .endOfStatement();
-    }
-  }
-
-  protected void writeSequence(DdlWrite writer, CreateTable createTable, String pk) throws IOException {
-
-    // explicit sequence use or platform decides
-    String explicitSequenceName = createTable.getSequenceName();
-    int initial = toInt(createTable.getSequenceInitial());
-    int allocate = toInt(createTable.getSequenceAllocate());
-
-    String seqName = explicitSequenceName;
-    if (seqName == null) {
-      seqName = namingConvention.getSequenceName(createTable.getName(), pk);
-    }
-
-    String createSeq = platformDdl.createSequence(seqName, initial, allocate);
-    if (createSeq != null) {
-      writer.apply().append(createSeq).newLine();
-      writer.dropAll().append(platformDdl.dropSequence(seqName)).endOfStatement();
-    }
-  }
-
-  protected void createWithHistory(DdlWrite writer, String name) throws IOException {
-
-    MTable table = writer.getTable(name);
-    platformDdl.createWithHistory(writer, table);
-  }
-
-  protected void writeInlineForeignKeys(DdlWrite write, CreateTable createTable) throws IOException {
-
-    for (Column column : createTable.getColumn()) {
-      String references = column.getReferences();
-      if (hasValue(references)) {
-        writeInlineForeignKey(write, column);
-      }
-    }
-    writeInlineCompoundForeignKeys(write, createTable);
-  }
-
-  protected void writeInlineForeignKey(DdlWrite write, Column column) throws IOException {
-
-    String references = column.getReferences();
-    int pos = references.lastIndexOf('.');
-    if (pos == -1) {
-      throw new IllegalStateException("Expecting period '.' character for table.column split but not found in [" + references + "]");
-    }
-    String refTableName = references.substring(0, pos);
-    String refColumnName = references.substring(pos + 1);
-    String fkConstraint = platformDdl.tableInlineForeignKey(new String[]{column.getName()}, refTableName, new String[]{refColumnName});
-    write.apply().append(",").newLine().append("  ").append(fkConstraint);
-  }
-
-  protected void writeInlineCompoundForeignKeys(DdlWrite write, CreateTable createTable) throws IOException {
-
-    List<ForeignKey> foreignKey = createTable.getForeignKey();
-    for (ForeignKey key : foreignKey) {
-      String refTableName = key.getRefTableName();
-      String[] cols = toColumnNamesSplit(key.getColumnNames());
-      String[] refColumns = toColumnNamesSplit(key.getRefColumnNames());
-
-      String fkConstraint = platformDdl.tableInlineForeignKey(cols, refTableName, refColumns);
-      write.apply().append(",").newLine().append("  ").append(fkConstraint);
-    }
-  }
-
-  protected void writeAddForeignKeys(DdlWrite write, CreateTable createTable) throws IOException {
-
-    String tableName = createTable.getName();
-    List<Column> columns = createTable.getColumn();
-    for (Column column : columns) {
-      String references = column.getReferences();
-      if (hasValue(references)) {
-        writeForeignKey(write, tableName, column);
-      }
-    }
-
-    writeAddCompoundForeignKeys(write, createTable);
-  }
-
-  protected void writeAddCompoundForeignKeys(DdlWrite write, CreateTable createTable) throws IOException {
-
-    String tableName = createTable.getName();
-
-    List<ForeignKey> foreignKey = createTable.getForeignKey();
-    for (ForeignKey key : foreignKey) {
-
-      String refTableName = key.getRefTableName();
-      String fkName = key.getName();
-      String[] cols = toColumnNamesSplit(key.getColumnNames());
-      String[] refColumns = toColumnNamesSplit(key.getRefColumnNames());
-
-      writeForeignKey(write, fkName, tableName, cols, refTableName, refColumns, key.getIndexName());
-    }
-  }
-
-  protected void writeForeignKey(DdlWrite write, String tableName, Column column) throws IOException {
-
-    String fkName = column.getForeignKeyName();
-    String references = column.getReferences();
-    int pos = references.lastIndexOf('.');
-    if (pos == -1) {
-      throw new IllegalStateException("Expecting period '.' character for table.column split but not found in [" + references + "]");
-    }
-    String refTableName = references.substring(0, pos);
-    String refColumnName = references.substring(pos + 1);
-
-    String[] cols = {column.getName()};
-    String[] refCols = {refColumnName};
-
-    writeForeignKey(write, fkName, tableName, cols, refTableName, refCols, column.getForeignKeyIndex());
-  }
-
-  protected void writeForeignKey(DdlWrite write, String fkName, String tableName, String[] columns, String refTable, String[] refColumns, String indexName) throws IOException {
-
-    tableName = lowerTableName(tableName);
-    DdlBuffer fkeyBuffer = write.applyForeignKeys();
-    alterTableAddForeignKey(fkeyBuffer, fkName, tableName, columns, refTable, refColumns);
-
-    if (indexName != null) {
-      // no matching unique constraint so add the index
-      fkeyBuffer.append(platformDdl.createIndex(indexName, tableName, columns)).endOfStatement();
-    }
-
-    fkeyBuffer.end();
-
-    write.dropAllForeignKeys()
-      .append(platformDdl.alterTableDropForeignKey(tableName, fkName)).endOfStatement();
-
-    if (indexName != null) {
-      write.dropAllForeignKeys()
-        .append(platformDdl.dropIndex(indexName, tableName)).endOfStatement();
-    }
-
-    write.dropAllForeignKeys().end();
-
-  }
-
-  protected void alterTableAddForeignKey(DdlBuffer buffer, String fkName, String tableName, String[] columns, String refTable, String[] refColumns) throws IOException {
-
-    String fkConstraint = platformDdl.alterTableAddForeignKey(tableName, fkName, columns, refTable, refColumns);
-    if (fkConstraint != null && !fkConstraint.isEmpty()) {
-      buffer.append(fkConstraint).endOfStatement();
-    }
-  }
-
-  protected void appendColumns(String[] columns, DdlBuffer buffer) throws IOException {
-    buffer.append(" (");
-    for (int i = 0; i < columns.length; i++) {
-      if (i > 0) {
-        buffer.append(",");
-      }
-      buffer.append(lowerColumnName(columns[i].trim()));
-    }
-    buffer.append(")");
-  }
-
-
-  /**
-   * Add 'drop table' statement to the buffer.
-   */
-  protected void dropTable(DdlBuffer buffer, String tableName) throws IOException {
-
-    buffer.append(platformDdl.dropTable(tableName)).endOfStatement();
-  }
-
-  /**
-   * Write all the check constraints.
-   */
-  protected void writeCheckConstraints(DdlBuffer apply, CreateTable createTable) throws IOException {
-
-    List<Column> columns = createTable.getColumn();
-    for (Column column : columns) {
-      String checkConstraint = column.getCheckConstraint();
-      if (hasValue(checkConstraint)) {
-        writeCheckConstraint(apply, column, checkConstraint);
-      }
-    }
-  }
-
-  /**
-   * Write a check constraint.
-   */
-  protected void writeCheckConstraint(DdlBuffer buffer, Column column, String checkConstraint) throws IOException {
-
-    String ckName = column.getCheckConstraintName();
-
-    buffer.append(",").newLine();
-    buffer.append("  constraint ").append(ckName);
-    buffer.append(" ").append(checkConstraint);
-  }
-
-  protected void writeCompoundUniqueConstraints(DdlBuffer apply, CreateTable createTable) throws IOException {
-
-    List<UniqueConstraint> uniqueConstraints = createTable.getUniqueConstraint();
-    for (UniqueConstraint uniqueConstraint : uniqueConstraints) {
-      String uqName = uniqueConstraint.getName();
-      String[] columns = toColumnNamesSplit(uniqueConstraint.getColumnNames());
-      apply.append(",").newLine();
-      apply.append("  constraint ").append(uqName).append(" unique");
-      appendColumns(columns, apply);
-    }
-  }
-
-  /**
-   * Write the unique constraints inline with the create table statement.
-   */
-  protected void writeUniqueConstraints(DdlBuffer apply, CreateTable createTable) throws IOException {
-
-    boolean inlineUniqueOneToOne = platformDdl.isInlineUniqueOneToOne();
-
-    List<Column> columns = createTable.getColumn();
-    for (Column column : columns) {
-      if (hasValue(column.getUnique()) || (inlineUniqueOneToOne && hasValue(column.getUniqueOneToOne()))) {
-        // normal mechanism for adding unique constraint
-        inlineUniqueConstraintSingle(apply, column);
-
-      } else if (!inlineUniqueOneToOne && hasValue(column.getUniqueOneToOne())) {
-        // MsSqlServer specific mechanism for adding unique constraints (that allow nulls)
-        externalUnique.add(column);
-      }
-    }
-  }
-
-  /**
-   * Write the unique constraint inline with the create table statement.
-   */
-  protected void inlineUniqueConstraintSingle(DdlBuffer buffer, Column column) throws IOException {
-
-    String uqName = column.getUnique();
-    if (uqName == null) {
-      uqName = column.getUniqueOneToOne();
-    }
-
-    buffer.append(",").newLine();
-    buffer.append("  constraint ").append(uqName).append(" unique ");
-    buffer.append("(");
-    buffer.append(lowerColumnName(column.getName()));
-    buffer.append(")");
-  }
-
-  /**
-   * Write the primary key constraint inline with the create table statement.
-   */
-  protected void writePrimaryKeyConstraint(DdlBuffer buffer, String pkName, String[] pkColumns) throws IOException {
-
-    buffer.append(",").newLine();
-    buffer.append("  constraint ").append(pkName).append(" primary key");
-    appendColumns(pkColumns, buffer);
-  }
-
-  /**
-   * Return as an array of string column names.
-   */
-  protected String[] toColumnNames(List<Column> columns) {
-
-    String[] cols = new String[columns.size()];
-    for (int i = 0; i < cols.length; i++) {
-      cols[i] = columns.get(i).getName();
-    }
-    return cols;
-  }
-
-  /**
-   * Return as an array of string column names.
-   */
-  protected String[] toColumnNamesSplit(String columns) {
-    return columns.split(",");
-  }
-
-  /**
-   * Convert the table lower case.
-   */
-  protected String lowerTableName(String name) {
-    return naming.lowerTableName(name);
-  }
-
-  /**
-   * Convert the column name to lower case.
-   */
-  protected String lowerColumnName(String name) {
-    return naming.lowerColumnName(name);
-  }
-
-  /**
-   * Return the list of columns that make the primary key.
-   */
-  protected List<Column> determinePrimaryKeyColumns(List<Column> columns) {
-    List<Column> pk = new ArrayList<>(3);
-    for (Column column : columns) {
-      if (isTrue(column.isPrimaryKey())) {
-        pk.add(column);
-      }
-    }
-    return pk;
-  }
-
-  @Override
-  public void generate(DdlWrite writer, CreateIndex createIndex) throws IOException {
-
-    String[] cols = toColumnNamesSplit(createIndex.getColumns());
-    writer.apply()
-      .append(platformDdl.createIndex(createIndex.getIndexName(), createIndex.getTableName(), cols))
-      .endOfStatement();
-
-    writer.dropAll()
-      .append(platformDdl.dropIndex(createIndex.getIndexName(), createIndex.getTableName()))
-      .endOfStatement();
-  }
-
-  @Override
-  public void generate(DdlWrite writer, DropIndex dropIndex) throws IOException {
-
-    writer.apply()
-      .append(platformDdl.dropIndex(dropIndex.getIndexName(), dropIndex.getTableName()))
-      .endOfStatement();
-  }
-
-  /**
-   * Add add history table DDL.
-   */
-  @Override
-  public void generate(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException {
-    platformDdl.addHistoryTable(writer, addHistoryTable);
-  }
-
-  /**
-   * Add drop history table DDL.
-   */
-  @Override
-  public void generate(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException {
-    platformDdl.dropHistoryTable(writer, dropHistoryTable);
-  }
-
-  /**
-   * Called at the end to generate additional ddl such as regenerate history triggers.
-   */
-  @Override
-  public void generateExtra(DdlWrite write) throws IOException {
-    for (HistoryTableUpdate update : this.regenerateHistoryTriggers.values()) {
-      platformDdl.regenerateHistoryTriggers(write, update);
-    }
-  }
-
-  @Override
-  public void generate(DdlWrite writer, AddTableComment addTableComment) throws IOException {
-    if (hasValue(addTableComment.getComment())) {
-      platformDdl.addTableComment(writer.apply(), addTableComment.getName(), addTableComment.getComment());
-    }
-  }
-
-  /**
-   * Add add column DDL.
-   */
-  @Override
-  public void generate(DdlWrite writer, AddColumn addColumn) throws IOException {
-
-    String tableName = addColumn.getTableName();
-    List<Column> columns = addColumn.getColumn();
-    for (Column column : columns) {
-      alterTableAddColumn(writer.apply(), tableName, column, false);
-    }
-
-    if (isTrue(addColumn.isWithHistory())) {
-      // make same changes to the history table
-      String historyTable = historyTable(tableName);
-      for (Column column : columns) {
-        regenerateHistoryTriggers(tableName, HistoryTableUpdate.Change.ADD, column.getName());
-        alterTableAddColumn(writer.apply(), historyTable, column, true);
-      }
-    }
-
-    for (Column column : columns) {
-      if (hasValue(column.getReferences())) {
-        writeForeignKey(writer, tableName, column);
-      }
-    }
-
-    // add a bit of whitespace
-    writer.apply().end();
-  }
-
-  /**
-   * Add drop table DDL.
-   */
-  @Override
-  public void generate(DdlWrite writer, DropTable dropTable) throws IOException {
-
-    dropTable(writer.apply(), dropTable.getName());
-  }
-
-  /**
-   * Add drop column DDL.
-   */
-  @Override
-  public void generate(DdlWrite writer, DropColumn dropColumn) throws IOException {
-
-    String tableName = dropColumn.getTableName();
-
-    alterTableDropColumn(writer.apply(), tableName, dropColumn.getColumnName());
-    if (isTrue(dropColumn.isWithHistory())) {
-      // also drop from the history table
-      regenerateHistoryTriggers(tableName, HistoryTableUpdate.Change.DROP, dropColumn.getColumnName());
-      alterTableDropColumn(writer.apply(), historyTable(tableName), dropColumn.getColumnName());
-    }
-
-    writer.apply().end();
-  }
-
-  /**
-   * Add all the appropriate changes based on the column changes.
-   */
-  @Override
-  public void generate(DdlWrite writer, AlterColumn alterColumn) throws IOException {
-
-    if (isTrue(alterColumn.isHistoryExclude())) {
-      regenerateHistoryTriggers(alterColumn.getTableName(), HistoryTableUpdate.Change.EXCLUDE, alterColumn.getColumnName());
-    } else if (isFalse(alterColumn.isHistoryExclude())) {
-      regenerateHistoryTriggers(alterColumn.getTableName(), HistoryTableUpdate.Change.INCLUDE, alterColumn.getColumnName());
-    }
-
-    if (hasValue(alterColumn.getDropForeignKey())) {
-      alterColumnDropForeignKey(writer, alterColumn);
-    }
-    if (hasValue(alterColumn.getReferences())) {
-      alterColumnAddForeignKey(writer, alterColumn);
-    }
-
-    if (hasValue(alterColumn.getDropUnique())) {
-      alterColumnDropUniqueConstraint(writer, alterColumn);
-    }
-    if (hasValue(alterColumn.getUnique())) {
-      alterColumnAddUniqueConstraint(writer, alterColumn);
-    }
-    if (hasValue(alterColumn.getUniqueOneToOne())) {
-      alterColumnAddUniqueOneToOneConstraint(writer, alterColumn);
-    }
-    if (hasValue(alterColumn.getComment())) {
-      alterColumnComment(writer, alterColumn);
-    }
-
-    boolean alterCheckConstraint = hasValue(alterColumn.getCheckConstraint());
-
-    if (alterCheckConstraint) {
-      // drop constraint before altering type etc
-      dropCheckConstraint(writer, alterColumn);
-    }
-    boolean alterBaseAttributes = false;
-    if (hasValue(alterColumn.getType())) {
-      alterColumnType(writer, alterColumn);
-      alterBaseAttributes = true;
-    }
-    if (hasValue(alterColumn.getDefaultValue())) {
-      alterColumnDefaultValue(writer, alterColumn);
-      alterBaseAttributes = true;
-    }
-    if (alterColumn.isNotnull() != null) {
-      alterColumnNotnull(writer, alterColumn);
-      alterBaseAttributes = true;
-    }
-    if (alterBaseAttributes) {
-      alterColumnBaseAttributes(writer, alterColumn);
-    }
-    if (alterCheckConstraint) {
-      // add constraint last (after potential type change)
-      addCheckConstraint(writer, alterColumn);
-    }
-  }
-
-  private void alterColumnComment(DdlWrite writer, AlterColumn alterColumn) throws IOException {
-    platformDdl.addColumnComment(writer.apply(), alterColumn.getTableName(), alterColumn.getColumnName(), alterColumn.getComment());
-  }
-
-  /**
-   * Return the name of the history table given the base table name.
-   */
-  protected String historyTable(String baseTable) {
-    return baseTable + historyTableSuffix;
-  }
-
-  /**
-   * Register the base table that we need to regenerate the history triggers on.
-   */
-  protected void regenerateHistoryTriggers(String baseTableName, HistoryTableUpdate.Change change, String column) {
-
-    HistoryTableUpdate update = regenerateHistoryTriggers.get(baseTableName);
-    if (update == null) {
-      update = new HistoryTableUpdate(baseTableName);
-      regenerateHistoryTriggers.put(baseTableName, update);
-    }
-    update.add(change, column);
-  }
-
-  /**
-   * This is mysql specific - alter all the base attributes of the column together.
-   */
-  protected void alterColumnBaseAttributes(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    String ddl = platformDdl.alterColumnBaseAttributes(alter);
-    if (hasValue(ddl)) {
-      writer.apply().append(ddl).endOfStatement();
-
-      if (isTrue(alter.isWithHistory()) && alter.getType() != null) {
-        // mysql and sql server column type change allowing nulls in the history table column
-        AlterColumn alterHistoryColumn = new AlterColumn();
-        alterHistoryColumn.setTableName(historyTable(alter.getTableName()));
-        alterHistoryColumn.setColumnName(alter.getColumnName());
-        alterHistoryColumn.setType(alter.getType());
-        String histColumnDdl = platformDdl.alterColumnBaseAttributes(alterHistoryColumn);
-
-        // write the apply to history table
-        writer.apply().append(histColumnDdl).endOfStatement();
-      }
-    }
-  }
-
-  protected void alterColumnDefaultValue(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    String ddl = platformDdl.alterColumnDefaultValue(alter.getTableName(), alter.getColumnName(), alter.getDefaultValue());
-    if (hasValue(ddl)) {
-      writer.apply().append(ddl).endOfStatement();
-    }
-  }
-
-  protected void dropCheckConstraint(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    String ddl = platformDdl.alterTableDropConstraint(alter.getTableName(), alter.getCheckConstraintName());
-    if (hasValue(ddl)) {
-      writer.apply().append(ddl).endOfStatement();
-    }
-  }
-
-  protected void addCheckConstraint(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    String ddl = platformDdl.alterTableAddCheckConstraint(alter.getTableName(), alter.getCheckConstraintName(), alter.getCheckConstraint());
-    if (hasValue(ddl)) {
-      writer.apply().append(ddl).endOfStatement();
-    }
-  }
-
-  protected void alterColumnNotnull(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    String ddl = platformDdl.alterColumnNotnull(alter.getTableName(), alter.getColumnName(), alter.isNotnull());
-    if (hasValue(ddl)) {
-      writer.apply().append(ddl).endOfStatement();
-    }
-  }
-
-  protected void alterColumnType(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    String ddl = platformDdl.alterColumnType(alter.getTableName(), alter.getColumnName(), alter.getType());
-    if (hasValue(ddl)) {
-      writer.apply().append(ddl).endOfStatement();
-      if (isTrue(alter.isWithHistory())) {
-        // apply same type change to matching column in the history table
-        ddl = platformDdl.alterColumnType(historyTable(alter.getTableName()), alter.getColumnName(), alter.getType());
-        writer.apply().append(ddl).endOfStatement();
-      }
-    }
-  }
-
-
-  protected void alterColumnAddForeignKey(DdlWrite writer, AlterColumn alterColumn) throws IOException {
-
-    String tableName = alterColumn.getTableName();
-    String fkName = alterColumn.getForeignKeyName();
-    String[] cols = {alterColumn.getColumnName()};
-    String references = alterColumn.getReferences();
-    int pos = references.lastIndexOf('.');
-    if (pos == -1) {
-      throw new IllegalStateException("Expecting period '.' character for table.column split but not found in [" + references + "]");
-    }
-    String refTableName = references.substring(0, pos);
-    String refColumnName = references.substring(pos + 1);
-    String[] refCols = {refColumnName};
-
-    alterTableAddForeignKey(writer.apply(), fkName, tableName, cols, refTableName, refCols);
-  }
-
-  protected void alterColumnDropForeignKey(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    writer.apply()
-      .append(platformDdl.alterTableDropForeignKey(alter.getTableName(), alter.getDropForeignKey()))
-      .endOfStatement();
-  }
-
-
-  protected void alterColumnDropUniqueConstraint(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    writer.apply()
-      .append(platformDdl.alterTableDropUniqueConstraint(alter.getTableName(), alter.getDropUnique()))
-      .endOfStatement();
-  }
-
-  protected void alterColumnAddUniqueOneToOneConstraint(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    addUniqueConstraint(writer, alter, alter.getUniqueOneToOne());
-  }
-
-  protected void alterColumnAddUniqueConstraint(DdlWrite writer, AlterColumn alter) throws IOException {
-
-    addUniqueConstraint(writer, alter, alter.getUnique());
-  }
-
-  protected void addUniqueConstraint(DdlWrite writer, AlterColumn alter, String uqName) throws IOException {
-
-    String[] cols = {alter.getColumnName()};
-
-    writer.apply()
-      .append(platformDdl.alterTableAddUniqueConstraint(alter.getTableName(), uqName, cols))
-      .endOfStatement();
-
-    writer.dropAllForeignKeys()
-      .append(platformDdl.dropIndex(uqName, alter.getTableName()))
-      .endOfStatement();
-  }
-
-
-  protected void alterTableDropColumn(DdlBuffer buffer, String tableName, String columnName) throws IOException {
-
-    buffer.append("alter table ").append(tableName).append(" drop column ").append(columnName)
-      .endOfStatement();
-  }
-
-  protected void alterTableAddColumn(DdlBuffer buffer, String tableName, Column column, boolean onHistoryTable) throws IOException {
-
-    String convertedType = platformDdl.convert(column.getType(), false);
-    buffer.append("alter table ").append(tableName)
-      .append(" add column ").append(column.getName())
-      .append(" ").append(convertedType);
-
-    if (!onHistoryTable) {
-      if (isTrue(column.isNotnull())) {
-        buffer.append(" not null");
-      }
-      if (hasValue(column.getCheckConstraint())) {
-        buffer.append(" ").append(column.getCheckConstraint());
-      }
-    }
-    buffer.endOfStatement();
-  }
-
-  protected boolean isFalse(Boolean value) {
-    return value != null && !value;
-  }
-
-  /**
-   * Return true if null or trimmed string is empty.
-   */
-  protected boolean hasValue(String value) {
-    return value != null && !value.trim().isEmpty();
-  }
-
-  /**
-   * Null safe Boolean true test.
-   */
-  protected boolean isTrue(Boolean value) {
-    return Boolean.TRUE.equals(value);
-  }
-
-  /**
-   * Return as an int value with 0 when it is null.
-   */
-  protected int toInt(BigInteger value) {
-    return (value == null) ? 0 : value.intValue();
-  }
-
-}
@@ -1,15 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-
-/**
- * DB2 platform specific DDL.
- */
-public class DB2Ddl extends PlatformDdl {
-
-  public DB2Ddl(DatabasePlatform platform) {
-    super(platform);
-    this.identitySuffix = " generated by default as identity";
-  }
-
-}
@@ -1,63 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
-
-import java.util.List;
-
-/**
- * DB trigger update when a change occurs on a table with history.
- */
-public class DbTriggerUpdate {
-
-  private final String baseTableName;
-
-  private final String historyTableName;
-
-  private final DdlWrite writer;
-
-  private final List<String> columns;
-
-  public DbTriggerUpdate(String baseTableName, String historyTableName, DdlWrite writer, List<String> columns) {
-    this.baseTableName = baseTableName;
-    this.historyTableName = historyTableName;
-    this.writer = writer;
-    this.columns = columns;
-  }
-
-  /**
-   * Return the appropriate buffer for the current mode.
-   */
-  public DdlBuffer historyBuffer() {
-    return writer.applyHistory();
-  }
-
-  /**
-   * Return the appropriate drop dependency buffer for the current mode.
-   */
-  public DdlBuffer dropDependencyBuffer() {
-    return writer.applyDropDependencies();
-  }
-
-  /**
-   * Return the base table name.
-   */
-  public String getBaseTable() {
-    return baseTableName;
-  }
-
-  /**
-   * Return the history table name.
-   */
-  public String getHistoryTable() {
-    return historyTableName;
-  }
-
-  /**
-   * Return the included columns.
-   */
-  public List<String> getColumns() {
-    return columns;
-  }
-
-}
@@ -1,15 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-
-/**
- * H2 platform specific DDL.
- */
-public class H2Ddl extends PlatformDdl {
-
-  public H2Ddl(DatabasePlatform platform) {
-    super(platform);
-    this.historyDdl = new H2HistoryDdl();
-  }
-
-}
@@ -1,15 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-
-/**
- * Hsqldb platform specific DDL.
- */
-public class HsqldbDdl extends PlatformDdl {
-
-  public HsqldbDdl(DatabasePlatform platform) {
-    super(platform);
-    this.identitySuffix = " generated by default as identity (start with 1) ";
-  }
-
-}
@@ -1,105 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-
-import java.io.IOException;
-
-/**
- * MS SQL Server platform specific DDL.
- */
-public class MsSqlServerDdl extends PlatformDdl {
-
-  public MsSqlServerDdl(DatabasePlatform platform) {
-    super(platform);
-    this.identitySuffix = " identity(1,1)";
-    this.foreignKeyRestrict = "";
-    this.inlineUniqueOneToOne = false;
-    this.columnSetDefault = "add default";
-    this.dropConstraintIfExists = "drop constraint";
-  }
-
-  @Override
-  public String dropTable(String tableName) {
-    return "IF OBJECT_ID('" + tableName + "', 'U') IS NOT NULL drop table " + tableName;
-  }
-
-  @Override
-  public String alterTableDropForeignKey(String tableName, String fkName) {
-    return "IF OBJECT_ID('" + fkName + "', 'F') IS NOT NULL " + super.alterTableDropForeignKey(tableName, fkName);
-  }
-
-  /**
-   * MsSqlServer specific null handling on unique constraints.
-   */
-  @Override
-  public String alterTableAddUniqueConstraint(String tableName, String uqName, String[] columns) {
-
-    // issues#233
-    String start = "create unique nonclustered index " + uqName + " on " + tableName + "(";
-    StringBuilder sb = new StringBuilder(start);
-
-    for (int i = 0; i < columns.length; i++) {
-      if (i > 0) {
-        sb.append(",");
-      }
-      sb.append(columns[i]);
-    }
-    sb.append(") where");
-    for (String column : columns) {
-      sb.append(" ").append(column).append(" is not null");
-    }
-    return sb.toString();
-  }
-
-  @Override
-  public String alterColumnDefaultValue(String tableName, String columnName, String defaultValue) {
-
-    if (isDropDefault(defaultValue)) {
-      return "-- alter table " + tableName + " drop constraint <unknown>  -- find the appropriate constraint for default value on column " + columnName;
-    } else {
-      return "alter table " + tableName + " add default " + defaultValue + " for " + columnName;
-    }
-  }
-
-  public String alterColumnBaseAttributes(AlterColumn alter) {
-
-    String tableName = alter.getTableName();
-    String columnName = alter.getColumnName();
-    String type = alter.getType() != null ? alter.getType() : alter.getCurrentType();
-    boolean notnull = (alter.isNotnull() != null) ? alter.isNotnull() : Boolean.TRUE.equals(alter.isCurrentNotnull());
-    String notnullClause = notnull ? " not null" : "";
-
-    return "alter table " + tableName + " alter column " + columnName + " " + type + notnullClause;
-  }
-
-  @Override
-  public String alterColumnType(String tableName, String columnName, String type) {
-
-    // can't alter itself - done in alterColumnBaseAttributes()
-    return null;
-  }
-
-  public String alterColumnNotnull(String tableName, String columnName, boolean notnull) {
-
-    // can't alter itself - done in alterColumnBaseAttributes()
-    return null;
-  }
-
-  /**
-   * Add table comment as a separate statement (from the create table statement).
-   */
-  public void addTableComment(DdlBuffer apply, String tableName, String tableComment) throws IOException {
-
-    // do nothing for MS SQL Server (cause it requires stored procedures etc)
-  }
-
-  /**
-   * Add column comment as a separate statement.
-   */
-  public void addColumnComment(DdlBuffer apply, String table, String column, String comment) throws IOException {
-
-    // do nothing for MS SQL Server (cause it requires stored procedures etc)
-  }
-}
@@ -1,99 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.Column;
-import com.avaje.ebeaninternal.server.lib.util.StringHelper;
-
-import java.io.IOException;
-
-/**
- * MySql specific DDL.
- */
-public class MySqlDdl extends PlatformDdl {
-
-  public MySqlDdl(DatabasePlatform platform) {
-    super(platform);
-    this.alterColumn = "modify";
-    this.dropUniqueConstraint = "drop index";
-    this.historyDdl = new MySqlHistoryDdl();
-    this.inlineComments = true;
-  }
-
-  /**
-   * Return the drop index statement.
-   */
-  @Override
-  public String dropIndex(String indexName, String tableName) {
-    return "drop index " + indexName + " on " + tableName;
-  }
-
-  /**
-   * Return the drop foreign key clause.
-   */
-  @Override
-  public String alterTableDropForeignKey(String tableName, String fkName) {
-    return "alter table " + tableName + " drop foreign key " + fkName;
-  }
-
-  @Override
-  public String alterTableDropConstraint(String tableName, String constraintName) {
-    // drop constraint not supported
-    return null;
-  }
-
-  @Override
-  public String alterColumnType(String tableName, String columnName, String type) {
-    // can't alter itself - done in alterColumnBaseAttributes()
-    return null;
-  }
-
-  public String alterColumnNotnull(String tableName, String columnName, boolean notnull) {
-
-    // can't alter itself - done in alterColumnBaseAttributes()
-    return null;
-  }
-
-  public String alterColumnDefaultValue(String tableName, String columnName, String defaultValue) {
-
-    String suffix = isDropDefault(defaultValue) ? columnDropDefault : columnSetDefault + " " + defaultValue;
-
-    // use alter
-    return "alter table " + tableName + " alter " + columnName + " " + suffix;
-  }
-
-  public String alterColumnBaseAttributes(AlterColumn alter) {
-
-    String tableName = alter.getTableName();
-    String columnName = alter.getColumnName();
-    String type = alter.getType() != null ? alter.getType() : alter.getCurrentType();
-    boolean notnull = (alter.isNotnull() != null) ? alter.isNotnull() : Boolean.TRUE.equals(alter.isCurrentNotnull());
-    String notnullClause = notnull ? " not null" : "";
-
-    // use modify
-    return "alter table " + tableName + " modify " + columnName + " " + type + notnullClause;
-  }
-
-  @Override
-  protected void writeColumnDefinition(DdlBuffer buffer, Column column, boolean useIdentity) throws IOException {
-    super.writeColumnDefinition(buffer, column, useIdentity);
-    String comment = column.getComment();
-    if (!StringHelper.isNull(comment)) {
-      // in mysql 5.5 column comment save in information_schema.COLUMNS.COLUMN_COMMENT(VARCHAR 1024)
-      if (comment.length() > 500) {
-        comment = comment.substring(0, 500);
-      }
-      buffer.append(String.format(" comment '%s'", comment));
-    }
-
-  }
-
-  public void inlineTableComment(DdlBuffer apply, String tableComment) throws IOException {
-    if (tableComment.length() > 1000) {
-      tableComment = tableComment.substring(0, 1000);
-    }
-    apply.append(" comment='").append(tableComment).append("'");
-  }
-
-}
@@ -1,41 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.model.MTable;
-
-import java.io.IOException;
-
-/**
- * Default history implementation that does nothing. Needs to be replaced
- * with an appropriate implementation for the given database platform.
- */
-public class NoHistorySupportDdl implements PlatformHistoryDdl {
-
-  @Override
-  public void configure(ServerConfig serverConfig, PlatformDdl platformDdl) {
-    // does nothing
-  }
-
-  @Override
-  public void createWithHistory(DdlWrite writer, MTable table) throws IOException {
-    // does nothing
-  }
-
-  @Override
-  public void dropHistoryTable(DdlWrite writer, DropHistoryTable dropHistoryTable) {
-    // does nothing
-  }
-
-  @Override
-  public void addHistoryTable(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException {
-    // does nothing
-  }
-
-  @Override
-  public void updateTriggers(DdlWrite write, HistoryTableUpdate update) {
-    // does nothing
-  }
-}
@@ -1,24 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-
-/**
- * Oracle platform specific DDL.
- */
-public class Oracle10Ddl extends PlatformDdl {
-
-  public Oracle10Ddl(DatabasePlatform platform) {
-    super(platform);
-    this.dropTableIfExists = "drop table ";
-    this.dropSequenceIfExists = "drop sequence ";
-    this.dropConstraintIfExists = "drop constraint";
-    this.dropIndexIfExists = "drop index ";
-    this.dropTableCascade = " cascade constraints purge";
-    this.foreignKeyRestrict = "";
-    this.alterColumn = "modify";
-    this.columnSetNotnull = "not null";
-    this.columnSetNull = "null";
-    this.columnSetDefault = "default";
-  }
-
-}
@@ -1,497 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.DbConstraintNaming;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-import com.avaje.ebean.config.dbplatform.DbDefaultValue;
-import com.avaje.ebean.config.dbplatform.DbIdentity;
-import com.avaje.ebean.config.dbplatform.IdType;
-import com.avaje.ebean.dbmigration.ddlgeneration.BaseDdlHandler;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.util.PlatformTypeConverter;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.Column;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.migration.IdentityType;
-import com.avaje.ebean.dbmigration.model.MTable;
-
-import java.io.IOException;
-import java.util.List;
-
-/**
- * Controls the DDL generation for a specific database platform.
- */
-public class PlatformDdl {
-
-  protected final DatabasePlatform platform;
-
-  protected PlatformHistoryDdl historyDdl = new NoHistorySupportDdl();
-
-  /**
-   * Converter for logical/standard types to platform specific types. (eg. clob -> text)
-   */
-  private final PlatformTypeConverter typeConverter;
-
-  /**
-   * For handling support of sequences and autoincrement.
-   */
-  private final DbIdentity dbIdentity;
-
-  /**
-   * Set to true if table and column comments are included inline with the create statements.
-   */
-  protected boolean inlineComments;
-
-  /**
-   * Default assumes if exists is supported.
-   */
-  protected String dropTableIfExists = "drop table if exists ";
-
-  protected String dropTableCascade = "";
-
-  /**
-   * Default assumes if exists is supported.
-   */
-  protected String dropSequenceIfExists = "drop sequence if exists ";
-
-  protected String foreignKeyRestrict = "on delete restrict on update restrict";
-
-  protected String identitySuffix = " auto_increment";
-
-  protected String alterTableIfExists = "";
-
-  protected String dropConstraintIfExists = "drop constraint if exists";
-
-  protected String dropIndexIfExists = "drop index if exists ";
-
-  protected String alterColumn = "alter column";
-
-  protected String dropConstraint = "drop constraint";
-
-  protected String dropUniqueConstraint = "drop constraint";
-
-  protected String addConstraint = "add constraint";
-
-  protected String columnSetType = "";
-
-  protected String columnSetDefault = "set default";
-
-  protected String columnDropDefault = "drop default";
-
-  protected String columnSetNotnull = "set not null";
-
-  protected String columnSetNull = "set null";
-
-  /**
-   * Set false for MsSqlServer to allow multiple nulls for OneToOne mapping.
-   */
-  protected boolean inlineUniqueOneToOne = true;
-
-  protected DbConstraintNaming naming;
-
-  /**
-   * Generally not desired as then they are not named (used with SQLite).
-   */
-  protected boolean inlineForeignKeys;
-
-  protected final DbDefaultValue dbDefaultValue;
-
-  public PlatformDdl(DatabasePlatform platform) {
-    this.platform = platform;
-    this.dbIdentity = platform.getDbIdentity();
-    this.dbDefaultValue = platform.getDbDefaultValue();
-    this.typeConverter = new PlatformTypeConverter(platform.getDbTypeMap());
-  }
-
-  /**
-   * Set configuration options.
-   */
-  public void configure(ServerConfig serverConfig) {
-    historyDdl.configure(serverConfig, this);
-    naming = serverConfig.getConstraintNaming();
-  }
-
-  /**
-   * Create a DdlHandler for the specific database platform.
-   */
-  public DdlHandler createDdlHandler(ServerConfig serverConfig) {
-    return new BaseDdlHandler(serverConfig, this);
-  }
-
-  /**
-   * Return the identity type to use given the support in the underlying database
-   * platform for sequences and identity/autoincrement.
-   */
-  public IdType useIdentityType(IdentityType modelIdentityType) {
-
-    return dbIdentity.useIdentityType(modelIdentityType);
-  }
-
-  /**
-   * Modify and return the column definition for autoincrement or identity definition.
-   */
-  public String asIdentityColumn(String columnDefn) {
-    return columnDefn + identitySuffix;
-  }
-
-  /**
-   * Return true if the table and column comments are included inline.
-   */
-  public boolean isInlineComments() {
-    return inlineComments;
-  }
-
-  /**
-   * Return true if foreign key reference constraints need to inlined with create table.
-   * Ideally we don't do this as then the constraints are not named. Do this for SQLite.
-   */
-  public boolean isInlineForeignKeys() {
-    return inlineForeignKeys;
-  }
-
-  /**
-   * Write all the table columns converting to platform types as necessary.
-   */
-  public void writeTableColumns(DdlBuffer apply, List<Column> columns, boolean useIdentity) throws IOException {
-    for (int i = 0; i < columns.size(); i++) {
-      apply.newLine();
-      writeColumnDefinition(apply, columns.get(i), useIdentity);
-      if (i < columns.size() - 1) {
-        apply.append(",");
-      }
-    }
-  }
-
-  /**
-   * Write the column definition to the create table statement.
-   */
-  protected void writeColumnDefinition(DdlBuffer buffer, Column column, boolean useIdentity) throws IOException {
-
-    boolean identityColumn = useIdentity && isTrue(column.isPrimaryKey());
-    String platformType = convert(column.getType(), identityColumn);
-
-    buffer.append("  ");
-    buffer.append(lowerColumnName(column.getName()), 29);
-    buffer.append(platformType);
-    if (!typeContainsDefault(platformType)) {
-      String defaultValue = convertDefaultValue(column.getDefaultValue());
-      if (defaultValue != null) {
-        buffer.append(" default ").append(defaultValue);
-      }
-    }
-    if (isTrue(column.isNotnull()) || isTrue(column.isPrimaryKey())) {
-      buffer.append(" not null");
-    }
-
-    // add check constraints later as we really want to give them a nice name
-    // so that the database can potentially provide a nice SQL error
-  }
-
-  /**
-   * Return true if the type definition already contains a default value.
-   */
-  private boolean typeContainsDefault(String platformType) {
-    return platformType.toLowerCase().contains(" default");
-  }
-
-  /**
-   * Convert the DB column default literal to platform specific.
-   */
-  private String convertDefaultValue(String dbDefault) {
-    return dbDefaultValue.convert(dbDefault);
-  }
-
-  /**
-   * Return the drop foreign key clause.
-   */
-  public String alterTableDropForeignKey(String tableName, String fkName) {
-    return "alter table " + alterTableIfExists + tableName + " " + dropConstraintIfExists + " " + fkName;
-  }
-
-  /**
-   * Convert the standard type to the platform specific type.
-   */
-  public String convert(String type, boolean identity) {
-    String platformType = typeConverter.convert(type);
-    return identity ? asIdentityColumn(platformType) : platformType;
-  }
-
-  /**
-   * Add history support to this table using the platform specific mechanism.
-   */
-  public void createWithHistory(DdlWrite writer, MTable table) throws IOException {
-    historyDdl.createWithHistory(writer, table);
-  }
-
-  /**
-   * Drop history support for a given table.
-   */
-  public void dropHistoryTable(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException {
-    historyDdl.dropHistoryTable(writer, dropHistoryTable);
-  }
-
-  /**
-   * Add history support to an existing table.
-   */
-  public void addHistoryTable(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException {
-    historyDdl.addHistoryTable(writer, addHistoryTable);
-  }
-
-  /**
-   * Regenerate the history triggers (or function) due to a column being added/dropped/excluded or included.
-   */
-  public void regenerateHistoryTriggers(DdlWrite write, HistoryTableUpdate update) throws IOException {
-    historyDdl.updateTriggers(write, update);
-  }
-
-  /**
-   * Generate and return the create sequence DDL.
-   */
-  public String createSequence(String sequenceName, int initialValue, int allocationSize) {
-
-    StringBuilder sb = new StringBuilder("create sequence ");
-    sb.append(sequenceName);
-    if (initialValue > 1) {
-      sb.append(" start with ").append(initialValue);
-    }
-    if (allocationSize > 0 && allocationSize != 50) {
-      // at this stage ignoring allocationSize 50 as this is the 'default' and
-      // not consistent with the way Ebean batch fetches sequence values
-      sb.append(" increment by ").append(allocationSize);
-    }
-    sb.append(";");
-    return sb.toString();
-  }
-
-  /**
-   * Return the drop sequence statement (potentially with if exists clause).
-   */
-  public String dropSequence(String sequenceName) {
-    return dropSequenceIfExists + sequenceName;
-  }
-
-  /**
-   * Return the drop table statement (potentially with if exists clause).
-   */
-  public String dropTable(String tableName) {
-    return dropTableIfExists + tableName + dropTableCascade;
-  }
-
-  /**
-   * Return the drop index statement.
-   */
-  public String dropIndex(String indexName, String tableName) {
-    return dropIndexIfExists + indexName;
-  }
-
-  /**
-   * Return the create index statement.
-   */
-  public String createIndex(String indexName, String tableName, String[] columns) {
-
-    StringBuilder buffer = new StringBuilder();
-    buffer.append("create index ").append(indexName).append(" on ").append(tableName);
-    appendColumns(columns, buffer);
-
-    return buffer.toString();
-  }
-
-  /**
-   * Return the foreign key constraint when used inline with create table.
-   */
-  public String tableInlineForeignKey(String[] columns, String refTable, String[] refColumns) {
-
-    StringBuilder buffer = new StringBuilder(90);
-    buffer.append("foreign key");
-    appendColumns(columns, buffer);
-    buffer.append(" references ").append(lowerTableName(refTable));
-    appendColumns(refColumns, buffer);
-    appendWithSpace(foreignKeyRestrict, buffer);
-    return buffer.toString();
-  }
-
-  /**
-   * Add foreign key.
-   */
-  public String alterTableAddForeignKey(String tableName, String fkName, String[] columns, String refTable, String[] refColumns) {
-
-    StringBuilder buffer = new StringBuilder(90);
-    buffer
-      .append("alter table ").append(tableName)
-      .append(" add constraint ").append(fkName)
-      .append(" foreign key");
-    appendColumns(columns, buffer);
-    buffer
-      .append(" references ")
-      .append(lowerTableName(refTable));
-    appendColumns(refColumns, buffer);
-    appendWithSpace(foreignKeyRestrict, buffer);
-
-    return buffer.toString();
-  }
-
-  /**
-   * Drop a unique constraint from the table (Sometimes this is an index).
-   */
-  public String alterTableDropUniqueConstraint(String tableName, String uniqueConstraintName) {
-    return "alter table " + tableName + " " + dropUniqueConstraint + " " + uniqueConstraintName;
-  }
-
-  /**
-   * Drop a unique constraint from the table.
-   */
-  public String alterTableDropConstraint(String tableName, String constraintName) {
-    return "alter table " + tableName + " " + dropConstraint + " " + constraintName;
-  }
-
-  /**
-   * Add a unique constraint to the table.
-   * <p>
-   * Overridden by MsSqlServer for specific null handling on unique constraints.
-   */
-  public String alterTableAddUniqueConstraint(String tableName, String uqName, String[] columns) {
-
-    StringBuilder buffer = new StringBuilder(90);
-    buffer.append("alter table ").append(tableName).append(" add constraint ").append(uqName).append(" unique ");
-    appendColumns(columns, buffer);
-    return buffer.toString();
-  }
-
-  /**
-   * Return true if unique constraints for OneToOne can be inlined as normal.
-   * Returns false for MsSqlServer due to it's null handling for unique constraints.
-   */
-  public boolean isInlineUniqueOneToOne() {
-    return inlineUniqueOneToOne;
-  }
-
-  /**
-   * Alter a column type.
-   * <p>
-   * Note that that MySql and SQL Server instead use alterColumnBaseAttributes()
-   * </p>
-   */
-  public String alterColumnType(String tableName, String columnName, String type) {
-
-    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + columnSetType + type;
-  }
-
-  /**
-   * Alter a column adding or removing the not null constraint.
-   * <p>
-   * Note that that MySql and SQL Server instead use alterColumnBaseAttributes()
-   * </p>
-   */
-  public String alterColumnNotnull(String tableName, String columnName, boolean notnull) {
-
-    String suffix = notnull ? columnSetNotnull : columnSetNull;
-    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + suffix;
-  }
-
-  /**
-   * Alter table adding the check constraint.
-   */
-  public String alterTableAddCheckConstraint(String tableName, String checkConstraintName, String checkConstraint) {
-
-    return "alter table " + tableName + " " + addConstraint + " " + checkConstraintName + " " + checkConstraint;
-  }
-
-  /**
-   * Return true if the default value is the special DROP DEFAULT value.
-   */
-  public boolean isDropDefault(String defaultValue) {
-    return "DROP DEFAULT".equals(defaultValue);
-  }
-
-  /**
-   * Alter column setting the default value.
-   */
-  public String alterColumnDefaultValue(String tableName, String columnName, String defaultValue) {
-
-    String suffix = isDropDefault(defaultValue) ? columnDropDefault : columnSetDefault + " " + defaultValue;
-    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + suffix;
-  }
-
-  /**
-   * Alter column setting both the type and not null constraint.
-   * <p>
-   * Used by MySql and SQL Server as these require both column attributes to be set together.
-   * </p>
-   */
-  public String alterColumnBaseAttributes(AlterColumn alter) {
-    // by default do nothing, only used by mysql and sql server as they can only
-    // modify the column with the full column definition
-    return null;
-  }
-
-  protected void appendColumns(String[] columns, StringBuilder buffer) {
-    buffer.append(" (");
-    for (int i = 0; i < columns.length; i++) {
-      if (i > 0) {
-        buffer.append(",");
-      }
-      buffer.append(lowerColumnName(columns[i].trim()));
-    }
-    buffer.append(")");
-  }
-
-  protected void appendWithSpace(String content, StringBuilder buffer) {
-    if (content != null && !content.isEmpty()) {
-      buffer.append(" ").append(content);
-    }
-  }
-
-  /**
-   * Convert the table to lower case.
-   * <p>
-   * Override as desired. Generally lower case with underscore is a good cross database
-   * choice for column/table names.
-   */
-  protected String lowerTableName(String name) {
-    return naming.lowerTableName(name);
-  }
-
-  /**
-   * Convert the column name to lower case.
-   * <p>
-   * Override as desired. Generally lower case with underscore is a good cross database
-   * choice for column/table names.
-   */
-  protected String lowerColumnName(String name) {
-    return naming.lowerColumnName(name);
-  }
-
-
-  /**
-   * Null safe Boolean true test.
-   */
-  protected boolean isTrue(Boolean value) {
-    return Boolean.TRUE.equals(value);
-  }
-
-  /**
-   * Add an inline table comment to the create table statement.
-   */
-  public void inlineTableComment(DdlBuffer apply, String tableComment) throws IOException {
-    // do nothing by default (MySql only)
-  }
-
-  /**
-   * Add table comment as a separate statement (from the create table statement).
-   */
-  public void addTableComment(DdlBuffer apply, String tableName, String tableComment) throws IOException {
-
-    apply.append(String.format("comment on table %s is '%s'", tableName, tableComment)).endOfStatement();
-  }
-
-  /**
-   * Add column comment as a separate statement.
-   */
-  public void addColumnComment(DdlBuffer apply, String table, String column, String comment) throws IOException {
-
-    apply.append(String.format("comment on column %s.%s is '%s'", table, column, comment)).endOfStatement();
-  }
-}
@@ -1,40 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.model.MTable;
-
-import java.io.IOException;
-
-/**
- * Defines the implementation for adding history support to a table.
- */
-public interface PlatformHistoryDdl {
-
-  /**
-   * Configure typically reading the
-   */
-  void configure(ServerConfig serverConfig, PlatformDdl platformDdl);
-
-  /**
-   * Add history support to the table using platform specific mechanism.
-   */
-  void createWithHistory(DdlWrite writer, MTable table) throws IOException;
-
-  /**
-   * Drop history support for the given table.
-   */
-  void dropHistoryTable(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException;
-
-  /**
-   * Add history support to the given table.
-   */
-  void addHistoryTable(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException;
-
-  /**
-   * Regenerate the history triggers/stored function due to column added/dropped/included or excluded.
-   */
-  void updateTriggers(DdlWrite write, HistoryTableUpdate baseTable) throws IOException;
-}
@@ -1,36 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-
-/**
- * Postgres specific DDL.
- */
-public class PostgresDdl extends PlatformDdl {
-
-  public PostgresDdl(DatabasePlatform platform) {
-    super(platform);
-    this.historyDdl = new PostgresHistoryDdl();
-    this.dropTableCascade = " cascade";
-    this.columnSetType = "type ";
-    this.alterTableIfExists = "if exists ";
-    this.columnSetNull = "drop not null";
-  }
-
-  /**
-   * Map bigint, integer and smallint into their equivalent serial types.
-   */
-  @Override
-  public String asIdentityColumn(String columnDefn) {
-
-    if ("bigint".equalsIgnoreCase(columnDefn)) {
-      return "bigserial";
-    }
-    if ("integer".equalsIgnoreCase(columnDefn)) {
-      return "serial";
-    }
-    if ("smallint".equalsIgnoreCase(columnDefn)) {
-      return "smallserial";
-    }
-    return columnDefn;
-  }
-}
@@ -1,34 +0,0 @@
-package com.avaje.ebean.dbmigration.ddlgeneration.platform;
-
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
-
-import java.io.IOException;
-
-/**
- * DB2 platform specific DDL.
- */
-public class SQLiteDdl extends PlatformDdl {
-
-  public SQLiteDdl(DatabasePlatform platform) {
-    super(platform);
-    this.identitySuffix = "";
-    this.inlineForeignKeys = true;
-  }
-
-  @Override
-  public void addTableComment(DdlBuffer apply, String tableName, String tableComment) throws IOException {
-    // not supported
-  }
-
-  @Override
-  public void addColumnComment(DdlBuffer apply, String table, String column, String comment) throws IOException {
-    // not supported
-  }
-
-  @Override
-  public String alterTableAddForeignKey(String tableName, String fkName, String[] columns, String refTable, String[] refColumns) {
-    // not supported
-    return null;
-  }
-}
@@ -1,236 +0,0 @@
-package com.avaje.ebean.dbmigration.migration;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlAttribute;
-import javax.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlElements;
-import javax.xml.bind.annotation.XmlRootElement;
-import javax.xml.bind.annotation.XmlType;
-import java.util.ArrayList;
-import java.util.List;
-
-
-/**
- * <p>Java class for anonymous complex type.
- * <p>
- * <p>The following schema fragment specifies the expected content contained within this class.
- * <p>
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence>
- *         &lt;choice>
- *           &lt;group ref="{http://ebean-orm.github.io/xml/ns/dbmigration}changeSetChildren" maxOccurs="unbounded" minOccurs="0"/>
- *         &lt;/choice>
- *       &lt;/sequence>
- *       &lt;attribute name="type" use="required" type="{http://ebean-orm.github.io/xml/ns/dbmigration}changeSetType" />
- *       &lt;attribute name="dropsFor" type="{http://www.w3.org/2001/XMLSchema}string" />
- *       &lt;attribute name="suppressDropsForever" type="{http://www.w3.org/2001/XMLSchema}boolean" />
- *       &lt;attribute name="generated" type="{http://www.w3.org/2001/XMLSchema}boolean" />
- *       &lt;attribute name="author" type="{http://www.w3.org/2001/XMLSchema}string" />
- *       &lt;attribute name="comment" type="{http://www.w3.org/2001/XMLSchema}string" />
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
- */
-@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "", propOrder = {
-  "changeSetChildren"
-})
-@XmlRootElement(name = "changeSet")
-public class ChangeSet {
-
-  @XmlElements({
-    @XmlElement(name = "configuration", type = Configuration.class),
-    @XmlElement(name = "sql", type = Sql.class),
-    @XmlElement(name = "createTable", type = CreateTable.class),
-    @XmlElement(name = "dropTable", type = DropTable.class),
-    @XmlElement(name = "renameTable", type = RenameTable.class),
-    @XmlElement(name = "addTableComment", type = AddTableComment.class),
-    @XmlElement(name = "addHistoryTable", type = AddHistoryTable.class),
-    @XmlElement(name = "dropHistoryTable", type = DropHistoryTable.class),
-    @XmlElement(name = "addColumn", type = AddColumn.class),
-    @XmlElement(name = "dropColumn", type = DropColumn.class),
-    @XmlElement(name = "alterColumn", type = AlterColumn.class),
-    @XmlElement(name = "renameColumn", type = RenameColumn.class),
-    @XmlElement(name = "createIndex", type = CreateIndex.class),
-    @XmlElement(name = "dropIndex", type = DropIndex.class)
-  })
-  protected List<Object> changeSetChildren;
-  @XmlAttribute(name = "type", required = true)
-  protected ChangeSetType type;
-  @XmlAttribute(name = "dropsFor")
-  protected String dropsFor;
-  @XmlAttribute(name = "suppressDropsForever")
-  protected Boolean suppressDropsForever;
-  @XmlAttribute(name = "generated")
-  protected Boolean generated;
-  @XmlAttribute(name = "author")
-  protected String author;
-  @XmlAttribute(name = "comment")
-  protected String comment;
-
-  /**
-   * Gets the value of the changeSetChildren property.
-   * <p>
-   * <p>
-   * This accessor method returns a reference to the live list,
-   * not a snapshot. Therefore any modification you make to the
-   * returned list will be present inside the JAXB object.
-   * This is why there is not a <CODE>set</CODE> method for the changeSetChildren property.
-   * <p>
-   * <p>
-   * For example, to add a new item, do as follows:
-   * <pre>
-   *    getChangeSetChildren().add(newItem);
-   * </pre>
-   * <p>
-   * <p>
-   * <p>
-   * Objects of the following type(s) are allowed in the list
-   * {@link Configuration }
-   * {@link Sql }
-   * {@link CreateTable }
-   * {@link DropTable }
-   * {@link RenameTable }
-   * {@link AddTableComment }
-   * {@link AddHistoryTable }
-   * {@link DropHistoryTable }
-   * {@link AddColumn }
-   * {@link DropColumn }
-   * {@link AlterColumn }
-   * {@link RenameColumn }
-   * {@link CreateIndex }
-   * {@link DropIndex }
-   */
-  public List<Object> getChangeSetChildren() {
-    if (changeSetChildren == null) {
-      changeSetChildren = new ArrayList<>();
-    }
-    return this.changeSetChildren;
-  }
-
-  /**
-   * Gets the value of the type property.
-   *
-   * @return possible object is
-   * {@link ChangeSetType }
-   */
-  public ChangeSetType getType() {
-    return type;
-  }
-
-  /**
-   * Sets the value of the type property.
-   *
-   * @param value allowed object is
-   *              {@link ChangeSetType }
-   */
-  public void setType(ChangeSetType value) {
-    this.type = value;
-  }
-
-  /**
-   * Gets the value of the dropsFor property.
-   *
-   * @return possible object is
-   * {@link String }
-   */
-  public String getDropsFor() {
-    return dropsFor;
-  }
-
-  /**
-   * Sets the value of the dropsFor property.
-   *
-   * @param value allowed object is
-   *              {@link String }
-   */
-  public void setDropsFor(String value) {
-    this.dropsFor = value;
-  }
-
-  /**
-   * Gets the value of the suppressDropsForever property.
-   *
-   * @return possible object is
-   * {@link Boolean }
-   */
-  public Boolean isSuppressDropsForever() {
-    return suppressDropsForever;
-  }
-
-  /**
-   * Sets the value of the suppressDropsForever property.
-   *
-   * @param value allowed object is
-   *              {@link Boolean }
-   */
-  public void setSuppressDropsForever(Boolean value) {
-    this.suppressDropsForever = value;
-  }
-
-  /**
-   * Gets the value of the generated property.
-   *
-   * @return possible object is
-   * {@link Boolean }
-   */
-  public Boolean isGenerated() {
-    return generated;
-  }
-
-  /**
-   * Sets the value of the generated property.
-   *
-   * @param value allowed object is
-   *              {@link Boolean }
-   */
-  public void setGenerated(Boolean value) {
-    this.generated = value;
-  }
-
-  /**
-   * Gets the value of the author property.
-   *
-   * @return possible object is
-   * {@link String }
-   */
-  public String getAuthor() {
-    return author;
-  }
-
-  /**
-   * Sets the value of the author property.
-   *
-   * @param value allowed object is
-   *              {@link String }
-   */
-  public void setAuthor(String value) {
-    this.author = value;
-  }
-
-  /**
-   * Gets the value of the comment property.
-   *
-   * @return possible object is
-   * {@link String }
-   */
-  public String getComment() {
-    return comment;
-  }
-
-  /**
-   * Sets the value of the comment property.
-   *
-   * @param value allowed object is
-   *              {@link String }
-   */
-  public void setComment(String value) {
-    this.comment = value;
-  }
-
-}
@@ -1,57 +0,0 @@
-package com.avaje.ebean.dbmigration.migration;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlRootElement;
-import javax.xml.bind.annotation.XmlType;
-
-
-/**
- * <p>Java class for anonymous complex type.
- * <p>
- * <p>The following schema fragment specifies the expected content contained within this class.
- * <p>
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence>
- *         &lt;element ref="{http://ebean-orm.github.io/xml/ns/dbmigration}defaultTablespace"/>
- *       &lt;/sequence>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
- */
-@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "", propOrder = {
-  "defaultTablespace"
-})
-@XmlRootElement(name = "configuration")
-public class Configuration {
-
-  @XmlElement(required = true)
-  protected DefaultTablespace defaultTablespace;
-
-  /**
-   * Gets the value of the defaultTablespace property.
-   *
-   * @return possible object is
-   * {@link DefaultTablespace }
-   */
-  public DefaultTablespace getDefaultTablespace() {
-    return defaultTablespace;
-  }
-
-  /**
-   * Sets the value of the defaultTablespace property.
-   *
-   * @param value allowed object is
-   *              {@link DefaultTablespace }
-   */
-  public void setDefaultTablespace(DefaultTablespace value) {
-    this.defaultTablespace = value;
-  }
-
-}
@@ -1,53 +0,0 @@
-package com.avaje.ebean.dbmigration.migration;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlAttribute;
-import javax.xml.bind.annotation.XmlRootElement;
-import javax.xml.bind.annotation.XmlType;
-
-
-/**
- * <p>Java class for anonymous complex type.
- * <p>
- * <p>The following schema fragment specifies the expected content contained within this class.
- * <p>
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
- */
-@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "")
-@XmlRootElement(name = "dropTable")
-public class DropTable {
-
-  @XmlAttribute(name = "name", required = true)
-  protected String name;
-
-  /**
-   * Gets the value of the name property.
-   *
-   * @return possible object is
-   * {@link String }
-   */
-  public String getName() {
-    return name;
-  }
-
-  /**
-   * Sets the value of the name property.
-   *
-   * @param value allowed object is
-   *              {@link String }
-   */
-  public void setName(String value) {
-    this.name = value;
-  }
-
-}
@@ -1,190 +0,0 @@
-package com.avaje.ebean.dbmigration.migration;
-
-import javax.xml.bind.annotation.XmlRegistry;
-
-
-/**
- * This object contains factory methods for each
- * Java content interface and Java element interface
- * generated in the com.avaje.ebean.dbmigration.migration package.
- * <p>An ObjectFactory allows you to programatically
- * construct new instances of the Java representation
- * for XML content. The Java representation of XML
- * content can consist of schema derived interfaces
- * and classes representing the binding of schema
- * type definitions, element declarations and model
- * groups.  Factory methods for each of these are
- * provided in this class.
- */
-@XmlRegistry
-public class ObjectFactory {
-
-
-  /**
-   * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: com.avaje.ebean.dbmigration.migration
-   */
-  public ObjectFactory() {
-  }
-
-  /**
-   * Create an instance of {@link Rollback }
-   */
-  public Rollback createRollback() {
-    return new Rollback();
-  }
-
-  /**
-   * Create an instance of {@link AddColumn }
-   */
-  public AddColumn createAddColumn() {
-    return new AddColumn();
-  }
-
-  /**
-   * Create an instance of {@link Column }
-   */
-  public Column createColumn() {
-    return new Column();
-  }
-
-  /**
-   * Create an instance of {@link CreateTable }
-   */
-  public CreateTable createCreateTable() {
-    return new CreateTable();
-  }
-
-  /**
-   * Create an instance of {@link UniqueConstraint }
-   */
-  public UniqueConstraint createUniqueConstraint() {
-    return new UniqueConstraint();
-  }
-
-  /**
-   * Create an instance of {@link ForeignKey }
-   */
-  public ForeignKey createForeignKey() {
-    return new ForeignKey();
-  }
-
-  /**
-   * Create an instance of {@link Apply }
-   */
-  public Apply createApply() {
-    return new Apply();
-  }
-
-  /**
-   * Create an instance of {@link Configuration }
-   */
-  public Configuration createConfiguration() {
-    return new Configuration();
-  }
-
-  /**
-   * Create an instance of {@link DefaultTablespace }
-   */
-  public DefaultTablespace createDefaultTablespace() {
-    return new DefaultTablespace();
-  }
-
-  /**
-   * Create an instance of {@link AddTableComment }
-   */
-  public AddTableComment createAddTableComment() {
-    return new AddTableComment();
-  }
-
-  /**
-   * Create an instance of {@link RenameTable }
-   */
-  public RenameTable createRenameTable() {
-    return new RenameTable();
-  }
-
-  /**
-   * Create an instance of {@link DropHistoryTable }
-   */
-  public DropHistoryTable createDropHistoryTable() {
-    return new DropHistoryTable();
-  }
-
-  /**
-   * Create an instance of {@link AlterColumn }
-   */
-  public AlterColumn createAlterColumn() {
-    return new AlterColumn();
-  }
-
-  /**
-   * Create an instance of {@link DropColumn }
-   */
-  public DropColumn createDropColumn() {
-    return new DropColumn();
-  }
-
-  /**
-   * Create an instance of {@link CreateIndex }
-   */
-  public CreateIndex createCreateIndex() {
-    return new CreateIndex();
-  }
-
-  /**
-   * Create an instance of {@link ChangeSet }
-   */
-  public ChangeSet createChangeSet() {
-    return new ChangeSet();
-  }
-
-  /**
-   * Create an instance of {@link Sql }
-   */
-  public Sql createSql() {
-    return new Sql();
-  }
-
-  /**
-   * Create an instance of {@link DropTable }
-   */
-  public DropTable createDropTable() {
-    return new DropTable();
-  }
-
-  /**
-   * Create an instance of {@link AddHistoryTable }
-   */
-  public AddHistoryTable createAddHistoryTable() {
-    return new AddHistoryTable();
-  }
-
-  /**
-   * Create an instance of {@link RenameColumn }
-   */
-  public RenameColumn createRenameColumn() {
-    return new RenameColumn();
-  }
-
-  /**
-   * Create an instance of {@link DropIndex }
-   */
-  public DropIndex createDropIndex() {
-    return new DropIndex();
-  }
-
-  /**
-   * Create an instance of {@link AlterHistoryTable }
-   */
-  public AlterHistoryTable createAlterHistoryTable() {
-    return new AlterHistoryTable();
-  }
-
-  /**
-   * Create an instance of {@link Migration }
-   */
-  public Migration createMigration() {
-    return new Migration();
-  }
-
-}
@@ -1,76 +0,0 @@
-package com.avaje.ebean.dbmigration.migration;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlAttribute;
-import javax.xml.bind.annotation.XmlRootElement;
-import javax.xml.bind.annotation.XmlType;
-
-
-/**
- * <p>Java class for anonymous complex type.
- * <p>
- * <p>The following schema fragment specifies the expected content contained within this class.
- * <p>
- * <pre>
- * &lt;complexType>
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
- *       &lt;attribute name="columnNames" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
- * </pre>
- */
-@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "")
-@XmlRootElement(name = "uniqueConstraint")
-public class UniqueConstraint {
-
-  @XmlAttribute(name = "name", required = true)
-  protected String name;
-  @XmlAttribute(name = "columnNames", required = true)
-  protected String columnNames;
-
-  /**
-   * Gets the value of the name property.
-   *
-   * @return possible object is
-   * {@link String }
-   */
-  public String getName() {
-    return name;
-  }
-
-  /**
-   * Sets the value of the name property.
-   *
-   * @param value allowed object is
-   *              {@link String }
-   */
-  public void setName(String value) {
-    this.name = value;
-  }
-
-  /**
-   * Gets the value of the columnNames property.
-   *
-   * @return possible object is
-   * {@link String }
-   */
-  public String getColumnNames() {
-    return columnNames;
-  }
-
-  /**
-   * Sets the value of the columnNames property.
-   *
-   * @param value allowed object is
-   *              {@link String }
-   */
-  public void setColumnNames(String value) {
-    this.columnNames = value;
-  }
-
-}
@@ -1,2 +0,0 @@
-@javax.xml.bind.annotation.XmlSchema(namespace = "http://ebean-orm.github.io/xml/ns/dbmigration", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)
-package com.avaje.ebean.dbmigration.migration;
@@ -1,67 +0,0 @@
-package com.avaje.ebean.dbmigration.migrationreader;
-
-
-import com.avaje.ebean.dbmigration.migration.Migration;
-
-import javax.xml.bind.JAXBContext;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Unmarshaller;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-/**
- * Reads a migration xml document returning the Migration.
- */
-public class MigrationXmlReader {
-
-  private MigrationXmlReader() {
-  }
-
-  /**
-   * Read and return a Migration from an xml document at the given resource path.
-   */
-  public static Migration read(String resourcePath) {
-
-    InputStream is = MigrationXmlReader.class.getResourceAsStream(resourcePath);
-    if (is == null) {
-      throw new IllegalArgumentException("No resource found for path [" + resourcePath + "]");
-    }
-
-    return read(is);
-  }
-
-  /**
-   * Read and return a Migration from a migration xml file.
-   */
-  public static Migration read(File migrationFile) {
-
-    try {
-      FileInputStream is = new FileInputStream(migrationFile);
-      try {
-        return read(is);
-      } finally {
-        is.close();
-      }
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  /**
-   * Read and return a Migration from an xml document.
-   */
-  public static Migration read(InputStream is) {
-
-    try {
-      JAXBContext jaxbContext = JAXBContext.newInstance(Migration.class);
-      Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
-      return (Migration) unmarshaller.unmarshal(is);
-
-    } catch (JAXBException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-}
@@ -1,165 +0,0 @@
-package com.avaje.ebean.dbmigration.model;
-
-import com.avaje.ebean.config.DbConstraintNaming;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.DefaultConstraintMaxLength;
-import com.avaje.ebean.dbmigration.migration.ChangeSet;
-import com.avaje.ebean.dbmigration.model.build.ModelBuildBeanVisitor;
-import com.avaje.ebean.dbmigration.model.build.ModelBuildContext;
-import com.avaje.ebean.dbmigration.model.visitor.VisitAllUsing;
-import com.avaje.ebeaninternal.api.SpiEbeanServer;
-
-import java.io.IOException;
-
-/**
- * Reads EbeanServer bean descriptors to build the current model.
- */
-public class CurrentModel {
-
-  private final SpiEbeanServer server;
-
-  private final DbConstraintNaming constraintNaming;
-
-  private final DbConstraintNaming.MaxLength maxLength;
-
-  private final boolean platformTypes;
-
-  private ModelContainer model;
-
-  private ChangeSet changeSet;
-
-  private DdlWrite write;
-
-  /**
-   * Construct with a given EbeanServer instance for DDL create all generation, not migration.
-   */
-  public CurrentModel(SpiEbeanServer server) {
-    this(server, server.getServerConfig().getConstraintNaming(), true);
-  }
-
-  /**
-   * Construct with a given EbeanServer, platformDdl and constraintNaming convention.
-   * <p>
-   * Note the EbeanServer is just used to read the BeanDescriptors and platformDdl supplies
-   * the platform specific handling on
-   * </p>
-   */
-  public CurrentModel(SpiEbeanServer server, DbConstraintNaming constraintNaming) {
-    this(server, constraintNaming, false);
-  }
-
-  private CurrentModel(SpiEbeanServer server, DbConstraintNaming constraintNaming, boolean platformTypes) {
-    this.server = server;
-    this.constraintNaming = constraintNaming;
-    this.maxLength = maxLength(server, constraintNaming);
-    this.platformTypes = platformTypes;
-  }
-
-  private static DbConstraintNaming.MaxLength maxLength(SpiEbeanServer server, DbConstraintNaming naming) {
-
-    if (naming.getMaxLength() != null) {
-      return naming.getMaxLength();
-    }
-
-    int maxConstraintNameLength = server.getDatabasePlatform().getMaxConstraintNameLength();
-    return new DefaultConstraintMaxLength(maxConstraintNameLength);
-  }
-
-  /**
-   * Return the current model by reading all the bean descriptors and properties.
-   */
-  public ModelContainer read() {
-    if (model == null) {
-      model = new ModelContainer();
-
-      ModelBuildContext context = new ModelBuildContext(model, constraintNaming, maxLength, platformTypes);
-      ModelBuildBeanVisitor visitor = new ModelBuildBeanVisitor(context);
-      VisitAllUsing visit = new VisitAllUsing(visitor, server);
-      visit.visitAllBeans();
-
-      // adjust the foreign keys on the 'draft' tables
-      context.adjustDraftReferences();
-    }
-    return model;
-  }
-
-  public void setChangeSet(ChangeSet changeSet) {
-    this.changeSet = changeSet;
-  }
-
-  /**
-   * Return as a ChangeSet.
-   */
-  public ChangeSet getChangeSet() {
-    read();
-    if (changeSet == null) {
-      changeSet = asChangeSet();
-    }
-    return changeSet;
-  }
-
-  /**
-   * Return the 'Create' DDL.
-   */
-  public String getCreateDdl() throws IOException {
-
-    createDdl();
-
-    StringBuilder ddl = new StringBuilder(2000);
-    ddl.append(write.apply().getBuffer());
-    ddl.append(write.applyForeignKeys().getBuffer());
-    ddl.append(write.applyHistory().getBuffer());
-
-    return ddl.toString();
-  }
-
-  /**
-   * Return the 'Drop' DDL.
-   */
-  public String getDropAllDdl() throws IOException {
-
-    createDdl();
-
-    StringBuilder ddl = new StringBuilder(2000);
-    ddl.append(write.dropAllForeignKeys().getBuffer());
-    ddl.append(write.dropAll().getBuffer());
-
-    return ddl.toString();
-  }
-
-  /**
-   * Create all the DDL based on the changeSet.
-   */
-  private void createDdl() throws IOException {
-
-    if (write == null) {
-      ChangeSet createChangeSet = getChangeSet();
-
-      write = new DdlWrite(new MConfiguration(), model);
-
-      DdlHandler handler = handler();
-      handler.generate(write, createChangeSet);
-    }
-  }
-
-  /**
-   * Return the platform specific DdlHandler (to generate DDL).
-   */
-  private DdlHandler handler() {
-    return server.getDatabasePlatform().createDdlHandler(server.getServerConfig());
-  }
-
-  /**
-   * Convert the model into a ChangeSet.
-   */
-  private ChangeSet asChangeSet() {
-
-    // empty diff so changes will effectively all be create
-    ModelDiff diff = new ModelDiff();
-    diff.compareTo(model);
-
-    return diff.getApplyChangeSet();
-  }
-
-}
@@ -1,432 +0,0 @@
-package com.avaje.ebean.dbmigration.model;
-
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.Column;
-
-/**
- * A column in the logical model.
- */
-public class MColumn {
-
-  private final String name;
-  private String type;
-  private String checkConstraint;
-  private String checkConstraintName;
-  private String defaultValue;
-  private String references;
-  private String foreignKeyName;
-  private String foreignKeyIndex;
-  private String comment;
-
-  private boolean historyExclude;
-  private boolean notnull;
-  private boolean primaryKey;
-  private boolean identity;
-
-  private String unique;
-
-  /**
-   * Special unique for OneToOne as we need to handle that different
-   * specifically for MsSqlServer.
-   */
-  private String uniqueOneToOne;
-
-  /**
-   * Temporary variable used when building the alter column changes.
-   */
-  private AlterColumn alterColumn;
-
-  private boolean draftOnly;
-
-  public MColumn(Column column) {
-    this.name = column.getName();
-    this.type = column.getType();
-    this.checkConstraint = column.getCheckConstraint();
-    this.checkConstraintName = column.getCheckConstraintName();
-    this.defaultValue = column.getDefaultValue();
-    this.comment = column.getComment();
-    this.references = column.getReferences();
-    this.foreignKeyName = column.getForeignKeyName();
-    this.foreignKeyIndex = column.getForeignKeyIndex();
-    this.notnull = Boolean.TRUE.equals(column.isNotnull());
-    this.primaryKey = Boolean.TRUE.equals(column.isPrimaryKey());
-    this.identity = Boolean.TRUE.equals(column.isIdentity());
-    this.unique = column.getUnique();
-    this.uniqueOneToOne = column.getUniqueOneToOne();
-    this.historyExclude = Boolean.TRUE.equals(column.isHistoryExclude());
-  }
-
-  public MColumn(String name, String type) {
-    this.name = name;
-    this.type = type;
-  }
-
-  public MColumn(String name, String type, boolean notnull) {
-    this.name = name;
-    this.type = type;
-    this.notnull = notnull;
-  }
-
-  /**
-   * Return a copy of this column used for creating the associated draft table.
-   */
-  public MColumn copyForDraft() {
-
-    MColumn copy = new MColumn(name, type);
-    copy.draftOnly = draftOnly;
-    copy.checkConstraint = checkConstraint;
-    copy.checkConstraintName = checkConstraintName;
-    copy.defaultValue = defaultValue;
-    copy.references = references;
-    copy.comment = comment;
-    copy.foreignKeyName = foreignKeyName;
-    copy.foreignKeyIndex = foreignKeyIndex;
-    copy.historyExclude = historyExclude;
-    copy.notnull = notnull;
-    copy.primaryKey = primaryKey;
-    copy.identity = identity;
-    copy.unique = unique;
-    copy.uniqueOneToOne = uniqueOneToOne;
-    return copy;
-  }
-
-  public String getName() {
-    return name;
-  }
-
-  public String getType() {
-    return type;
-  }
-
-  public boolean isPrimaryKey() {
-    return primaryKey;
-  }
-
-  public void setPrimaryKey(boolean primaryKey) {
-    this.primaryKey = primaryKey;
-  }
-
-  public boolean isIdentity() {
-    return identity;
-  }
-
-  public void setIdentity(boolean identity) {
-    this.identity = identity;
-  }
-
-  public String getCheckConstraint() {
-    return checkConstraint;
-  }
-
-  public void setCheckConstraint(String checkConstraint) {
-    this.checkConstraint = checkConstraint;
-  }
-
-  public String getCheckConstraintName() {
-    return checkConstraintName;
-  }
-
-  public void setCheckConstraintName(String checkConstraintName) {
-    this.checkConstraintName = checkConstraintName;
-  }
-
-  public String getForeignKeyName() {
-    return foreignKeyName;
-  }
-
-  public void setForeignKeyName(String foreignKeyName) {
-    this.foreignKeyName = foreignKeyName;
-  }
-
-  public String getForeignKeyIndex() {
-    return foreignKeyIndex;
-  }
-
-  public void setForeignKeyIndex(String foreignKeyIndex) {
-    this.foreignKeyIndex = foreignKeyIndex;
-  }
-
-  public String getDefaultValue() {
-    return defaultValue;
-  }
-
-  public void setDefaultValue(String defaultValue) {
-    this.defaultValue = defaultValue;
-  }
-
-  public String getReferences() {
-    return references;
-  }
-
-  public void setReferences(String references) {
-    this.references = references;
-  }
-
-  public boolean isNotnull() {
-    return notnull;
-  }
-
-  public void setNotnull(boolean notnull) {
-    this.notnull = notnull;
-  }
-
-  public boolean isHistoryExclude() {
-    return historyExclude;
-  }
-
-  public void setHistoryExclude(boolean historyExclude) {
-    this.historyExclude = historyExclude;
-  }
-
-  public void setUnique(String unique) {
-    this.unique = unique;
-  }
-
-  public String getUnique() {
-    return unique;
-  }
-
-  /**
-   * Set unique specifically for OneToOne mapping.
-   * We need special DDL for this case for MsSqlServer.
-   */
-  public void setUniqueOneToOne(String uniqueOneToOne) {
-    this.uniqueOneToOne = uniqueOneToOne;
-  }
-
-  /**
-   * Return true if this is unique for a OneToOne.
-   */
-  public String getUniqueOneToOne() {
-    return uniqueOneToOne;
-  }
-
-  /**
-   * Return the column comment.
-   */
-  public String getComment() {
-    return comment;
-  }
-
-  /**
-   * Set the column comment.
-   */
-  public void setComment(String comment) {
-    this.comment = comment;
-  }
-
-  /**
-   * Set the draftOnly status for this column.
-   */
-  public void setDraftOnly(boolean draftOnly) {
-    this.draftOnly = draftOnly;
-  }
-
-  /**
-   * Return the draftOnly status for this column.
-   */
-  public boolean isDraftOnly() {
-    return draftOnly;
-  }
-
-  /**
-   * Return true if this column should be included in History DB triggers etc.
-   */
-  public boolean isIncludeInHistory() {
-    return !draftOnly && !historyExclude;
-  }
-
-  public Column createColumn() {
-
-    Column c = new Column();
-    c.setName(name);
-    c.setType(type);
-
-    if (notnull) c.setNotnull(true);
-    if (primaryKey) c.setPrimaryKey(true);
-    if (identity) c.setIdentity(true);
-    if (historyExclude) c.setHistoryExclude(true);
-
-    c.setCheckConstraint(checkConstraint);
-    c.setCheckConstraintName(checkConstraintName);
-    c.setReferences(references);
-    c.setForeignKeyName(foreignKeyName);
-    c.setForeignKeyIndex(foreignKeyIndex);
-    c.setDefaultValue(defaultValue);
-    c.setComment(comment);
-    c.setUnique(unique);
-    c.setUniqueOneToOne(uniqueOneToOne);
-
-    return c;
-  }
-
-  protected static boolean different(String val1, String val2) {
-    return (val1 == null) ? val2 != null : !val1.equals(val2);
-  }
-
-  private boolean hasValue(String val) {
-    return val != null && !val.isEmpty();
-  }
-
-  private boolean hasValue(Boolean val) {
-    return val != null;
-  }
-
-  private AlterColumn getAlterColumn(String tableName, boolean tableWithHistory) {
-    if (alterColumn == null) {
-      alterColumn = new AlterColumn();
-      alterColumn.setColumnName(name);
-      alterColumn.setTableName(tableName);
-      if (tableWithHistory) {
-        alterColumn.setWithHistory(Boolean.TRUE);
-      }
-    }
-    return alterColumn;
-  }
-
-  /**
-   * Compare the column meta data and return true if there is a change that means
-   * the history table column needs
-   */
-  public void compare(ModelDiff modelDiff, MTable table, MColumn newColumn) {
-
-    boolean tableWithHistory = table.isWithHistory();
-    String tableName = table.getName();
-
-    // set to null and check at the end
-    this.alterColumn = null;
-
-    boolean changeBaseAttribute = false;
-
-    if (historyExclude != newColumn.historyExclude) {
-      getAlterColumn(tableName, tableWithHistory).setHistoryExclude(newColumn.historyExclude);
-    }
-
-    if (different(type, newColumn.type)) {
-      changeBaseAttribute = true;
-      getAlterColumn(tableName, tableWithHistory).setType(newColumn.type);
-    }
-    if (notnull != newColumn.notnull) {
-      changeBaseAttribute = true;
-      getAlterColumn(tableName, tableWithHistory).setNotnull(newColumn.notnull);
-    }
-    if (different(defaultValue, newColumn.defaultValue)) {
-      AlterColumn alter = getAlterColumn(tableName, tableWithHistory);
-      if (newColumn.defaultValue == null) {
-        alter.setDefaultValue("DROP DEFAULT");
-      } else {
-        alter.setDefaultValue(newColumn.defaultValue);
-      }
-    }
-    if (different(comment, newColumn.comment)) {
-      AlterColumn alter = getAlterColumn(tableName, tableWithHistory);
-      alter.setComment(newColumn.comment);
-    }
-    if (different(checkConstraint, newColumn.checkConstraint)) {
-      AlterColumn alter = getAlterColumn(tableName, tableWithHistory);
-      if (hasValue(checkConstraint) && !hasValue(newColumn.checkConstraint)) {
-        alter.setDropCheckConstraint(checkConstraintName);
-      }
-      if (hasValue(newColumn.checkConstraint)) {
-        alter.setCheckConstraintName(newColumn.checkConstraintName);
-        alter.setCheckConstraint(newColumn.checkConstraint);
-      }
-    }
-    if (different(references, newColumn.references)) {
-      // foreign key change
-      AlterColumn alter = getAlterColumn(tableName, tableWithHistory);
-      if (hasValue(foreignKeyName)) {
-        alter.setDropForeignKey(foreignKeyName);
-      }
-      if (hasValue(foreignKeyIndex)) {
-        alter.setDropForeignKeyIndex(foreignKeyIndex);
-      }
-      if (hasValue(newColumn.references)) {
-        // add new foreign key constraint
-        alter.setReferences(newColumn.references);
-        alter.setForeignKeyName(newColumn.foreignKeyName);
-        alter.setForeignKeyIndex(newColumn.foreignKeyIndex);
-      }
-    }
-
-    if (different(unique, newColumn.unique)) {
-      AlterColumn alter = getAlterColumn(tableName, tableWithHistory);
-      if (hasValue(unique)) {
-        alter.setDropUnique(unique);
-      }
-      if (hasValue(newColumn.unique)) {
-        alter.setUnique(newColumn.unique);
-      }
-    }
-    if (different(uniqueOneToOne, newColumn.uniqueOneToOne)) {
-      AlterColumn alter = getAlterColumn(tableName, tableWithHistory);
-      if (hasValue(uniqueOneToOne)) {
-        alter.setDropUnique(uniqueOneToOne);
-      }
-      if (hasValue(newColumn.uniqueOneToOne)) {
-        alter.setUniqueOneToOne(newColumn.uniqueOneToOne);
-      }
-    }
-
-    if (alterColumn != null) {
-      modelDiff.addAlterColumn(alterColumn);
-      if (changeBaseAttribute) {
-        // support reverting these changes
-        alterColumn.setCurrentType(type);
-        alterColumn.setCurrentNotnull(notnull);
-      }
-    }
-  }
-
-  /**
-   * Apply changes based on the AlterColumn request.
-   */
-  public void apply(AlterColumn alterColumn) {
-
-    if (hasValue(alterColumn.getDropCheckConstraint())) {
-      checkConstraint = null;
-    }
-    if (hasValue(alterColumn.getDropForeignKey())) {
-      foreignKeyName = null;
-    }
-    if (hasValue(alterColumn.getDropForeignKeyIndex())) {
-      foreignKeyIndex = null;
-    }
-    if (hasValue(alterColumn.getDropUnique())) {
-      unique = null;
-      uniqueOneToOne = null;
-    }
-
-    if (hasValue(alterColumn.getType())) {
-      type = alterColumn.getType();
-    }
-    if (hasValue(alterColumn.isNotnull())) {
-      notnull = alterColumn.isNotnull();
-    }
-    if (hasValue(alterColumn.getDefaultValue())) {
-      defaultValue = alterColumn.getDefaultValue();
-    }
-    if (hasValue(alterColumn.getCheckConstraint())) {
-      checkConstraint = alterColumn.getCheckConstraint();
-    }
-    if (hasValue(alterColumn.getCheckConstraintName())) {
-      checkConstraintName = alterColumn.getCheckConstraintName();
-    }
-    if (hasValue(alterColumn.getUnique())) {
-      unique = alterColumn.getUnique();
-    }
-    if (hasValue(alterColumn.getUniqueOneToOne())) {
-      uniqueOneToOne = alterColumn.getUniqueOneToOne();
-    }
-    if (hasValue(alterColumn.getReferences())) {
-      references = alterColumn.getReferences();
-    }
-    if (hasValue(alterColumn.getForeignKeyName())) {
-      foreignKeyName = alterColumn.getForeignKeyName();
-    }
-    if (hasValue(alterColumn.getForeignKeyIndex())) {
-      foreignKeyIndex = alterColumn.getForeignKeyIndex();
-    }
-
-  }
-}
@@ -1,102 +0,0 @@
-package com.avaje.ebean.dbmigration.model;
-
-import com.avaje.ebean.dbmigration.migration.ForeignKey;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * A unique constraint for multiple columns.
- * <p>
- * Note that unique constraint on a single column is instead
- * a boolean flag on the associated MColumn.
- * </p>
- */
-public class MCompoundForeignKey {
-
-  private String name;
-  private final String referenceTable;
-  private final List<String> columns = new ArrayList<>();
-  private final List<String> referenceColumns = new ArrayList<>();
-  private String indexName;
-
-  public MCompoundForeignKey(String name, String referenceTable, String indexName) {
-    this.name = name;
-    this.referenceTable = referenceTable;
-    this.indexName = indexName;
-  }
-
-  /**
-   * Add a column pair of local and referenced column.
-   */
-  public void addColumnPair(String dbCol, String refColumn) {
-    columns.add(dbCol);
-    referenceColumns.add(refColumn);
-  }
-
-  /**
-   * Create and return an ForeignKey migration element.
-   */
-  public ForeignKey createForeignKey() {
-    ForeignKey fk = new ForeignKey();
-    fk.setName(name);
-    fk.setIndexName(indexName);
-    fk.setColumnNames(toColumnNames(columns));
-    fk.setRefColumnNames(toColumnNames(referenceColumns));
-    fk.setRefTableName(referenceTable);
-    return fk;
-  }
-
-  /**
-   * Add a counter to the foreign key and index names to avoid duplication.
-   */
-  public void addNameSuffix(int counter) {
-    this.name = name + "_" + counter;
-    this.indexName = indexName + "_" + counter;
-  }
-
-  /**
-   * Return the foreign key name.
-   */
-  public String getName() {
-    return name;
-  }
-
-  /**
-   * Return the index name.
-   */
-  public String getIndexName() {
-    return indexName;
-  }
-
-  /**
-   * Return the columns making up the foreign key in order.
-   */
-  public List<String> getColumns() {
-    return columns;
-  }
-
-  /**
-   * Set the associated index name. Note that setting to null has the effect
-   * of indicating an associated index should not be created for this foreign key.
-   */
-  public void setIndexName(String indexName) {
-    this.indexName = indexName;
-  }
-
-  /**
-   * Return as an array of string column names.
-   */
-  private String toColumnNames(List<String> columns) {
-
-    StringBuilder sb = new StringBuilder(40);
-    for (int i = 0; i < columns.size(); i++) {
-      if (i > 0) {
-        sb.append(",");
-      }
-      sb.append(columns.get(i));
-    }
-    return sb.toString();
-  }
-
-}
@@ -1,50 +0,0 @@
-package com.avaje.ebean.dbmigration.model;
-
-/**
- * A unique constraint for multiple columns.
- * <p>
- * Note that unique constraint on a single column is instead
- * a boolean flag on the associated MColumn.
- * </p>
- */
-public class MCompoundUniqueConstraint {
-
-  private final String name;
-
-  /**
-   * Flag if true indicates this was specifically created for a OneToOne mapping.
-   */
-  private final boolean oneToOne;
-
-  /**
-   * The columns combined to be unique.
-   */
-  private final String[] columns;
-
-  public MCompoundUniqueConstraint(String[] columns, boolean oneToOne, String name) {
-    this.name = name;
-    this.columns = columns;
-    this.oneToOne = oneToOne;
-  }
-
-  /**
-   * Return the columns for this unique constraint.
-   */
-  public String[] getColumns() {
-    return columns;
-  }
-
-  /**
-   * Return true if this unqiue constraint is specifically for OneToOne mapping.
-   */
-  public boolean isOneToOne() {
-    return oneToOne;
-  }
-
-  /**
-   * Return the constraint name.
-   */
-  public String getName() {
-    return name;
-  }
-}
@@ -1,639 +0,0 @@
-package com.avaje.ebean.dbmigration.model;
-
-import com.avaje.ebean.dbmigration.migration.AddColumn;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.AddTableComment;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.Column;
-import com.avaje.ebean.dbmigration.migration.CreateTable;
-import com.avaje.ebean.dbmigration.migration.DropColumn;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.migration.DropTable;
-import com.avaje.ebean.dbmigration.migration.IdentityType;
-import com.avaje.ebean.dbmigration.migration.UniqueConstraint;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Holds the logical model for a given Table and everything associated to it.
- * <p>
- * This effectively represents a table, its columns and all associated
- * constraints, foreign keys and indexes.
- * </p>
- * <p>
- * Migrations can be applied to this such that it represents the state
- * of a given table after various migrations have been applied.
- * </p>
- * <p>
- * This table model can also be derived from the EbeanServer bean descriptor
- * and associated properties.
- * </p>
- */
-public class MTable {
-
-  private static final Logger logger = LoggerFactory.getLogger(MTable.class);
-
-  /**
-   * Table name.
-   */
-  private final String name;
-
-  /**
-   * The associated draft table.
-   */
-  private MTable draftTable;
-
-  /**
-   * Marked true for draft tables. These need to have their FK references adjusted
-   * after all the draft tables have been identified.
-   */
-  private boolean draft;
-
-  /**
-   * Primary key name.
-   */
-  private String pkName;
-
-  /**
-   * Table comment.
-   */
-  private String comment;
-
-  /**
-   * Tablespace to use.
-   */
-  private String tablespace;
-
-  /**
-   * Tablespace to use for indexes on this table.
-   */
-  private String indexTablespace;
-
-  /**
-   * If set then this overrides the platform default so for UUID generated values
-   * or DB's supporting both sequences and autoincrement.
-   */
-  private IdentityType identityType;
-
-  /**
-   * DB sequence name.
-   */
-  private String sequenceName;
-  private int sequenceInitial;
-  private int sequenceAllocate;
-
-  /**
-   * If set to true this table should has history support.
-   */
-  private boolean withHistory;
-
-  /**
-   * The columns on the table.
-   */
-  private Map<String, MColumn> columns = new LinkedHashMap<>();
-
-  /**
-   * Compound unique constraints.
-   */
-  private List<MCompoundUniqueConstraint> uniqueConstraints = new ArrayList<>();
-
-  /**
-   * Compound foreign keys.
-   */
-  private List<MCompoundForeignKey> compoundKeys = new ArrayList<>();
-
-  /**
-   * Column name for the 'When created' column. This can be used for the initial effective start date when adding
-   * history to an existing table and maps to a @WhenCreated or @CreatedTimestamp column.
-   */
-  private String whenCreatedColumn;
-
-  /**
-   * Temporary - holds addColumn settings.
-   */
-  private AddColumn addColumn;
-
-  private List<String> droppedColumns = new ArrayList<>();
-
-  /**
-   * Create a copy of this table structure as a 'draft' table.
-   * <p>
-   * Note that both tables contain @DraftOnly MColumns and these are filtered out
-   * later when creating the CreateTable object.
-   */
-  public MTable createDraftTable() {
-
-    draftTable = new MTable(name + "_draft");
-    draftTable.draft = true;
-    draftTable.whenCreatedColumn = whenCreatedColumn;
-    // compoundKeys
-    // compoundUniqueConstraints
-    draftTable.identityType = identityType;
-
-    for (MColumn col : allColumns()) {
-      draftTable.addColumn(col.copyForDraft());
-    }
-
-    return draftTable;
-  }
-
-  /**
-   * Construct for migration.
-   */
-  public MTable(CreateTable createTable) {
-    this.name = createTable.getName();
-    this.pkName = createTable.getPkName();
-    this.comment = createTable.getComment();
-    this.tablespace = createTable.getTablespace();
-    this.indexTablespace = createTable.getIndexTablespace();
-    this.withHistory = Boolean.TRUE.equals(createTable.isWithHistory());
-    this.draft = Boolean.TRUE.equals(createTable.isDraft());
-    this.sequenceName = createTable.getSequenceName();
-    this.sequenceInitial = toInt(createTable.getSequenceInitial());
-    this.sequenceAllocate = toInt(createTable.getSequenceAllocate());
-    List<Column> cols = createTable.getColumn();
-    for (Column column : cols) {
-      addColumn(column);
-    }
-  }
-
-
-  /**
-   * Construct typically from EbeanServer meta data.
-   */
-  public MTable(String name) {
-    this.name = name;
-  }
-
-  /**
-   * Return the DropTable migration for this table.
-   */
-  public DropTable dropTable() {
-    DropTable dropTable = new DropTable();
-    dropTable.setName(name);
-    return dropTable;
-  }
-
-  /**
-   * Return the CreateTable migration for this table.
-   */
-  public CreateTable createTable() {
-
-    CreateTable createTable = new CreateTable();
-    createTable.setName(name);
-    createTable.setPkName(pkName);
-    createTable.setComment(comment);
-    createTable.setTablespace(tablespace);
-    createTable.setIndexTablespace(indexTablespace);
-    createTable.setSequenceName(sequenceName);
-    createTable.setSequenceInitial(toBigInteger(sequenceInitial));
-    createTable.setSequenceAllocate(toBigInteger(sequenceAllocate));
-    createTable.setIdentityType(identityType);
-    if (withHistory) {
-      createTable.setWithHistory(Boolean.TRUE);
-    }
-    if (draft) {
-      createTable.setDraft(Boolean.TRUE);
-    }
-
-    for (MColumn column : allColumns()) {
-      // filter out draftOnly columns from the base table
-      if (draft || !column.isDraftOnly()) {
-        createTable.getColumn().add(column.createColumn());
-      }
-    }
-
-    for (MCompoundForeignKey compoundKey : compoundKeys) {
-      createTable.getForeignKey().add(compoundKey.createForeignKey());
-    }
-
-    for (MCompoundUniqueConstraint constraint : uniqueConstraints) {
-      UniqueConstraint uq = new UniqueConstraint();
-      uq.setName(constraint.getName());
-      String[] columns = constraint.getColumns();
-      StringBuilder sb = new StringBuilder();
-      for (int i = 0; i < columns.length; i++) {
-        if (i > 0) {
-          sb.append(",");
-        }
-        sb.append(columns[i]);
-      }
-      uq.setColumnNames(sb.toString());
-      createTable.getUniqueConstraint().add(uq);
-    }
-
-    return createTable;
-  }
-
-  /**
-   * Compare to another version of the same table to perform a diff.
-   */
-  public void compare(ModelDiff modelDiff, MTable newTable) {
-
-    if (withHistory != newTable.withHistory) {
-      if (withHistory) {
-        DropHistoryTable dropHistoryTable = new DropHistoryTable();
-        dropHistoryTable.setBaseTable(name);
-        modelDiff.addDropHistoryTable(dropHistoryTable);
-
-      } else {
-        AddHistoryTable addHistoryTable = new AddHistoryTable();
-        addHistoryTable.setBaseTable(name);
-        modelDiff.addAddHistoryTable(addHistoryTable);
-      }
-    }
-
-    addColumn = null;
-
-    Map<String, MColumn> newColumnMap = newTable.getColumns();
-
-    // compare newColumns to existing columns (look for new and diff columns)
-    for (MColumn newColumn : newColumnMap.values()) {
-      MColumn localColumn = getColumn(newColumn.getName());
-      if (localColumn == null) {
-        // can ignore if draftOnly column and non-draft table
-        if (!newColumn.isDraftOnly() || draft) {
-          diffNewColumn(newColumn);
-        }
-      } else {
-        localColumn.compare(modelDiff, this, newColumn);
-      }
-    }
-
-    // compare existing columns (look for dropped columns)
-    for (MColumn existingColumn : allColumns()) {
-      MColumn newColumn = newColumnMap.get(existingColumn.getName());
-      if (newColumn == null) {
-        diffDropColumn(modelDiff, existingColumn);
-      } else if (newColumn.isDraftOnly() && !draft) {
-        // effectively a drop column (draft only column on a non-draft table)
-        logger.trace("... drop column {} from table {} as now draftOnly", newColumn.getName(), name);
-        diffDropColumn(modelDiff, existingColumn);
-      }
-    }
-
-    if (addColumn != null) {
-      modelDiff.addAddColumn(addColumn);
-    }
-
-    if (MColumn.different(comment, newTable.comment)) {
-      AddTableComment addTableComment = new AddTableComment();
-      addTableComment.setName(name);
-      addTableComment.setComment(newTable.comment);
-      modelDiff.addTableComment(addTableComment);
-    }
-  }
-
-  /**
-   * Apply AddColumn migration.
-   */
-  public void apply(AddColumn addColumn) {
-    checkTableName(addColumn.getTableName());
-    for (Column column : addColumn.getColumn()) {
-      addColumn(column);
-    }
-  }
-
-  /**
-   * Apply AddColumn migration.
-   */
-  public void apply(AlterColumn alterColumn) {
-    checkTableName(alterColumn.getTableName());
-    String columnName = alterColumn.getColumnName();
-    MColumn existingColumn = getColumn(columnName);
-    if (existingColumn == null) {
-      throw new IllegalStateException("Column [" + columnName + "] does not exist for AlterColumn change?");
-    }
-    existingColumn.apply(alterColumn);
-  }
-
-  /**
-   * Apply DropColumn migration.
-   */
-  public void apply(DropColumn dropColumn) {
-    checkTableName(dropColumn.getTableName());
-    MColumn removed = columns.remove(dropColumn.getColumnName());
-    if (removed == null) {
-      throw new IllegalStateException("Column [" + dropColumn.getColumnName() + "] does not exist for DropColumn change on table [" + dropColumn.getTableName() + "]?");
-    }
-  }
-
-  public String getName() {
-    return name;
-  }
-
-  /**
-   * Return true if this table is a 'Draft' table.
-   */
-  public boolean isDraft() {
-    return draft;
-  }
-
-  public void setPkName(String pkName) {
-    this.pkName = pkName;
-  }
-
-  public String getComment() {
-    return comment;
-  }
-
-  public void setComment(String comment) {
-    this.comment = comment;
-  }
-
-  public String getTablespace() {
-    return tablespace;
-  }
-
-  public String getIndexTablespace() {
-    return indexTablespace;
-  }
-
-  public boolean isWithHistory() {
-    return withHistory;
-  }
-
-  public MTable setWithHistory(boolean withHistory) {
-    this.withHistory = withHistory;
-    return this;
-  }
-
-  public List<String> allHistoryColumns(boolean includeDropped) {
-
-    List<String> columnNames = new ArrayList<>(columns.size());
-    for (MColumn column : columns.values()) {
-      if (column.isIncludeInHistory()) {
-        columnNames.add(column.getName());
-      }
-    }
-    if (includeDropped && !droppedColumns.isEmpty()) {
-      for (String droppedColumn : droppedColumns) {
-        columnNames.add(droppedColumn);
-      }
-    }
-    return columnNames;
-  }
-
-  /**
-   * Return all the columns (excluding columns marked as dropped).
-   */
-  public Collection<MColumn> allColumns() {
-
-    return columns.values();
-  }
-
-  /**
-   * Return the column by name.
-   */
-  public MColumn getColumn(String name) {
-    return columns.get(name);
-  }
-
-  private Map<String, MColumn> getColumns() {
-    return columns;
-  }
-
-  public List<MCompoundUniqueConstraint> getUniqueConstraints() {
-    return uniqueConstraints;
-  }
-
-  public List<MCompoundForeignKey> getCompoundKeys() {
-    return compoundKeys;
-  }
-
-  public void setSequenceName(String sequenceName) {
-    this.sequenceName = sequenceName;
-  }
-
-  public void setSequenceInitial(int sequenceInitial) {
-    this.sequenceInitial = sequenceInitial;
-  }
-
-  public void setSequenceAllocate(int sequenceAllocate) {
-    this.sequenceAllocate = sequenceAllocate;
-  }
-
-  public void setWhenCreatedColumn(String whenCreatedColumn) {
-    this.whenCreatedColumn = whenCreatedColumn;
-  }
-
-  public String getWhenCreatedColumn() {
-    return whenCreatedColumn;
-  }
-
-  /**
-   * Set the identity type to use for this table.
-   * <p>
-   * If set then this overrides the platform default so for UUID generated values
-   * or DB's supporting both sequences and autoincrement.
-   */
-  public void setIdentityType(IdentityType identityType) {
-    this.identityType = identityType;
-  }
-
-  /**
-   * Return the list of columns that make the primary key.
-   */
-  public List<MColumn> primaryKeyColumns() {
-    List<MColumn> pk = new ArrayList<>(3);
-    for (MColumn column : allColumns()) {
-      if (column.isPrimaryKey()) {
-        pk.add(column);
-      }
-    }
-    return pk;
-  }
-
-  private void checkTableName(String tableName) {
-    if (!name.equals(tableName)) {
-      throw new IllegalArgumentException("addColumn tableName [" + tableName + "] does not match [" + name + "]");
-    }
-  }
-
-  /**
-   * Add a column via migration data.
-   */
-  private void addColumn(Column column) {
-    columns.put(column.getName(), new MColumn(column));
-  }
-
-  /**
-   * Add a model column (typically from EbeanServer meta data).
-   */
-  public void addColumn(MColumn column) {
-    columns.put(column.getName(), column);
-  }
-
-  /**
-   * Add a unique constraint.
-   */
-  public void addUniqueConstraint(String[] columns, boolean oneToOne, String constraintName) {
-    uniqueConstraints.add(new MCompoundUniqueConstraint(columns, oneToOne, constraintName));
-  }
-
-  /**
-   * Add a unique constraint.
-   */
-  public void addUniqueConstraint(List<MColumn> columns, boolean oneToOne, String constraintName) {
-    String[] cols = new String[columns.size()];
-    for (int i = 0; i < columns.size(); i++) {
-      cols[i] = columns.get(i).getName();
-    }
-    addUniqueConstraint(cols, oneToOne, constraintName);
-  }
-
-  /**
-   * Add a compound foreign key.
-   */
-  public void addForeignKey(MCompoundForeignKey compoundKey) {
-    compoundKeys.add(compoundKey);
-  }
-
-  /**
-   * Add a column checking if it already exists and if so return the existing column.
-   * Sometimes the case for a primaryKey that is also a foreign key.
-   */
-  public MColumn addColumn(String dbCol, String columnDefn, boolean notnull) {
-
-    MColumn existingColumn = getColumn(dbCol);
-    if (existingColumn != null) {
-      if (notnull) {
-        existingColumn.setNotnull(true);
-      }
-      return existingColumn;
-    }
-
-    MColumn newCol = new MColumn(dbCol, columnDefn, notnull);
-    addColumn(newCol);
-    return newCol;
-  }
-
-  /**
-   * Add a 'new column' to the AddColumn migration object.
-   */
-  private void diffNewColumn(MColumn newColumn) {
-
-    if (addColumn == null) {
-      addColumn = new AddColumn();
-      addColumn.setTableName(name);
-      if (withHistory) {
-        // These addColumns need to occur on the history
-        // table as well as the base table
-        addColumn.setWithHistory(Boolean.TRUE);
-      }
-    }
-
-    addColumn.getColumn().add(newColumn.createColumn());
-  }
-
-  /**
-   * Add a 'drop column' to the diff.
-   */
-  private void diffDropColumn(ModelDiff modelDiff, MColumn existingColumn) {
-
-    DropColumn dropColumn = new DropColumn();
-    dropColumn.setTableName(name);
-    dropColumn.setColumnName(existingColumn.getName());
-    if (withHistory && !existingColumn.isHistoryExclude()) {
-      // These dropColumns should occur on the history
-      // table as well as the base table
-      dropColumn.setWithHistory(Boolean.TRUE);
-    }
-
-    modelDiff.addDropColumn(dropColumn);
-  }
-
-  /**
-   * Register a pending un-applied drop column.
-   * <p>
-   * This means this column still needs to be included in history views/triggers etc even
-   * though it is not part of the current model.
-   */
-  public void registerPendingDropColumn(String columnName) {
-    droppedColumns.add(columnName);
-  }
-
-  private int toInt(BigInteger value) {
-    return (value == null) ? 0 : value.intValue();
-  }
-
-  private BigInteger toBigInteger(int value) {
-    return (value == 0) ? null : BigInteger.valueOf(value);
-  }
-
-  /**
-   * Check if there are duplicate foreign keys.
-   * <p>
-   * This can occur when an ManyToMany relates back to itself.
-   * </p>
-   */
-  public void checkDuplicateForeignKeys() {
-
-    if (hasDuplicateForeignKeys()) {
-      int counter = 1;
-      for (MCompoundForeignKey fk : compoundKeys) {
-        fk.addNameSuffix(counter++);
-      }
-    }
-  }
-
-  /**
-   * Return true if the foreign key names are not unique.
-   */
-  private boolean hasDuplicateForeignKeys() {
-    Set<String> fkNames = new HashSet<>();
-    for (MCompoundForeignKey fk : compoundKeys) {
-      if (!fkNames.add(fk.getName())) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Adjust the references (FK) if it should relate to a draft table.
-   */
-  public void adjustReferences(ModelContainer modelContainer) {
-
-    Collection<MColumn> cols = allColumns();
-    for (MColumn col : cols) {
-      String references = col.getReferences();
-      if (references != null) {
-        String baseTable = extractBaseTable(references);
-        MTable refBaseTable = modelContainer.getTable(baseTable);
-        if (refBaseTable.draftTable != null) {
-          // change references to another associated 'draft' table
-          String newReferences = deriveReferences(references, refBaseTable.draftTable.getName());
-          col.setReferences(newReferences);
-        }
-      }
-    }
-  }
-
-  /**
-   * Return the base table name from references (table.column).
-   */
-  private String extractBaseTable(String references) {
-    int lastDot = references.lastIndexOf('.');
-    return references.substring(0, lastDot);
-  }
-
-  /**
-   * Return the new references using the given draftTableName.
-   * (The referenced column is the same as before).
-   */
-  private String deriveReferences(String references, String draftTableName) {
-    int lastDot = references.lastIndexOf('.');
-    return draftTableName + "." + references.substring(lastDot + 1);
-  }
-
-}
@@ -1,314 +0,0 @@
-package com.avaje.ebean.dbmigration.model;
-
-import com.avaje.ebean.dbmigration.migration.AddColumn;
-import com.avaje.ebean.dbmigration.migration.AddHistoryTable;
-import com.avaje.ebean.dbmigration.migration.AlterColumn;
-import com.avaje.ebean.dbmigration.migration.ChangeSet;
-import com.avaje.ebean.dbmigration.migration.ChangeSetType;
-import com.avaje.ebean.dbmigration.migration.CreateIndex;
-import com.avaje.ebean.dbmigration.migration.CreateTable;
-import com.avaje.ebean.dbmigration.migration.DropColumn;
-import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
-import com.avaje.ebean.dbmigration.migration.DropIndex;
-import com.avaje.ebean.dbmigration.migration.DropTable;
-import com.avaje.ebean.dbmigration.migration.Migration;
-
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Holds all the tables, views, indexes etc that represent the model.
- * <p>
- * Migration changeSets can be applied to the model.
- * </p>
- */
-public class ModelContainer {
-
-  /**
-   * All the tables in the model.
-   */
-  private final Map<String, MTable> tables = new LinkedHashMap<>();
-
-  /**
-   * All the non unique non foreign key indexes.
-   */
-  private final Map<String, MIndex> indexes = new LinkedHashMap<>();
-
-  private final PendingDrops pendingDrops = new PendingDrops();
-
-  public ModelContainer() {
-  }
-
-  /**
-   * Adjust the FK references on all the draft tables.
-   */
-  public void adjustDraftReferences() {
-    for (MTable table : this.tables.values()) {
-      if (table.isDraft()) {
-        table.adjustReferences(this);
-      }
-    }
-  }
-
-  /**
-   * Return the map of all the tables.
-   */
-  public Map<String, MTable> getTables() {
-    return tables;
-  }
-
-  /**
-   * Return the map of all the non unique non fk indexes.
-   */
-  public Map<String, MIndex> getIndexes() {
-    return indexes;
-  }
-
-  /**
-   * Return the table by name.
-   */
-  public MTable getTable(String tableName) {
-    return tables.get(tableName);
-  }
-
-  /**
-   * Return the index by name.
-   */
-  public MIndex getIndex(String indexName) {
-    return indexes.get(indexName);
-  }
-
-  /**
-   * Apply a migration with associated changeSets to the model.
-   */
-  public void apply(Migration migration, MigrationVersion version) {
-
-    List<ChangeSet> changeSets = migration.getChangeSet();
-    for (ChangeSet changeSet : changeSets) {
-      boolean pending = changeSet.getType() == ChangeSetType.PENDING_DROPS;
-      if (pending) {
-        // un-applied drop columns etc
-        pendingDrops.add(version, changeSet);
-
-      } else if (isDropsFor(changeSet)) {
-        pendingDrops.appliedDropsFor(changeSet);
-      }
-      if (!isDropsFor(changeSet)) {
-        applyChangeSet(changeSet);
-      }
-    }
-  }
-
-  /**
-   * Return true if the changeSet contains drops for a previous PENDING_DROPS changeSet.
-   */
-  private boolean isDropsFor(ChangeSet changeSet) {
-    return changeSet.getDropsFor() != null;
-  }
-
-  /**
-   * Apply a changeSet to the model.
-   */
-  protected void applyChangeSet(ChangeSet changeSet) {
-
-    List<Object> changeSetChildren = changeSet.getChangeSetChildren();
-    for (Object change : changeSetChildren) {
-      if (change instanceof CreateTable) {
-        applyChange((CreateTable) change);
-      } else if (change instanceof DropTable) {
-        applyChange((DropTable) change);
-      } else if (change instanceof AlterColumn) {
-        applyChange((AlterColumn) change);
-      } else if (change instanceof AddColumn) {
-        applyChange((AddColumn) change);
-      } else if (change instanceof DropColumn) {
-        applyChange((DropColumn) change);
-      } else if (change instanceof CreateIndex) {
-        applyChange((CreateIndex) change);
-      } else if (change instanceof DropIndex) {
-        applyChange((DropIndex) change);
-      } else if (change instanceof AddHistoryTable) {
-        applyChange((AddHistoryTable) change);
-      } else if (change instanceof DropHistoryTable) {
-        applyChange((DropHistoryTable) change);
-      }
-    }
-  }
-
-  /**
-   * Set the withHistory flag on the associated base table.
-   */
-  private void applyChange(AddHistoryTable change) {
-
-    MTable table = tables.get(change.getBaseTable());
-    if (table == null) {
-      throw new IllegalStateException("Table [" + change.getBaseTable() + "] does not exist in model?");
-    }
-    table.setWithHistory(true);
-  }
-
-  /**
-   * Unset the withHistory flag on the associated base table.
-   */
-  private void applyChange(DropHistoryTable change) {
-
-    MTable table = tables.get(change.getBaseTable());
-    if (table == null) {
-      throw new IllegalStateException("Table [" + change.getBaseTable() + "] does not exist in model?");
-    }
-    table.setWithHistory(false);
-  }
-
-  /**
-   * Apply a CreateTable change to the model.
-   */
-  protected void applyChange(CreateTable createTable) {
-    String tableName = createTable.getName();
-    if (tables.containsKey(tableName)) {
-      throw new IllegalStateException("Table [" + tableName + "] already exists in model?");
-    }
-    MTable table = new MTable(createTable);
-    tables.put(tableName, table);
-  }
-
-  /**
-   * Apply a DropTable change to the model.
-   */
-  protected void applyChange(DropTable dropTable) {
-    String tableName = dropTable.getName();
-    if (!tables.containsKey(tableName)) {
-      throw new IllegalStateException("Table [" + tableName + "] does not exists in model?");
-    }
-    tables.remove(tableName);
-  }
-
-  /**
-   * Apply a CreateTable change to the model.
-   */
-  protected void applyChange(CreateIndex createIndex) {
-    String indexName = createIndex.getIndexName();
-    if (indexes.containsKey(indexName)) {
-      throw new IllegalStateException("Index [" + indexName + "] already exists in model?");
-    }
-    MIndex index = new MIndex(createIndex);
-    indexes.put(createIndex.getIndexName(), index);
-  }
-
-  /**
-   * Apply a DropTable change to the model.
-   */
-  protected void applyChange(DropIndex dropIndex) {
-    String name = dropIndex.getIndexName();
-    if (!indexes.containsKey(name)) {
-      throw new IllegalStateException("Index [" + name + "] does not exist in model?");
-    }
-    indexes.remove(name);
-  }
-
-
-  /**
-   * Apply a AddColumn change to the model.
-   */
-  protected void applyChange(AddColumn addColumn) {
-    MTable table = tables.get(addColumn.getTableName());
-    if (table == null) {
-      throw new IllegalStateException("Table [" + addColumn.getTableName() + "] does not exist in model?");
-    }
-    table.apply(addColumn);
-  }
-
-  /**
-   * Apply a AddColumn change to the model.
-   */
-  protected void applyChange(AlterColumn alterColumn) {
-    MTable table = tables.get(alterColumn.getTableName());
-    if (table == null) {
-      throw new IllegalStateException("Table [" + alterColumn.getTableName() + "] does not exist in model?");
-    }
-    table.apply(alterColumn);
-  }
-
-  /**
-   * Apply a DropColumn change to the model.
-   */
-  protected void applyChange(DropColumn dropColumn) {
-    MTable table = tables.get(dropColumn.getTableName());
-    if (table == null) {
-      throw new IllegalStateException("Table [" + dropColumn.getTableName() + "] does not exist in model?");
-    }
-    table.apply(dropColumn);
-  }
-
-  /**
-   * Add a table (typically from reading EbeanServer meta data).
-   */
-  public MTable addTable(MTable table) {
-    return tables.put(table.getName(), table);
-  }
-
-  /**
-   * Add a single column index.
-   */
-  public void addIndex(String indexName, String tableName, String columnName) {
-
-    indexes.put(indexName, new MIndex(indexName, tableName, columnName));
-  }
-
-  /**
-   * Add a multi column index.
-   */
-  public void addIndex(String indexName, String tableName, String[] columnNames) {
-
-    indexes.put(indexName, new MIndex(indexName, tableName, columnNames));
-  }
-
-  /**
-   * Return the list of versions containing un-applied pending drops.
-   */
-  public List<String> getPendingDrops() {
-    return pendingDrops.pendingDrops();
-  }
-
-  /**
-   * Return the migration for the pending drops for a given version.
-   */
-  public Migration migrationForPendingDrop(String pendingVersion) {
-    return pendingDrops.migrationForVersion(pendingVersion);
-  }
-
-  /**
-   * Register the drop columns on history tables that have not been applied yet.
-   */
-  public void registerPendingHistoryDropColumns(ModelContainer newModel) {
-    pendingDrops.registerPendingHistoryDropColumns(newModel);
-  }
-
-  /**
-   * Register any pending drop columns on history tables.  These columns are now not in the current
-   * logical model but we still need to include them in the history views and triggers until they
-   * are actually dropped.
-   */
-  public void registerPendingHistoryDropColumns(ChangeSet changeSet) {
-    for (Object change : changeSet.getChangeSetChildren()) {
-      if (change instanceof DropColumn) {
-        DropColumn dropColumn = (DropColumn) change;
-        if (Boolean.TRUE.equals(dropColumn.isWithHistory())) {
-          registerPendingDropColumn(dropColumn);
-        }
-      }
-    }
-  }
-
-  /**
-   * Register a drop column on a history tables that has not been applied yet.
-   */
-  private void registerPendingDropColumn(DropColumn dropColumn) {
-
-    MTable table = getTable(dropColumn.getTableName());
-    if (table == null) {
-      throw new IllegalArgumentException("Table [" + dropColumn.getTableName() + "] not found?");
-    }
-    table.registerPendingDropColumn(dropColumn.getColumnName());
-  }
-}
@@ -1,131 +0,0 @@
-package com.avaje.ebean.dbmigration.model;
-
-import com.avaje.ebean.config.DbMigrationConfig;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.config.dbplatform.DatabasePlatform;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
-import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
-import com.avaje.ebean.dbmigration.migration.ChangeSet;
-import com.avaje.ebean.dbmigration.migration.ChangeSetType;
-import com.avaje.ebean.dbmigration.migration.Migration;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.Writer;
-import java.util.List;
-
-/**
- * Writes migration changes as platform specific DDL.
- */
-public class PlatformDdlWriter {
-
-  private static final Logger logger = LoggerFactory.getLogger(PlatformDdlWriter.class);
-
-  private final ServerConfig serverConfig;
-
-  private final DatabasePlatform platform;
-
-  private final String platformPrefix;
-
-  private final DbMigrationConfig config;
-
-  public PlatformDdlWriter(DatabasePlatform platform, ServerConfig serverConfig, String platformPrefix, DbMigrationConfig config) {
-    this.platform = platform;
-    this.serverConfig = serverConfig;
-    this.platformPrefix = platformPrefix;
-    this.config = config;
-  }
-
-  /**
-   * Write the migration as platform specific ddl.
-   */
-  public void processMigration(Migration dbMigration, DdlWrite write, File writePath, String fullVersion) throws IOException {
-
-    DdlHandler handler = handler();
-
-    List<ChangeSet> changeSets = dbMigration.getChangeSet();
-    for (ChangeSet changeSet : changeSets) {
-      if (isApply(changeSet)) {
-        handler.generate(write, changeSet);
-      }
-    }
-    handler.generateExtra(write);
-
-    writePlatformDdl(write, writePath, fullVersion);
-  }
-
-  /**
-   * Return true if the changeSet is APPLY and not empty.
-   */
-  private boolean isApply(ChangeSet changeSet) {
-    return changeSet.getType() == ChangeSetType.APPLY && !changeSet.getChangeSetChildren().isEmpty();
-  }
-
-  /**
-   * Write the ddl files.
-   */
-  protected void writePlatformDdl(DdlWrite write, File resourcePath, String fullVersion) throws IOException {
-
-    if (!write.isApplyEmpty()) {
-      FileWriter applyWriter = createWriter(resourcePath, fullVersion, config.getApplySuffix());
-      try {
-        writeApplyDdl(applyWriter, write);
-        applyWriter.flush();
-      } finally {
-        applyWriter.close();
-      }
-    }
-  }
-
-  protected FileWriter createWriter(File path, String fullVersion, String suffix) throws IOException {
-
-    File applyFile = new File(path, fullVersion + suffix);
-    return new FileWriter(applyFile);
-  }
-
-  /**
-   * Write the 'Apply' DDL buffers to the writer.
-   */
-  protected void writeApplyDdl(Writer writer, DdlWrite write) throws IOException {
-
-    // merge the apply buffers in the appropriate order
-    prependDropDependencies(writer, write.applyDropDependencies());
-    writer.append("-- apply changes\n");
-    writer.append(write.apply().getBuffer());
-    writer.append(write.applyForeignKeys().getBuffer());
-    writer.append(write.applyHistory().getBuffer());
-  }
-
-  private void prependDropDependencies(Writer writer, DdlBuffer buffer) throws IOException {
-    if (!buffer.isEmpty()) {
-      writer.append("-- drop dependencies\n");
-      writer.append(buffer.getBuffer());
-      writer.append("\n");
-    }
-  }
-
-  /**
-   * Return the platform specific DdlHandler (to generate DDL).
-   */
-  protected DdlHandler handler() {
-    return platform.createDdlHandler(serverConfig);
-  }
-
-  /**
-   * Return a sub directory (for multi-platform ddl generation).
-   */
-  public File subPath(File path, String suffix) {
-    File subPath = new File(path, suffix);
-    if (!subPath.exists()) {
-      if (!subPath.mkdirs()) {
-        logger.error("failed to create directories for " + subPath.getAbsolutePath());
-      }
-    }
-    return subPath;
-  }
-
-}
@@ -1,101 +0,0 @@
-package com.avaje.ebean.dbmigration.model.build;
-
-import com.avaje.ebean.config.dbplatform.DbPlatformType;
-import com.avaje.ebean.config.dbplatform.IdType;
-import com.avaje.ebean.dbmigration.migration.IdentityType;
-import com.avaje.ebean.dbmigration.model.MColumn;
-import com.avaje.ebean.dbmigration.model.MTable;
-import com.avaje.ebean.dbmigration.model.visitor.BeanVisitor;
-import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
-import com.avaje.ebeaninternal.server.deploy.BeanProperty;
-import com.avaje.ebeaninternal.server.deploy.InheritInfo;
-
-/**
- * Used to build the Model objects MTable etc.
- */
-public class ModelBuildBeanVisitor implements BeanVisitor {
-
-  private final ModelBuildContext ctx;
-
-  public ModelBuildBeanVisitor(ModelBuildContext ctx) {
-    this.ctx = ctx;
-  }
-
-  /**
-   * Return the PropertyVisitor used to read all the property meta data
-   * and in this case add MColumn objects to the model.
-   * <p>
-   * This creates an MTable and adds it to the model.
-   * </p>
-   */
-  public ModelBuildPropertyVisitor visitBean(BeanDescriptor<?> descriptor) {
-
-    if (!descriptor.isInheritanceRoot()) {
-      return null;
-    }
-
-    MTable table = new MTable(descriptor.getBaseTable());
-    table.setComment(descriptor.getDbComment());
-    if (descriptor.isHistorySupport()) {
-      table.setWithHistory(true);
-      BeanProperty whenCreated = descriptor.getWhenCreatedProperty();
-      if (whenCreated != null) {
-        table.setWhenCreatedColumn(whenCreated.getDbColumn());
-      }
-    }
-    setIdentity(descriptor, table);
-
-    // add the table to the model
-    ctx.addTable(table);
-
-    InheritInfo inheritInfo = descriptor.getInheritInfo();
-    if (inheritInfo != null && inheritInfo.isRoot()) {
-      // add the discriminator column
-      String discColumn = inheritInfo.getDiscriminatorColumn();
-      DbPlatformType dbType = ctx.getDbTypeMap().get(inheritInfo.getDiscriminatorType());
-      String discDbType = dbType.renderType(inheritInfo.getDiscriminatorLength(), 0);
-
-      table.addColumn(new MColumn(discColumn, discDbType, true));
-    }
-
-    return new ModelBuildPropertyVisitor(ctx, table, descriptor);
-  }
-
-  /**
-   * Set the identity type to use for this table.
-   * <p>
-   * Takes into account the requested identity type and the underlying support in the
-   * database platform.
-   * </p>
-   */
-  private void setIdentity(BeanDescriptor<?> descriptor, MTable table) {
-
-    if (IdType.GENERATOR == descriptor.getIdType()) {
-      // explicit generator like UUID
-      table.setIdentityType(IdentityType.GENERATOR);
-      return;
-    }
-    if (IdType.EXTERNAL == descriptor.getIdType()) {
-      // externally defined code (lookup table, ISO country code etc)
-      table.setIdentityType(IdentityType.EXTERNAL);
-      return;
-    }
-
-    int initialValue = descriptor.getSequenceInitialValue();
-    int allocationSize = descriptor.getSequenceAllocationSize();
-
-    if (!descriptor.isIdTypePlatformDefault() || initialValue > 0 || allocationSize > 0) {
-      // explicitly set to use sequence or identity (generally not recommended practice)
-      if (IdType.IDENTITY == descriptor.getIdType()) {
-        table.setIdentityType(IdentityType.IDENTITY);
-      } else {
-        // explicit sequence defined
-        table.setIdentityType(IdentityType.SEQUENCE);
-        table.setSequenceName(descriptor.getSequenceName());
-        table.setSequenceInitial(initialValue);
-        table.setSequenceAllocate(allocationSize);
-      }
-    }
-  }
-
-}
@@ -1,190 +0,0 @@
-package com.avaje.ebean.dbmigration.model.build;
-
-import com.avaje.ebean.config.DbConstraintNaming;
-import com.avaje.ebean.config.dbplatform.DbPlatformType;
-import com.avaje.ebean.config.dbplatform.DbPlatformTypeMapping;
-import com.avaje.ebean.dbmigration.model.MColumn;
-import com.avaje.ebean.dbmigration.model.MTable;
-import com.avaje.ebean.dbmigration.model.ModelContainer;
-import com.avaje.ebeaninternal.server.deploy.BeanProperty;
-import com.avaje.ebeaninternal.server.type.ScalarType;
-
-import java.util.Collection;
-import java.util.List;
-
-/**
- * The context used during DDL generation.
- */
-public class ModelBuildContext {
-
-  /**
-   * Use platform agnostic logical types. These types are converted to
-   * platform specific types in the DDL generation.
-   */
-  private final DbPlatformTypeMapping dbTypeMap = DbPlatformTypeMapping.logicalTypes();
-
-  private final ModelContainer model;
-
-  private final DbConstraintNaming constraintNaming;
-
-  private final DbConstraintNaming.MaxLength maxLength;
-
-  private final boolean platformTypes;
-
-  public ModelBuildContext(ModelContainer model, DbConstraintNaming naming, DbConstraintNaming.MaxLength maxLength, boolean platformTypes) {
-    this.model = model;
-    this.constraintNaming = naming;
-    this.maxLength = maxLength;
-    this.platformTypes = platformTypes;
-  }
-
-  /**
-   * Adjust the foreign key references on any draft tables (that reference other draft tables).
-   * This is called as a 'second pass' after all the draft tables have been identified.
-   */
-  public void adjustDraftReferences() {
-    model.adjustDraftReferences();
-  }
-
-  public String normaliseTable(String baseTable) {
-    return constraintNaming.normaliseTable(baseTable);
-  }
-
-  public String primaryKeyName(String tableName) {
-    return maxLength(constraintNaming.primaryKeyName(tableName), 0);
-  }
-
-  public String foreignKeyConstraintName(String tableName, String columnName, int foreignKeyCount) {
-    return maxLength(constraintNaming.foreignKeyConstraintName(tableName, columnName), foreignKeyCount);
-  }
-
-  public String foreignKeyIndexName(String tableName, String[] columns, int indexCount) {
-    return maxLength(constraintNaming.foreignKeyIndexName(tableName, columns), indexCount);
-  }
-
-  public String foreignKeyIndexName(String tableName, String column, int indexCount) {
-    return maxLength(constraintNaming.foreignKeyIndexName(tableName, column), indexCount);
-  }
-
-  public String indexName(String tableName, String column, int indexCount) {
-    return maxLength(constraintNaming.indexName(tableName, column), indexCount);
-  }
-
-  public String indexName(String tableName, String[] columns, int indexCount) {
-    return maxLength(constraintNaming.indexName(tableName, columns), indexCount);
-  }
-
-  public String uniqueConstraintName(String tableName, String columnName, int indexCount) {
-    return maxLength(constraintNaming.uniqueConstraintName(tableName, columnName), indexCount);
-  }
-
-  public String uniqueConstraintName(String tableName, String[] columnNames, int indexCount) {
-    return maxLength(constraintNaming.uniqueConstraintName(tableName, columnNames), indexCount);
-  }
-
-  public String checkConstraintName(String tableName, String columnName, int checkCount) {
-    return maxLength(constraintNaming.checkConstraintName(tableName, columnName), checkCount);
-  }
-
-  public MTable addTable(MTable table) {
-    return model.addTable(table);
-  }
-
-  public void addIndex(String indexName, String tableName, String columnName) {
-    model.addIndex(indexName, tableName, columnName);
-  }
-
-  public void addIndex(String indexName, String tableName, String[] columnNames) {
-    model.addIndex(indexName, tableName, columnNames);
-  }
-
-  private String maxLength(String constraintName, int indexCount) {
-    return maxLength.maxLength(constraintName, indexCount);
-  }
-
-  /**
-   * Return the map used to determine the DB specific type
-   * for a given bean property.
-   */
-  public DbPlatformTypeMapping getDbTypeMap() {
-    return dbTypeMap;
-  }
-
-
-  /**
-   * Render the DB type for this property given the strict mode.
-   */
-  public String getColumnDefn(BeanProperty p, boolean strict) {
-    DbPlatformType dbType = getDbType(p);
-    if (dbType == null) {
-      throw new IllegalStateException("Unknown DbType mapping for " + p.getFullBeanName());
-    }
-    return p.renderDbType(dbType, strict);
-  }
-
-  private DbPlatformType getDbType(BeanProperty p) {
-
-    if (p.isDbEncrypted()) {
-      return dbTypeMap.get(p.getDbEncryptedType());
-    }
-    if (p.isLocalEncrypted()) {
-      // scalar type potentially wrapping varbinary db type
-      ScalarType<Object> scalarType = p.getScalarType();
-      int jdbcType = scalarType.getJdbcType();
-      return dbTypeMap.get(jdbcType);
-    }
-
-    // can be the logical JSON types (JSON, JSONB, JSONClob, JSONBlob, JSONVarchar)
-    int dbType = p.getDbType(platformTypes);
-    if (dbType == 0) {
-      throw new RuntimeException("No scalarType defined for " + p.getFullBeanName());
-    }
-    return dbTypeMap.get(dbType);
-  }
-
-  /**
-   * Create the draft table for a given table.
-   */
-  public void createDraft(MTable table, boolean draftable) {
-
-    MTable draftTable = table.createDraftTable();
-    draftTable.setPkName(primaryKeyName(draftTable.getName()));
-
-    if (draftable) {
-      // Add a FK from @Draftable live table back to it's draft table)
-      List<MColumn> pkCols = table.primaryKeyColumns();
-      if (pkCols.size() == 1) {
-        // only doing this for single column PK at this stage
-        MColumn pk = pkCols.get(0);
-        pk.setReferences(draftTable.getName() + "." + pk.getName());
-        pk.setForeignKeyName(foreignKeyConstraintName(table.getName(), pk.getName(), 0));
-      }
-    }
-
-    int fkCount = 0;
-    int ixCount = 0;
-    int uqCount = 0;
-    Collection<MColumn> cols = draftTable.allColumns();
-    for (MColumn col : cols) {
-      if (col.getForeignKeyName() != null) {
-        // Note that we adjust the 'references' table later in a second pass
-        // after we know all the tables that are 'draftable'
-        //col.setReferences(refTable + "." + refColumn);
-        col.setForeignKeyName(foreignKeyConstraintName(draftTable.getName(), col.getName(), ++fkCount));
-
-        String[] indexCols = {col.getName()};
-        col.setForeignKeyIndex(foreignKeyIndexName(draftTable.getName(), indexCols, ++ixCount));
-      }
-      // adjust the unique constraint names
-      if (col.getUnique() != null) {
-        col.setUnique(uniqueConstraintName(draftTable.getName(), col.getName(), ++uqCount));
-      }
-      if (col.getUniqueOneToOne() != null) {
-        col.setUniqueOneToOne(uniqueConstraintName(draftTable.getName(), col.getName(), ++uqCount));
-      }
-    }
-
-    addTable(draftTable);
-  }
-
-}
@@ -1,120 +0,0 @@
-package com.avaje.ebean.dbmigration.model.build;
-
-import com.avaje.ebean.dbmigration.model.MColumn;
-import com.avaje.ebean.dbmigration.model.MCompoundForeignKey;
-import com.avaje.ebean.dbmigration.model.MTable;
-import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
-import com.avaje.ebeaninternal.server.deploy.BeanProperty;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import com.avaje.ebeaninternal.server.deploy.TableJoin;
-import com.avaje.ebeaninternal.server.deploy.TableJoinColumn;
-
-
-/**
- * Add the intersection table to the model.
- */
-public class ModelBuildIntersectionTable {
-
-  private final ModelBuildContext ctx;
-
-  private final BeanPropertyAssocMany<?> manyProp;
-  private final TableJoin intersectionTableJoin;
-  private final TableJoin tableJoin;
-
-  private MTable intersectionTable;
-
-  private int countForeignKey;
-
-  public ModelBuildIntersectionTable(ModelBuildContext ctx, BeanPropertyAssocMany<?> manyProp) {
-    this.ctx = ctx;
-    this.manyProp = manyProp;
-    this.intersectionTableJoin = manyProp.getIntersectionTableJoin();
-    this.tableJoin = manyProp.getTableJoin();
-  }
-
-  public void build() {
-
-    intersectionTable = createTable();
-    MTable existingTable = ctx.addTable(intersectionTable);
-    if (existingTable != null) {
-      throw new IllegalStateException("Property " + manyProp.getFullBeanName() + " has duplicate ManyToMany intersection table " + intersectionTable.getName()
-        + ". Please use @JoinTable to define unique table to use");
-    }
-
-    buildFkConstraints();
-
-    if (manyProp.getTargetDescriptor().isDraftable()) {
-      ctx.createDraft(intersectionTable, false);
-    }
-
-  }
-
-  private void buildFkConstraints() {
-
-    BeanDescriptor<?> localDesc = manyProp.getBeanDescriptor();
-    buildFkConstraints(localDesc, intersectionTableJoin.columns(), true);
-
-    BeanDescriptor<?> targetDesc = manyProp.getTargetDescriptor();
-    buildFkConstraints(targetDesc, tableJoin.columns(), false);
-
-    intersectionTable.checkDuplicateForeignKeys();
-  }
-
-
-  private void buildFkConstraints(BeanDescriptor<?> desc, TableJoinColumn[] columns, boolean direction) {
-
-    String tableName = intersectionTableJoin.getTable();
-    String baseTable = ctx.normaliseTable(desc.getBaseTable());
-    String fkName = ctx.foreignKeyConstraintName(tableName, baseTable, ++countForeignKey);
-    String fkIndex = ctx.foreignKeyIndexName(tableName, baseTable, countForeignKey);
-
-    MCompoundForeignKey foreignKey = new MCompoundForeignKey(fkName, desc.getBaseTable(), fkIndex);
-    intersectionTable.addForeignKey(foreignKey);
-
-    for (TableJoinColumn column : columns) {
-      String localCol = direction ? column.getForeignDbColumn() : column.getLocalDbColumn();
-      String refCol = !direction ? column.getForeignDbColumn() : column.getLocalDbColumn();
-      foreignKey.addColumnPair(localCol, refCol);
-    }
-  }
-
-  private MTable createTable() {
-
-    BeanDescriptor<?> localDesc = manyProp.getBeanDescriptor();
-    BeanDescriptor<?> targetDesc = manyProp.getTargetDescriptor();
-
-    String tableName = intersectionTableJoin.getTable();
-    MTable table = new MTable(tableName);
-    if (!manyProp.isExcludedFromHistory()) {
-      if (localDesc.isHistorySupport()) {
-        table.setWithHistory(true);
-      }
-    }
-    table.setPkName(ctx.primaryKeyName(tableName));
-
-    TableJoinColumn[] columns = intersectionTableJoin.columns();
-    for (TableJoinColumn column : columns) {
-      addColumn(table, localDesc, column.getForeignDbColumn(), column.getLocalDbColumn());
-    }
-
-    TableJoinColumn[] otherColumns = tableJoin.columns();
-    for (TableJoinColumn otherColumn : otherColumns) {
-      addColumn(table, targetDesc, otherColumn.getLocalDbColumn(), otherColumn.getForeignDbColumn());
-    }
-
-    return table;
-  }
-
-  private void addColumn(MTable table, BeanDescriptor<?> desc, String column, String findPropColumn) {
-
-    BeanProperty p = desc.getIdBinder().findBeanProperty(findPropColumn);
-    if (p == null) {
-      throw new RuntimeException("Could not find id property for " + findPropColumn);
-    }
-
-    MColumn col = new MColumn(column, ctx.getColumnDefn(p, true), true);
-    col.setPrimaryKey(true);
-    table.addColumn(col);
-  }
-
-}
@@ -1,371 +0,0 @@
-package com.avaje.ebean.dbmigration.model.build;
-
-import com.avaje.ebean.dbmigration.ddlgeneration.platform.util.IndexSet;
-import com.avaje.ebean.dbmigration.model.MColumn;
-import com.avaje.ebean.dbmigration.model.MCompoundForeignKey;
-import com.avaje.ebean.dbmigration.model.MTable;
-import com.avaje.ebean.dbmigration.model.visitor.BaseTablePropertyVisitor;
-import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
-import com.avaje.ebeaninternal.server.deploy.BeanProperty;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyCompound;
-import com.avaje.ebeaninternal.server.deploy.IndexDefinition;
-import com.avaje.ebeaninternal.server.deploy.InheritInfo;
-import com.avaje.ebeaninternal.server.deploy.TableJoinColumn;
-import com.avaje.ebeaninternal.server.deploy.id.ImportedId;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-/**
- * Used as part of ModelBuildBeanVisitor and generally adds the MColumn to the associated
- * MTable model objects.
- */
-public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
-
-  protected final ModelBuildContext ctx;
-
-  private final MTable table;
-
-  private final BeanDescriptor<?> beanDescriptor;
-
-  private final IndexSet indexSet = new IndexSet();
-
-  private MColumn lastColumn;
-
-  private int countForeignKey;
-  private int countIndex;
-  private int countUnique;
-  private int countCheck;
-
-
-  public ModelBuildPropertyVisitor(ModelBuildContext ctx, MTable table, BeanDescriptor<?> beanDescriptor) {
-    this.ctx = ctx;
-    this.table = table;
-    this.beanDescriptor = beanDescriptor;
-    addIndexes(beanDescriptor.getIndexDefinitions());
-  }
-
-  /**
-   * Add unique constraints defined via JPA UniqueConstraint annotations.
-   */
-  private void addIndexes(IndexDefinition[] indexes) {
-
-    if (indexes != null) {
-      for (IndexDefinition index : indexes) {
-        String[] columns = index.getColumns();
-        indexSet.add(columns);
-
-        if (index.isUnique()) {
-          String uqName = index.getName();
-          if (uqName == null || uqName.trim().isEmpty()) {
-            uqName = determineUniqueConstraintName(columns);
-          }
-          table.addUniqueConstraint(columns, false, uqName);
-
-        } else {
-          // 'just' an index (not a unique constraint)
-          String idxName = index.getName();
-          if (idxName == null || idxName.trim().isEmpty()) {
-            idxName = determineIndexName(columns);
-          }
-          ctx.addIndex(idxName, table.getName(), columns);
-        }
-      }
-    }
-  }
-
-  @Override
-  public void visitEnd() {
-
-    // set the primary key name
-    table.setPkName(determinePrimaryKeyName());
-
-    // check if indexes on foreign keys should be suppressed
-    for (MColumn column : table.allColumns()) {
-      if (hasValue(column.getForeignKeyIndex())) {
-        if (indexSet.contains(column.getName())) {
-          // suppress index on foreign key as there is already
-          // effectively an index (probably via unique constraint)
-          column.setForeignKeyIndex(null);
-        }
-      }
-    }
-
-    for (MCompoundForeignKey compoundKey : table.getCompoundKeys()) {
-      if (indexSet.contains(compoundKey.getColumns())) {
-        // suppress index on foreign key as there is already
-        // effectively an index (probably via unique constraint)
-        compoundKey.setIndexName(null);
-      }
-    }
-
-    addDraftTable();
-  }
-
-  /**
-   * Create a 'draft' table that is mostly the same as the base table.
-   * It has @DraftOnly columns and adjusted primary and foreign keys.
-   */
-  private void addDraftTable() {
-    if (beanDescriptor.isDraftable() || beanDescriptor.isDraftableElement()) {
-      // create a 'Draft' table which looks very similar (change PK, FK etc)
-      ctx.createDraft(table, !beanDescriptor.isDraftableElement());
-    }
-  }
-
-
-  @Override
-  public void visitMany(BeanPropertyAssocMany<?> p) {
-    if (p.isManyToMany()) {
-      if (p.getMappedBy() == null) {
-        // only create on other 'owning' side
-
-        //TableJoin intersectionTableJoin = p.getIntersectionTableJoin();
-        // check if the intersection table has already been created
-
-        // build the create table and fkey constraints
-        // putting the DDL into ctx for later output as we are
-        // in the middle of rendering the create table DDL
-        new ModelBuildIntersectionTable(ctx, p).build();
-      }
-    }
-  }
-
-  @Override
-  public void visitCompoundScalar(BeanPropertyCompound compound, BeanProperty p) {
-    visitScalar(p);
-  }
-
-  @Override
-  public void visitCompound(BeanPropertyCompound p) {
-    // do nothing
-  }
-
-  @Override
-  public void visitEmbeddedScalar(BeanProperty p, BeanPropertyAssocOne<?> embedded) {
-
-    visitScalar(p);
-    if (embedded.isId()) {
-      // compound primary key
-      lastColumn.setPrimaryKey(true);
-    }
-  }
-
-  @Override
-  public void visitOneImported(BeanPropertyAssocOne<?> p) {
-
-    TableJoinColumn[] columns = p.getTableJoin().columns();
-    if (columns.length == 0) {
-      String msg = "No join columns for " + p.getFullBeanName();
-      throw new RuntimeException(msg);
-    }
-
-    ImportedId importedId = p.getImportedId();
-
-    List<MColumn> modelColumns = new ArrayList<>(columns.length);
-
-    MCompoundForeignKey compoundKey = null;
-    if (columns.length > 1) {
-      // compound foreign key
-      String refTable = p.getTargetDescriptor().getBaseTable();
-      String fkName = determineForeignKeyConstraintName(p.getName());
-      String fkIndex = determineForeignKeyIndexName(p.getName());
-      compoundKey = new MCompoundForeignKey(fkName, refTable, fkIndex);
-      table.addForeignKey(compoundKey);
-    }
-
-    for (TableJoinColumn column : columns) {
-
-      String dbCol = column.getLocalDbColumn();
-      BeanProperty importedProperty = importedId.findMatchImport(dbCol);
-      if (importedProperty == null) {
-        throw new RuntimeException("Imported BeanProperty not found?");
-      }
-      String columnDefn = ctx.getColumnDefn(importedProperty, true);
-      String refColumn = importedProperty.getDbColumn();
-
-      MColumn col = table.addColumn(dbCol, columnDefn, !p.isNullable());
-
-      if (columns.length == 1) {
-        // single references column (put it on the column)
-        String refTable = importedProperty.getBeanDescriptor().getBaseTable();
-        if (refTable == null) {
-          // odd case where an EmbeddedId only has 1 property
-          refTable = p.getTargetDescriptor().getBaseTable();
-        }
-        col.setReferences(refTable + "." + refColumn);
-        col.setForeignKeyName(determineForeignKeyConstraintName(col.getName()));
-        col.setForeignKeyIndex(determineForeignKeyIndexName(col.getName()));
-      } else {
-        compoundKey.addColumnPair(dbCol, refColumn);
-      }
-      modelColumns.add(col);
-    }
-
-    if (p.isOneToOne()) {
-      // adding the unique constraint restricts the cardinality from OneToMany down to OneToOne
-      // for MsSqlServer we need different DDL to handle NULL values on this constraint
-      if (modelColumns.size() == 1) {
-        MColumn col = modelColumns.get(0);
-        col.setUniqueOneToOne(determineUniqueConstraintName(col.getName()));
-        indexSetAdd(col.getName());
-
-      } else {
-        String uqName = determineUniqueConstraintName(p.getName());
-        table.addUniqueConstraint(modelColumns, true, uqName);
-        indexSetAdd(modelColumns);
-      }
-    }
-  }
-
-  @Override
-  public void visitScalar(BeanProperty p) {
-
-    if (p.isSecondaryTable()) {
-      lastColumn = null;
-      return;
-    }
-
-    // using non-strict mode to render the DB type such that we have a
-    // "logical" type like jsonb(200) that can map to JSONB or VARCHAR(200)
-    MColumn col = new MColumn(p.getDbColumn(), ctx.getColumnDefn(p, false));
-    col.setDefaultValue(p.getDbColumnDefault());
-    col.setComment(p.getDbComment());
-    col.setDraftOnly(p.isDraftOnly());
-    col.setHistoryExclude(p.isExcludedFromHistory());
-
-    if (p.isId()) {
-      col.setPrimaryKey(true);
-      if (p.getBeanDescriptor().isUseIdGenerator()) {
-        col.setIdentity(true);
-      }
-    } else if (!p.isNullable() || p.isDDLNotNull()) {
-      col.setNotnull(true);
-    }
-
-    if (p.isUnique() && !p.isId()) {
-      col.setUnique(determineUniqueConstraintName(col.getName()));
-      indexSetAdd(col.getName());
-    }
-    Set<String> checkConstraintValues = p.getDbCheckConstraintValues();
-    if (checkConstraintValues != null) {
-      if (beanDescriptor.hasInheritance()) {
-        InheritInfo inheritInfo = beanDescriptor.getInheritInfo();
-        inheritInfo.appendCheckConstraintValues(p.getName(), checkConstraintValues);
-      }
-      col.setCheckConstraint(buildCheckConstraint(p.getDbColumn(), checkConstraintValues));
-      col.setCheckConstraintName(determineCheckConstraintName(col.getName()));
-    }
-
-    lastColumn = col;
-    table.addColumn(col);
-  }
-
-  /**
-   * Build the check constraint clause given the db column and values.
-   */
-  private String buildCheckConstraint(String dbColumn, Set<String> checkConstraintValues) {
-    StringBuilder sb = new StringBuilder();
-    sb.append("check ( ").append(dbColumn).append(" in (");
-    int count = 0;
-    for (String value : checkConstraintValues) {
-      if (count++ > 0) {
-        sb.append(",");
-      }
-      sb.append(value);
-    }
-    sb.append("))");
-    return sb.toString();
-  }
-
-  private void indexSetAdd(String column) {
-    indexSet.add(column);
-  }
-
-  private void indexSetAdd(List<MColumn> modelColumns) {
-    String[] cols = new String[modelColumns.size()];
-    for (int i = 0; i < modelColumns.size(); i++) {
-      cols[i] = modelColumns.get(i).getName();
-    }
-    indexSet.add(cols);
-  }
-
-  /**
-   * Return the primary key constraint name.
-   */
-  protected String determinePrimaryKeyName() {
-
-    return ctx.primaryKeyName(table.getName());
-  }
-
-  /**
-   * Return the foreign key constraint name given a single column foreign key.
-   */
-  protected String determineForeignKeyConstraintName(String columnName) {
-
-    return ctx.foreignKeyConstraintName(table.getName(), columnName, ++countForeignKey);
-  }
-
-  protected String determineForeignKeyIndexName(String column) {
-
-    String[] cols = {column};
-    return determineForeignKeyIndexName(cols);
-  }
-
-  /**
-   * Return the foreign key constraint name given a single column foreign key.
-   */
-  protected String determineForeignKeyIndexName(String[] columns) {
-
-    return ctx.foreignKeyIndexName(table.getName(), columns, ++countIndex);
-  }
-
-  /**
-   * Return the index name given a single column foreign key.
-   */
-  protected String determineIndexName(String column) {
-
-    return ctx.indexName(table.getName(), column, ++countIndex);
-  }
-
-  /**
-   * Return the index name given multiple columns.
-   */
-  protected String determineIndexName(String[] columns) {
-
-    return ctx.indexName(table.getName(), columns, ++countIndex);
-  }
-
-  /**
-   * Return the unique constraint name.
-   */
-  protected String determineUniqueConstraintName(String columnName) {
-
-    return ctx.uniqueConstraintName(table.getName(), columnName, ++countUnique);
-  }
-
-  /**
-   * Return the unique constraint name.
-   */
-  protected String determineUniqueConstraintName(String[] columnNames) {
-
-    return ctx.uniqueConstraintName(table.getName(), columnNames, ++countUnique);
-  }
-
-  /**
-   * Return the constraint name.
-   */
-  protected String determineCheckConstraintName(String columnName) {
-
-    return ctx.checkConstraintName(table.getName(), columnName, ++countCheck);
-  }
-
-
-  private boolean hasValue(String val) {
-    return val != null && !val.isEmpty();
-  }
-
-}
@@ -1,59 +0,0 @@
-package com.avaje.ebean.dbmigration.model.visitor;
-
-import com.avaje.ebeaninternal.server.deploy.BeanProperty;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyCompound;
-
-/**
- * Used to help mark PropertyVisitor methods that need to be implemented
- * to visit base table properties.
- */
-public abstract class BaseTablePropertyVisitor implements BeanPropertyVisitor {
-
-  /**
-   * Not required in that you can use the visitEmbeddedScalar.
-   */
-  public void visitEmbedded(BeanPropertyAssocOne<?> p) {
-  }
-
-  /**
-   * Override this method.
-   */
-  public abstract void visitEmbeddedScalar(BeanProperty p, BeanPropertyAssocOne<?> embedded);
-
-  /**
-   * Not part of base table.
-   */
-  public void visitMany(BeanPropertyAssocMany<?> p) {
-  }
-
-  /**
-   * Not part of base table.
-   */
-  public void visitOneExported(BeanPropertyAssocOne<?> p) {
-  }
-
-  /**
-   * Override this method for the foreign key.
-   */
-  public abstract void visitOneImported(BeanPropertyAssocOne<?> p);
-
-  /**
-   * Override this method for normal scalar property.
-   */
-  public abstract void visitScalar(BeanProperty p);
-
-  /**
-   * Not required in that the scalar properties map to the columns.
-   */
-  public void visitCompound(BeanPropertyCompound p) {
-  }
-
-  /**
-   * Override this method for scalar property inside a Immutable Compound Value object.
-   */
-  public abstract void visitCompoundScalar(BeanPropertyCompound compound, BeanProperty p);
-
-
-}
@@ -1,58 +0,0 @@
-package com.avaje.ebean.dbmigration.model.visitor;
-
-import com.avaje.ebeaninternal.server.deploy.BeanProperty;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne;
-import com.avaje.ebeaninternal.server.deploy.BeanPropertyCompound;
-
-/**
- * Used to visit a BeanProperty given the type of bean property it is.
- */
-public interface BeanPropertyVisitor {
-
-  /**
-   * Completed visiting all the properties on the bean.
-   */
-  void visitEnd();
-
-  /**
-   * Visit a OneToMany or ManyToMany property.
-   */
-  void visitMany(BeanPropertyAssocMany<?> p);
-
-  /**
-   * Visit the imported side of a OneToOne property.
-   */
-  void visitOneImported(BeanPropertyAssocOne<?> p);
-
-  /**
-   * Visit the exported side of a OneToOne property.
-   */
-  void visitOneExported(BeanPropertyAssocOne<?> p);
-
-  /**
-   * Visit an embedded property.
-   */
-  void visitEmbedded(BeanPropertyAssocOne<?> p);
-
-  /**
-   * Visit the scalar property of an embedded bean.
-   */
-  void visitEmbeddedScalar(BeanProperty p, BeanPropertyAssocOne<?> embedded);
-
-  /**
-   * Visit a scalar property.
-   */
-  void visitScalar(BeanProperty p);
-
-  /**
-   * Visit a compound value object.
-   */
-  void visitCompound(BeanPropertyCompound p);
-
-  /**
-   * Visit the scalar value inside a compound value object.
-   */
-  void visitCompoundScalar(BeanPropertyCompound compound, BeanProperty p);
-
-}
@@ -1,18 +0,0 @@
-package com.avaje.ebean.dbmigration.model.visitor;
-
-import com.avaje.ebean.dbmigration.model.build.ModelBuildPropertyVisitor;
-import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
-
-/**
- * Visitor pattern for visiting a BeanDescriptor and potentially all its bean
- * properties.
- */
-public interface BeanVisitor {
-
-  /**
-   * Visit a BeanDescriptor and return a PropertyVisitor to use to visit each
-   * property on the entity bean (return null to skip visiting this bean).
-   */
-  ModelBuildPropertyVisitor visitBean(BeanDescriptor<?> descriptor);
-
-}
--- a/Show More
+++ b/Show More