[maven-release-plugin] prepare release avaje-ebeanorm-3.4.2

Backport fix for #154 - @OrderBy on a @OneToMany property is not used when lazy loading

.editorconfig

@@ -1,13 +0,0 @@
-# editorconfig.org
-
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_size = 2
-indent_style = space
-insert_final_newline = true
-trim_trailing_whitespace = true
-spaces_around_operators = true
-max_line_length = 130

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-custom: https://ebean.io/sponsors

.github/ISSUE_TEMPLATE.md

@@ -1,13 +0,0 @@
-## Expected behavior
-
-## Actual behavior
-
-### Steps to reproduce
-
-```java
-  // some java code
-```
-
-```console
-  // some logging output
-```

.github/workflows/build.yml

@@ -1,40 +0,0 @@
-
-name: Build
-
-on: [push, pull_request]
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [8]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'zulu'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: Maven version
-      run: mvn --version
-#    - name: Maven single test
-#      run: mvn --batch-mode clean verify -Dtest="io.ebeaninternal.server.core.DefaultServer_getReferenceTest" -DfailIfNoTests=false
-    - name: Build with Maven
-      run: mvn clean package
-

.github/workflows/db2luw.yml

@@ -1,38 +0,0 @@
-
-name: DB2 LUW
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '10 8 * * 2,5'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'adopt'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: db2
-      run: mvn clean test -Dprops.file=testconfig/ebean-db2.properties

.github/workflows/h2database.yml

@@ -1,41 +0,0 @@
-
-name: H2Database
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '10 1 * * *'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'zulu'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: Maven version
-      run: mvn --version
-    - name: H2Database
-      run: mvn clean package
-

.github/workflows/jdk-18-ea.yml

@@ -1,39 +0,0 @@
-
-name: JDK 18-ea
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '30 6 * * 1,3,5'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [18-ea]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'zulu'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: Build with Maven
-      run: mvn package
-

.github/workflows/jdk-ea.yml

@@ -1,39 +0,0 @@
-
-name: ebean EA
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '39 6 * * 1,3,5'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [17,18,19,loom,valhalla,metropolis,panama]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: oracle-actions/setup-java@v1
-      with:
-        website: jdk.java.net
-        release: ${{ matrix.java_version }}
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: Build with Maven
-      run: mvn package
-

.github/workflows/mariadb.yml

@@ -1,38 +0,0 @@
-
-name: MariaDB
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '10 7 * * 1,4'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'adopt'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: mariadb 10.6
-      run: mvn clean test -Dprops.file=testconfig/ebean-mariadb.properties

.github/workflows/multi-db-platform.yml

@@ -1,51 +0,0 @@
-
-name: Multi-database platform
-
-on: [workflow_dispatch]
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'adopt'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: h2database
-      run: mvn clean test
-    - name: postgres
-      run: mvn clean test -Dprops.file=testconfig/ebean-postgres.properties
-    - name: mysql
-      run: mvn clean test -Dprops.file=testconfig/ebean-mysql.properties
-    - name: mariadb
-      run: mvn clean test -Dprops.file=testconfig/ebean-mariadb.properties
-    - name: yugabyte
-      run: mvn clean test -Dprops.file=testconfig/ebean-yugabyte.properties
-    - name: sqlserver
-      run: mvn clean test -Dprops.file=testconfig/ebean-sqlserver17.properties
-#    - name: sqlserver19
-#      run: mvn clean test -Dprops.file=testconfig/ebean-sqlserver19.properties
-#    - name: db2
-#      run: mvn clean test -Dprops.file=testconfig/ebean-db2.properties
-#    - name: oracle
-#      run: mvn clean test -Dprops.file=testconfig/ebean-oracle.properties

.github/workflows/multi-jdk-build.yml

@@ -1,39 +0,0 @@
-
-name: Multi-JDK Build
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '30 6 * * *'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [8.0.192, 8, 11.0.3, 11, 17]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'zulu'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: Build with Maven
-      run: mvn package
-

.github/workflows/mysql.yml

@@ -1,38 +0,0 @@
-
-name: MySql
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '20 6 * * *'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'adopt'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: mysql
-      run: mvn clean test -Dprops.file=testconfig/ebean-mysql.properties

.github/workflows/oracle18.yml

@@ -1,38 +0,0 @@
-
-name: Oracle18
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '10 6 * * 1,4'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'zulu'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: oracle
-      run: mvn clean test -Dprops.file=testconfig/ebean-oracle.properties

.github/workflows/postgres.yml

@@ -1,38 +0,0 @@
-
-name: Postgres
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '10 6 * * *'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'adopt'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: postgres
-      run: mvn clean test -Dprops.file=testconfig/ebean-postgres.properties

.github/workflows/sqlserver-2019.yml

@@ -1,35 +0,0 @@
-
-name: SqlServer 2019
-
-on: [workflow_dispatch]
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'adopt'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: sqlserver 2019 latest
-      run: mvn clean test -Dprops.file=testconfig/ebean-sqlserver19.properties

.github/workflows/sqlserver.yml

@@ -1,38 +0,0 @@
-
-name: SqlServer
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '10 7 * * 2,5'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'adopt'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: sqlserver 2017
-      run: mvn clean test -Dprops.file=testconfig/ebean-sqlserver17.properties

.github/workflows/yugabyte.yml

@@ -1,38 +0,0 @@
-
-name: Yugabyte
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '10 3 * * *'
-
-jobs:
-  build:
-
-    runs-on: ${{ matrix.os }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        java_version: [11]
-        os: [ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        java-version: ${{ matrix.java_version }}
-        distribution: 'adopt'
-    - name: Maven cache
-      uses: actions/cache@v2
-      env:
-        cache-name: maven-cache
-      with:
-        path:
-          ~/.m2
-        key: build-${{ env.cache-name }}
-    - name: yugabyte
-      run: mvn clean test -Dprops.file=testconfig/ebean-yugabyte.properties

.gitignore

@@ -1,20 +1,11 @@
 *.autofetch
-*.orig
+*.sql
 .classpath
 .project
 .settings/
 target/
 logs/
 log/
-ebean-autotune.xml
-ebean-profiling*.xml
-/db
 /mydb.db
-profiling/
-
-# Intellij project files
 *.iml
-*.ipr
-*.iws
-.idea/
-*uuid.state
+.idea

.travis.yml

@@ -1,44 +0,0 @@
-dist: xenial
-sudo: required
-language: java
-jdk:
-  - openjdk11
-
-git:
-  depth: 3
-
-addons:
-  postgresql: 10
-#  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
-
-script:
-  - mvn -T 1C clean test
-
-after_failure:
-  - ./.travis/print_surefire_reports
-
-cache:
-  directories:
-  - $HOME/.m2

.travis/print_surefire_reports

@@ -1,17 +0,0 @@
-#!/bin/sh
-
-echo "\n=== SUREFIRE REPORTS ===\n"
-
-for file in target/surefire-reports/*.txt
-do
-    echo ${file}
-    cat ${file}
-    echo
-done
-
-for file in ebean-autotune/target/surefire-reports/*.txt
-do
-    echo ${file}
-    cat ${file}
-    echo
-done

.travis/setup_database

@@ -1,14 +0,0 @@
-#!/bin/sh
-
-echo "\n=== SETUP DATABASE ===\n"
-
-#set -e
-#set -x
-
-# Setup postgres' users and databases
-sudo -u postgres psql -c "CREATE USER unit WITH PASSWORD 'unit';"
-sudo -u postgres psql -c 'CREATE DATABASE unit WITH OWNER unit;'
-sudo -u postgres psql unit -c 'CREATE EXTENSION hstore;'
-sudo -u postgres psql unit -c 'CREATE EXTENSION pgcrypto;'
-#sudo -u postgres psql test2 -c 'CREATE EXTENSION postgis;'
-

CONFIGURATION.md

@@ -1,298 +0,0 @@
-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.useValidationNotNull
-ebean.useJtaTransactionManager
-

LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2012 Authors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

LICENSE.TXT

@@ -0,0 +1,15 @@
+EbeanORM
+
+Copyright 2012 Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -1,62 +1,14 @@
-[![Build](https://github.com/ebean-orm/ebean/actions/workflows/build.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/build.yml)
-[![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)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ebean-orm/ebean/blob/master/LICENSE)
-[![Multi-JDK Build](https://github.com/ebean-orm/ebean/actions/workflows/multi-jdk-build.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/multi-jdk-build.yml)
-[![JDK 18-ea](https://github.com/ebean-orm/ebean/actions/workflows/jdk-18-ea.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/jdk-18-ea.yml)
-
-[![H2Database](https://github.com/ebean-orm/ebean/actions/workflows/h2database.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/h2database.yml)
-[![Postgres](https://github.com/ebean-orm/ebean/actions/workflows/postgres.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/postgres.yml)
-[![MySql](https://github.com/ebean-orm/ebean/actions/workflows/mysql.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/mysql.yml)
-[![MariaDB](https://github.com/ebean-orm/ebean/actions/workflows/mariadb.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/mariadb.yml)
-[![SqlServer](https://github.com/ebean-orm/ebean/actions/workflows/sqlserver.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/sqlserver.yml)
-[![Yugabyte](https://github.com/ebean-orm/ebean/actions/workflows/yugabyte.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/yugabyte.yml)
-
-
-#### Builds against EA (Early Access) versions of Java (19, Loom, panama etc)
-
-[![ebean EA](https://github.com/ebean-orm/ebean/actions/workflows/jdk-ea.yml/badge.svg)](https://github.com/ebean-orm/ebean/actions/workflows/jdk-ea.yml)
-[![datasource EA](https://github.com/ebean-orm/ebean-datasource/actions/workflows/jdk-ea.yml/badge.svg)](https://github.com/ebean-orm/ebean-datasource/actions/workflows/jdk-ea.yml)
-[![migration EA](https://github.com/ebean-orm/ebean-migration/actions/workflows/jdk-ea.yml/badge.svg)](https://github.com/ebean-orm/ebean-migration/actions/workflows/jdk-ea.yml)
-[![test-docker EA](https://github.com/ebean-orm/ebean-test-docker/actions/workflows/jdk-ea.yml/badge.svg)](https://github.com/ebean-orm/ebean-test-docker/actions/workflows/jdk-ea.yml)
-
-
-# Sponsors
-<table>
-  <tbody>
-    <tr>
-      <td align="center" valign="middle">
-        <a href="https://www.foconis.de/" target="_blank">
-          <img width="222px" src="https://www.foconis.de/templates/yootheme/cache/foconis_logo_322-709da1de.png">
-        </a>
-      </td>
-      <td align="center" valign="middle">
-        <a href="https://www.payintech.com/" target="_blank">
-          <img width="222px" src="https://ebean.io/images/sponsor_PayinTech-logo-noir.png">
-        </a>
-      </td>
-      <td align="center" valign="middle">
-        <a href="https://www.premium-minds.com" target="_blank">
-          <img width="222px" src="https://ebean.io/images/logo-med-principal.png">
-        </a>
-      </td>
-      <td align="center" valign="middle">
-        <a href="https://timerbee.de" target="_blank">
-          <img width="222px" src="https://ebean.io/images/logo-timerbee.png">
-        </a>
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-## Need help?
-Post questions or issues to the Ebean google group - https://groups.google.com/forum/#!forum/ebean
-
-## Documentation
-Goto [https://ebean.io/docs/](https://ebean.io/docs/)
-
-
-## Maven central
-[Maven central - io.ebean](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22io.ebean%22%20)
-
+avaje-ebeanorm
+==============
 
+Main EbeanORM artifact
 
+Maven Dependency
+----------------
+    <dependency>
+      <groupId>org.avaje.ebeanorm</groupId>
+      <artifactId>avaje-ebeanorm</artifactId>
+      <version>3.3.2</version>
+    </dependency>
+    
+    

ebean-api/pom.xml

@@ -1,130 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <parent>
-    <artifactId>ebean-parent</artifactId>
-    <groupId>io.ebean</groupId>
-    <version>12.16.3</version>
-  </parent>
-
-  <name>ebean api</name>
-  <description>ebean api</description>
-  <artifactId>ebean-api</artifactId>
-
-  <dependencies>
-
-    <!--
-    Projects are expected to explicit depend on version
-    of slf4j that they want to use
-    -->
-    <dependency>
-      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-api</artifactId>
-      <version>1.7.30</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>io.avaje</groupId>
-      <artifactId>avaje-config</artifactId>
-      <version>1.7</version>
-    </dependency>
-
-    <!--
-    Class retention Nonnull and Nullable annotations
-    to assist with IDE auto-completion with Ebean API
-    -->
-    <dependency>
-      <groupId>io.avaje</groupId>
-      <artifactId>avaje-lang</artifactId>
-      <version>1.0</version>
-    </dependency>
-
-    <dependency>
-      <groupId>io.ebean</groupId>
-      <artifactId>persistence-api</artifactId>
-      <version>2.2.5</version>
-    </dependency>
-
-    <dependency>
-      <groupId>io.ebean</groupId>
-      <artifactId>ebean-annotation</artifactId>
-      <version>7.7</version>
-    </dependency>
-
-    <dependency>
-      <groupId>io.ebean</groupId>
-      <artifactId>ebean-types</artifactId>
-      <version>2.2</version>
-    </dependency>
-
-    <dependency>
-      <groupId>io.ebean</groupId>
-      <artifactId>ebean-datasource-api</artifactId>
-      <version>${ebean-datasource.version}</version>
-    </dependency>
-
-    <!-- Jackson core used internally by Ebean -->
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-core</artifactId>
-      <version>${jackson.version}</version>
-      <optional>true</optional>
-    </dependency>
-
-    <!-- provided scope for JsonNode support -->
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-databind</artifactId>
-      <version>${jackson.version}</version>
-      <optional>true</optional>
-    </dependency>
-
-    <!-- Provided scope so that the H2HistoryTrigger can live in Ebean core
-     and not require a separate module for it -->
-    <dependency>
-      <groupId>com.h2database</groupId>
-      <artifactId>h2</artifactId>
-      <version>${h2database.version}</version>
-      <optional>true</optional>
-    </dependency>
-
-    <dependency>
-      <groupId>javax.transaction</groupId>
-      <artifactId>jta</artifactId>
-      <version>1.1</version>
-      <optional>true</optional>
-    </dependency>
-
-    <dependency>
-      <groupId>javax.servlet</groupId>
-      <artifactId>javax.servlet-api</artifactId>
-      <version>3.1.0</version>
-      <optional>true</optional>
-    </dependency>
-
-    <dependency>
-      <groupId>io.avaje</groupId>
-      <artifactId>junit</artifactId>
-      <version>1.1</version>
-      <scope>test</scope>
-    </dependency>
-
-  </dependencies>
-
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>io.repaint.maven</groupId>
-        <artifactId>tiles-maven-plugin</artifactId>
-        <version>2.24</version>
-        <extensions>true</extensions>
-        <configuration>
-          <tiles>
-            <tile>io.avaje.tile:moditech-module:1.0</tile>
-          </tiles>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-</project>

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

@@ -1,21 +0,0 @@
-package io.ebean;
-
-import javax.persistence.PessimisticLockException;
-
-/**
- * Thrown when failing to acquire a pessimistic lock.
- * <p>
- * Typically when "select for update nowait" or "select for update" is being used and
- * the lock can not be obtained (as it is held by another transaction).
- * </p>
- */
-public class AcquireLockException extends PessimisticLockException {
-  private static final long serialVersionUID = -8585962352965876691L;
-
-  /**
-   * Create with a message and cause.
-   */
-  public AcquireLockException(String message, Throwable cause) {
-    super(message, cause);
-  }
-}

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

@@ -1,24 +0,0 @@
-package io.ebean;
-
-/**
- * Administrative control of AutoTune during runtime.
- */
-public interface AutoTune {
-
-  /**
-   * Fire a garbage collection (hint to the JVM). Assuming garbage collection
-   * fires this will gather remaining usage profiling information.
-   */
-  void collectProfiling();
-
-  /**
-   * Output the profiling.
-   * <p>
-   * When profiling updates are applied to tuning at runtime this reports all tuning and profiling combined.
-   * When profiling is not applied at runtime then this reports the diff report with new and diff entries relative
-   * to the existing tuning.
-   * </p>
-   */
-  void reportProfiling();
-
-}

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

@@ -1,112 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.NonNullApi;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Background executor service for executing of tasks asynchronously.
- * <p>
- * This service can be used to execute tasks in the background.
- * <p>
- * This service is managed by Ebean and will perform a clean shutdown
- * waiting for background tasks to complete with a default 30 second
- * timeout. Shutdown occurs prior to DataSource shutdown.
- * <p>
- * This also propagates MDC context from the current thread to the
- * background task if defined.
- */
-@NonNullApi
-public interface BackgroundExecutor {
-
-  /**
-   * Execute a callable task in the background returning the Future.
-   */
-  <T> Future<T> submit(Callable<T> task);
-
-  /**
-   * Execute a runnable task in the background returning the Future.
-   */
-  Future<?> submit(Runnable task);
-
-  /**
-   * Execute a task in the background. Effectively the same as
-   * {@link BackgroundExecutor#submit(Runnable)} but returns void.
-   */
-  void execute(Runnable task);
-
-  /**
-   * Deprecated - migrate to scheduleWithFixedDelay().
-   * Execute a task periodically with a fixed delay between each execution.
-   * <p>
-   * For example, execute a runnable every minute.
-   * <p>
-   * The delay is the time between executions no matter how long the task took.
-   * That is, this method has the same behaviour characteristics as
-   * {@link ScheduledExecutorService#scheduleWithFixedDelay(Runnable, long, long, TimeUnit)}
-   */
-  @Deprecated
-  void executePeriodically(Runnable task, long delay, TimeUnit unit);
-
-  /**
-   * Deprecated - migrate to scheduleWithFixedDelay().
-   * Execute a task periodically additionally with an initial delay different from delay.
-   */
-  @Deprecated
-  void executePeriodically(Runnable task, long initialDelay, long delay, TimeUnit unit);
-
-  /**
-   * Execute a task periodically with a given delay.
-   *
-   * @param task         the task to execute
-   * @param initialDelay the time to delay first execution
-   * @param delay        the delay between the termination of one
-   *                     execution and the commencement of the next
-   * @param unit         the time unit of the initialDelay and delay parameters
-   * @return a ScheduledFuture representing pending completion of
-   * the series of repeated tasks.  The future's {@link
-   * Future#get() get()} method will never return normally,
-   * and will throw an exception upon task cancellation or
-   * abnormal termination of a task execution.
-   */
-  ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit);
-
-  /**
-   * Execute a task periodically with a given period.
-   *
-   * <p>If any execution of this task takes longer than its period, then
-   * subsequent executions may start late, but will not concurrently
-   * execute.
-   *
-   * @param task         the task to execute
-   * @param initialDelay the time to delay first execution
-   * @param period       the period between successive executions
-   * @param unit         the time unit of the initialDelay and period parameters
-   * @return a ScheduledFuture representing pending completion of
-   * the series of repeated tasks.  The future's {@link
-   * Future#get() get()} method will never return normally,
-   * and will throw an exception upon task cancellation or
-   * abnormal termination of a task execution.
-   */
-  ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit);
-
-  /**
-   * Schedules a Runnable for one-shot action that becomes enabled after the given delay.
-   *
-   * @return a ScheduledFuture representing pending completion of the task and
-   * whose get() method will return null upon completion
-   */
-  ScheduledFuture<?> schedule(Runnable task, long delay, TimeUnit unit);
-
-  /**
-   * Schedules a Callable for one-shot action that becomes enabled after the given delay.
-   *
-   * @return a ScheduledFuture that can be used to extract result or cancel
-   */
-  <V> ScheduledFuture<V> schedule(Callable<V> task, long delay, TimeUnit unit);
-
-}

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

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

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

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

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

@@ -1,162 +0,0 @@
-package io.ebean;
-
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Provides access to the internal state of an entity bean.
- */
-public interface BeanState {
-
-  /**
-   * Return true if this is a lazy loading reference bean.
-   * <p>
-   * If so the this bean only holds the Id property and will invoke lazy loading
-   * if any other property is get or set.
-   * </p>
-   */
-  boolean isReference();
-
-  /**
-   * Return true if the bean is new (and not yet saved).
-   */
-  boolean isNew();
-
-  /**
-   * Return true if the bean is new or dirty (and probably needs to be saved).
-   */
-  boolean isNewOrDirty();
-
-  /**
-   * Return true if the bean has been changed but not yet saved.
-   */
-  boolean isDirty();
-
-  /**
-   * This can be called with true to disable lazy loading on the bean.
-   */
-  void setDisableLazyLoad(boolean disableLazyLoading);
-
-  /**
-   * Return true if the bean has lazy loading disabled.
-   */
-  boolean isDisableLazyLoad();
-
-  /**
-   * Set the loaded state of the property given it's name.
-   * <p>
-   * Typically this would be used to set the loaded state of a property
-   * to false to ensure that the specific property is excluded from a
-   * stateless update.
-   * </p>
-   * <pre>{@code
-   *
-   *   // populate a bean via say JSON
-   *   User user = ...;
-   *
-   *   // set loaded state on the email property to false so that
-   *   // the email property is not included in a stateless update
-   *   DB.beanState(user).setPropertyLoaded("email", false);
-   *
-   *   user.update();
-   *
-   * }</pre>
-   * <p>
-   * This will throw an IllegalArgumentException if the property is unknown.
-   */
-  void setPropertyLoaded(String propertyName, boolean loaded);
-
-  /**
-   * For partially populated beans returns the properties that are loaded on the
-   * bean.
-   * <p>
-   * Accessing another property will cause lazy loading to occur.
-   */
-  Set<String> loadedProps();
-
-  /**
-   * Deprecated migrate to loadedProps().
-   */
-  @Deprecated
-  default Set<String> getLoadedProps() {
-    return loadedProps();
-  }
-
-  /**
-   * Return the set of changed properties.
-   */
-  Set<String> changedProps();
-
-  /**
-   * Deprecated migrate to changedProps().
-   */
-  @Deprecated
-  default Set<String> getChangedProps() {
-    return changedProps();
-  }
-
-  /**
-   * Return a map of the updated properties and their new and old values.
-   */
-  Map<String, ValuePair> dirtyValues();
-
-  /**
-   * Deprecated migrate to dirtyValues().
-   */
-  @Deprecated
-  default Map<String, ValuePair> getDirtyValues() {
-    return dirtyValues();
-  }
-
-  /**
-   * Return true if the bean is readOnly.
-   * <p>
-   * If a setter is called on a readOnly bean it will throw an exception.
-   */
-  boolean isReadOnly();
-
-  /**
-   * Set the readOnly status for the bean.
-   */
-  void setReadOnly(boolean readOnly);
-
-  /**
-   * Advanced - Used to programmatically build a partially or fully loaded
-   * entity bean. First create an entity bean via
-   * {@link Database#createEntityBean(Class)}, then populate its properties
-   * and then call this method specifying which properties where loaded or null
-   * for a fully loaded entity bean.
-   */
-  void setLoaded();
-
-  /**
-   * Reset the bean putting it into NEW state such that a save() results in an insert.
-   */
-  void resetForInsert();
-
-  /**
-   * Returns a map with load errors.
-   */
-  Map<String, Exception> loadErrors();
-
-  /**
-   * Deprecated migrate to loadErrors().
-   */
-  @Deprecated
-  default Map<String, Exception> getLoadErrors() {
-    return loadErrors();
-  }
-
-  /**
-   * Return the sort order value for an order column.
-   */
-  int sortOrder();
-
-  /**
-   * Deprecated migrate to sortOrder().
-   */
-  @Deprecated
-  default int getSortOrder() {
-    return sortOrder();
-  }
-}

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

@@ -1,93 +0,0 @@
-package io.ebean;
-
-/**
- * Enum to control the different cache modes for queryCache and beanCache.
- * <h3>Bean cache</h3>
- * <p>
- * The bean cache is automatically used by default on <code>@Cache</code> beans for
- * the following queries:
- * </p>
- * <ul>
- * <li>findOne() by id</li>
- * <li>findOne() by natural key(s)</li>
- * <li>findList() by ids</li>
- * </ul>
- * <p>
- * Bean caching needs to be explicitly turned on for queries that are findList() by natural keys.
- * </p>
- * <h3>Query cache</h3>
- * <p>
- * For query cache use note that you must be careful, what you do with the returned collection.
- * By default the returned collections are read only and you will get an exception if you try
- * to change them.
- * If you add ".setReadOnly(false)" to your query, you'll get a collection that is a clone from the
- * one in the cache. That means, changing does not affect the cache.
- * </p>
- *
- * @author Roland Praml, FOCONIS AG
- */
-public enum CacheMode {
-
-  /**
-   * Do not use cache.
-   */
-  OFF(false, false),
-
-  /**
-   * Use the cache and store a result when needed.
-   */
-  ON(true, true),
-
-  /**
-   * Only used for bean caching.
-   * <p>
-   * The bean cache is automatically used by default on <code>@Cache</code> beans for
-   * the following queries:
-   * </p>
-   * <ul>
-   * <li>findOne() by id</li>
-   * <li>findOne() by natural key(s)</li>
-   * <li>findList() by ids</li>
-   * </ul>
-   * <p>
-   * Bean caching needs to be explicitly turned on for queries that are findList() by natural keys.
-   * </p>
-   */
-  AUTO(true, true),
-
-  /**
-   * Do not read from cache, but put beans into the cache and invalidate parts of the cache as necessary.
-   * <p>
-   * Use this on a query if you want to get the fresh value from database and put it into the cache.
-   */
-  PUT(false, true),
-
-  /**
-   * GET only from the cache.
-   * <p>
-   * This mode does not put entries into the cache or invalidate parts of the cache.
-   */
-  GET(true, false);
-
-  private final boolean get;
-  private final boolean put;
-
-  CacheMode(boolean get, boolean put) {
-    this.get = get;
-    this.put = put;
-  }
-
-  /**
-   * Return true if value is read from cache.
-   */
-  public boolean isGet() {
-    return get;
-  }
-
-  /**
-   * Return true if a newly loaded value (from database) is put into the cache.
-   */
-  public boolean isPut() {
-    return put;
-  }
-}

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

@@ -1,185 +0,0 @@
-package io.ebean;
-
-import java.sql.CallableStatement;
-import java.sql.SQLException;
-
-/**
- * For making calls to stored procedures. Refer to the Ebean execute() method.
- * <p>
- * Note that UpdateSql is designed for general DML sql and CallableSql is
- * designed for use with stored procedures. Also note that when using this in
- * batch mode the out parameters are not read.
- * </p>
- * <p>
- * Example 1:
- * </p>
- * <pre>{@code
- *
- * String sql = "{call sp_order_mod(?,?)}";
- *
- * CallableSql cs = DB.createCallableSql(sql);
- * cs.setParameter(1, "turbo");
- * cs.registerOut(2, Types.INTEGER);
- *
- * DB.execute(cs);
- *
- * // read the out parameter
- * Integer returnValue = (Integer) cs.getObject(2);
- *
- * }</pre>
- * <p>
- * Example 2:<br>
- * Includes batch mode, table modification information and label. Note that the
- * label is really only to help people reading the transaction logs to identify
- * the procedure called etc.
- * </p>
- *
- * <pre>{@code
- *
- * String sql = "{call sp_insert_order(?,?)}";
- *
- * CallableSql cs = DB.createCallableSql(sql);
- *
- * // Inform Ebean this stored procedure inserts into the
- * // oe_order table and inserts + updates the oe_order_detail table.
- * // this is used to invalidate objects in the cache
- * cs.addModification("oe_order", true, false, false);
- * cs.addModification("oe_order_detail", true, true, false);
- *
- *
- * try (Transaction t = DB.beginTransaction()) {
- *
- *   // execute using JDBC batching 10 statements at a time
- *   t.setBatchMode(true);
- *   t.setBatchSize(10);
- *
- *   cs.setParameter(1, "Was");
- *   cs.setParameter(2, "Banana");
- *   DB.execute(cs);
- *
- *   cs.setParameter(1, "Here");
- *   cs.setParameter(2, "Kumera");
- *   DB.execute(cs);
- *
- *   cs.setParameter(1, "More");
- *   cs.setParameter(2, "Apple");
- *   DB.execute(cs);
- *
- *   // DB.externalModification("oe_order",true,false,false);
- *   // DB.externalModification("oe_order_detail",true,true,false);
- *   t.commit();
- *
- * }
- * }</pre>
- *
- * @see SqlUpdate
- */
-public interface CallableSql {
-
-  /**
-   * Return the label that is put into the transaction log.
-   */
-  String getLabel();
-
-  /**
-   * Set the label that is put in the transaction log.
-   */
-  CallableSql setLabel(String label);
-
-  /**
-   * Return the statement execution timeout.
-   */
-  int getTimeout();
-
-  /**
-   * Return the callable sql.
-   */
-  String getSql();
-
-  /**
-   * Set the statement execution timeout. Zero implies unlimited time.
-   * <p>
-   * This is set to the underlying CallableStatement.
-   * </p>
-   */
-  CallableSql setTimeout(int secs);
-
-  /**
-   * Set the callable sql.
-   */
-  CallableSql setSql(String sql);
-
-  /**
-   * Bind a parameter that is bound as a IN parameter.
-   * <p>
-   * position starts at value 1 (not 0) to be consistent with CallableStatement.
-   * </p>
-   * <p>
-   * This is designed so that you do not need to set params in index order. You
-   * can set/register param 2 before param 1 etc.
-   * </p>
-   *
-   * @param position the index position of the parameter.
-   * @param value    the value of the parameter.
-   */
-  CallableSql bind(int position, Object value);
-
-  /**
-   * Bind a positioned parameter (same as bind method).
-   *
-   * @param position the index position of the parameter.
-   * @param value    the value of the parameter.
-   */
-  CallableSql setParameter(int position, Object value);
-
-  /**
-   * Register an OUT parameter.
-   * <p>
-   * Note that position starts at value 1 (not 0) to be consistent with
-   * CallableStatement.
-   * </p>
-   * <p>
-   * This is designed so that you do not need to register params in index order.
-   * You can set/register param 2 before param 1 etc.
-   * </p>
-   *
-   * @param position the index position of the parameter (starts with 1).
-   * @param type     the jdbc type of the OUT parameter that will be read.
-   */
-  CallableSql registerOut(int position, int type);
-
-  /**
-   * Return an OUT parameter value.
-   * <p>
-   * position starts at value 1 (not 0) to be consistent with CallableStatement.
-   * </p>
-   * <p>
-   * This can only be called after the CallableSql has been executed. When run
-   * in batch mode you effectively can't use this method.
-   * </p>
-   */
-  Object getObject(int position);
-
-  /**
-   * You can extend this object and override this method for more advanced
-   * stored procedure calls. This would be the case when ResultSets are returned
-   * etc.
-   */
-  boolean executeOverride(CallableStatement cstmt) throws SQLException;
-
-  /**
-   * Add table modification information to the TransactionEvent.
-   * <p>
-   * This would be similar to using the
-   * <code>DB.externalModification()</code> method. It may be easier and make
-   * more sense to set it here with the CallableSql.
-   * </p>
-   * <p>
-   * For UpdateSql the table modification information is derived by parsing the
-   * sql to determine the table name and whether it was an insert, update or
-   * delete.
-   * </p>
-   */
-  CallableSql addModification(String tableName, boolean inserts, boolean updates, boolean deletes);
-
-}

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

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

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

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

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

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

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

@@ -1,17 +0,0 @@
-package io.ebean;
-
-import javax.persistence.PersistenceException;
-
-/**
- * Thrown when a foreign key constraint is enforced.
- */
-public class DataIntegrityException extends PersistenceException {
-  private static final long serialVersionUID = -6740171949170180970L;
-
-  /**
-   * Create with a message and cause.
-   */
-  public DataIntegrityException(String message, Throwable cause) {
-    super(message, cause);
-  }
-}

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

@@ -1,170 +0,0 @@
-package io.ebean;
-
-import io.ebean.config.ContainerConfig;
-import io.ebean.config.DatabaseConfig;
-import io.ebean.service.SpiContainer;
-import io.ebean.service.SpiContainerFactory;
-
-import javax.persistence.PersistenceException;
-import java.util.Iterator;
-import java.util.Properties;
-import java.util.ServiceLoader;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * Creates Database instances.
- * <p>
- * This uses either DatabaseConfig or properties in the application.properties file to
- * configure and create a Database instance.
- * <p>
- * The Database instance can either be registered with the DB singleton or
- * not. The DB singleton effectively holds a map of Database by a name.
- * If the Database is registered with the DB singleton you can retrieve it
- * later via {@link DB#byName(String)}.
- * <p>
- * One Database can be nominated as the 'default/primary' Database. Many
- * methods on the DB singleton such as {@link DB#find(Class)} are just a
- * convenient way of using the 'default/primary' Database.
- */
-public class DatabaseFactory {
-
-  private static final ReentrantLock lock = new ReentrantLock();
-  private static SpiContainer container;
-  private static String defaultServerName;
-
-  static {
-    EbeanVersion.getVersion();
-  }
-
-  /**
-   * Initialise the container with clustering configuration.
-   * <p>
-   * Call this prior to creating any Database instances or alternatively set the
-   * ContainerConfig on the DatabaseConfig when creating the first Database instance.
-   */
-  public static void initialiseContainer(ContainerConfig containerConfig) {
-    lock.lock();
-    try {
-      container(containerConfig);
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Create using properties to configure the database.
-   */
-  public static Database create(String name) {
-    lock.lock();
-    try {
-      return container(null).createServer(name);
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Create using the DatabaseConfig object to configure the database.
-   *
-   * <pre>{@code
-   *
-   *   DatabaseConfig config = new DatabaseConfig();
-   *   config.setName("db");
-   *   config.loadProperties();
-   *
-   *   Database database = DatabaseFactory.create(config);
-   *
-   * }</pre>
-   */
-  public static Database create(DatabaseConfig config) {
-    lock.lock();
-    try {
-      if (config.getName() == null) {
-        throw new PersistenceException("The name is null (it is required)");
-      }
-      Database server = createInternal(config);
-      if (config.isRegister()) {
-        if (config.isDefaultServer()) {
-          if (defaultServerName != null && !defaultServerName.equals(config.getName())) {
-            throw new IllegalStateException("Registering [" + config.getName() + "] as the default server but [" + defaultServerName + "] is already registered as the default");
-          }
-          defaultServerName = config.getName();
-        }
-        DbPrimary.setSkip(true);
-        DbContext.getInstance().register(server, config.isDefaultServer());
-      }
-      return server;
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Create using the DatabaseConfig additionally specifying a classLoader to use as the context class loader.
-   */
-  public static Database createWithContextClassLoader(DatabaseConfig config, ClassLoader classLoader) {
-    lock.lock();
-    try {
-      ClassLoader currentContextLoader = Thread.currentThread().getContextClassLoader();
-      Thread.currentThread().setContextClassLoader(classLoader);
-      try {
-        return DatabaseFactory.create(config);
-      } finally {
-        // set the currentContextLoader back
-        Thread.currentThread().setContextClassLoader(currentContextLoader);
-      }
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Shutdown gracefully all Database instances cleaning up any resources as required.
-   * <p>
-   * This is typically invoked via JVM shutdown hook and not explicitly called.
-   */
-  public static void shutdown() {
-    lock.lock();
-    try {
-      container.shutdown();
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  private static Database createInternal(DatabaseConfig config) {
-    return container(config.getContainerConfig()).createServer(config);
-  }
-
-  /**
-   * Return the SpiContainer initialising it if necessary.
-   *
-   * @param containerConfig the configuration controlling clustering communication
-   */
-  private static SpiContainer container(ContainerConfig containerConfig) {
-    // thread safe in that all calling methods hold lock
-    if (container != null) {
-      return container;
-    }
-
-    if (containerConfig == null) {
-      // effectively load configuration from ebean.properties
-      Properties properties = DbPrimary.getProperties();
-      containerConfig = new ContainerConfig();
-      containerConfig.loadFromProperties(properties);
-    }
-    container = createContainer(containerConfig);
-    return container;
-  }
-
-  /**
-   * Create the container instance using the configuration.
-   */
-  protected static SpiContainer createContainer(ContainerConfig containerConfig) {
-    Iterator<SpiContainerFactory> factories = ServiceLoader.load(SpiContainerFactory.class).iterator();
-    if (factories.hasNext()) {
-      return factories.next().create(containerConfig);
-    }
-    throw new IllegalStateException("Service loader didn't find a SpiContainerFactory?");
-  }
-}

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

@@ -1,137 +0,0 @@
-package io.ebean;
-
-import io.ebean.config.BeanNotEnhancedException;
-import io.ebean.datasource.DataSourceConfigurationException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.persistence.PersistenceException;
-import java.util.HashMap;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * Holds Database instances.
- */
-final class DbContext {
-
-  private static final Logger log = LoggerFactory.getLogger("io.ebean");
-  static {
-    EbeanVersion.getVersion();
-  }
-
-  private static final DbContext INSTANCE = new DbContext();
-
-  private final ConcurrentHashMap<String, Database> concMap = new ConcurrentHashMap<>();
-
-  private final HashMap<String, Database> syncMap = new HashMap<>();
-
-  private final ReentrantLock lock = new ReentrantLock();
-
-  /**
-   * The 'default' Database.
-   */
-  private Database defaultDatabase;
-
-  private DbContext() {
-    try {
-      if (!DbPrimary.isSkip()) {
-        // look to see if there is a default server defined
-        String defaultName = DbPrimary.getDefaultServerName();
-        if (defaultName != null && !defaultName.trim().isEmpty()) {
-          defaultDatabase = getWithCreate(defaultName.trim());
-        }
-      }
-    } catch (BeanNotEnhancedException e) {
-      throw e;
-
-    } catch (DataSourceConfigurationException e) {
-      String msg = "Configuration error creating DataSource for the default Database." +
-        " This typically means a missing application-test.yaml or missing ebean-test dependency." +
-        " See https://ebean.io/docs/trouble-shooting#datasource";
-      throw new DataSourceConfigurationException(msg, e);
-
-    } catch (Throwable e) {
-      log.error("Error trying to create the default Database", e);
-      throw new RuntimeException(e);
-    }
-  }
-
-  /**
-   * Return the shared singleton instance.
-   */
-  static DbContext getInstance() {
-    return INSTANCE;
-  }
-
-  /**
-   * Return the default database.
-   */
-  Database getDefault() {
-    if (defaultDatabase == null) {
-      String msg = "The default Database has not been defined?";
-      msg += " This is normally set via the ebean.datasource.default property.";
-      msg += " Otherwise it should be registered programmatically via registerServer()";
-      throw new PersistenceException(msg);
-    }
-    return defaultDatabase;
-  }
-
-  /**
-   * Return the database by name.
-   */
-  Database get(String name) {
-    if (name == null || name.isEmpty()) {
-      return defaultDatabase;
-    }
-    Database server = concMap.get(name);
-    if (server != null) {
-      return server;
-    }
-    return getWithCreate(name);
-  }
-
-  /**
-   * Read, create and put of Databases.
-   */
-  private Database getWithCreate(String name) {
-    lock.lock();
-    try {
-      Database server = syncMap.get(name);
-      if (server == null) {
-        // register when creating server this way
-        server = DatabaseFactory.create(name);
-        register(server, false);
-      }
-      return server;
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Register a server so we can get it by its name.
-   */
-  void register(Database server, boolean isDefault) {
-    registerWithName(server.name(), server, isDefault);
-  }
-
-  private void registerWithName(String name, Database server, boolean isDefault) {
-    lock.lock();
-    try {
-      concMap.put(name, server);
-      syncMap.put(name, server);
-      if (isDefault) {
-        defaultDatabase = server;
-      }
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  Database mock(String name, Database server, boolean defaultServer) {
-    Database originalPrimaryServer = this.defaultDatabase;
-    registerWithName(name, server, defaultServer);
-    return originalPrimaryServer;
-  }
-}

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

@@ -1,96 +0,0 @@
-package io.ebean;
-
-import io.avaje.config.Config;
-
-import java.util.Properties;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * Provides singleton state for the default database.
- * <p/>
- * Intended for internal use as part of bootup, construction, registration of the default database.
- */
-class DbPrimary {
-
-  private static final ReentrantLock lock = new ReentrantLock();
-  private static String defaultServerName;
-  private static boolean skip;
-
-  /**
-   * Set whether to skip automatically creating the primary database.
-   */
-  static void setSkip(boolean skip) {
-    lock.lock();
-    try {
-      DbPrimary.skip = skip;
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Return true to skip automatically creating the primary database.
-   */
-  static boolean isSkip() {
-    lock.lock();
-    try {
-      return skip;
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Return the default database name.
-   */
-  static String getDefaultServerName() {
-    lock.lock();
-    try {
-      getProperties();
-      return defaultServerName;
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Return the default configuration Properties.
-   */
-  static Properties getProperties() {
-    lock.lock();
-    try {
-      if (defaultServerName == null) {
-        defaultServerName = determineDefaultServerName();
-      }
-      return Config.asProperties();
-    } finally {
-      lock.unlock();
-    }
-  }
-
-  /**
-   * Determine and return the default server name checking system environment variables and then global properties.
-   */
-  private static String determineDefaultServerName() {
-    String defaultServerName = System.getenv("EBEAN_DB");
-    defaultServerName = System.getProperty("db", defaultServerName);
-    defaultServerName = System.getProperty("ebean_db", defaultServerName);
-    if (isEmpty(defaultServerName)) {
-      defaultServerName = Config.get("datasource.default", null);
-      if (isEmpty(defaultServerName)) {
-        defaultServerName = Config.get("ebean.default.datasource", null);
-      }
-    }
-    if (defaultServerName == null) {
-      defaultServerName = "db";
-    }
-    return defaultServerName;
-  }
-
-  /**
-   * Return true if the string is null or empty.
-   */
-  private static boolean isEmpty(String value) {
-    return value == null || value.trim().isEmpty();
-  }
-}

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

@@ -1,94 +0,0 @@
-package io.ebean;
-
-/**
- * Bean holding the details to update the document store.
- */
-public final class DocStoreQueueEntry {
-
-  /**
-   * Action to either update or delete a document from the index.
-   */
-  public enum Action {
-
-    /**
-     * Action is to update a document in the doc store.
-     */
-    INDEX(1),
-
-    /**
-     * Action is to delete a document from the doc store..
-     */
-    DELETE(2),
-
-    /**
-     * An update is required based on a change to a nested/embedded object at a given path.
-     */
-    NESTED(3);
-
-    int value;
-
-    Action(int value) {
-      this.value = value;
-    }
-
-    /**
-     * Return the value associated with this action type.
-     */
-    public int getValue() {
-      return value;
-    }
-  }
-
-  private final Action type;
-
-  private final String queueId;
-
-  private final String path;
-
-  private final Object beanId;
-
-  /**
-   * Construct for an INDEX or DELETE action.
-   */
-  public DocStoreQueueEntry(Action type, String queueId, Object beanId) {
-    this(type, queueId, null, beanId);
-  }
-
-  /**
-   * Construct for an NESTED/embedded path invalidation action.
-   */
-  public DocStoreQueueEntry(Action type, String queueId, String path, Object beanId) {
-    this.type = type;
-    this.queueId = queueId;
-    this.path = path;
-    this.beanId = beanId;
-  }
-
-  /**
-   * Return the event type.
-   */
-  public Action getType() {
-    return type;
-  }
-
-  /**
-   * Return the associate queueId.
-   */
-  public String getQueueId() {
-    return queueId;
-  }
-
-  /**
-   * Return the path if this is a nested update.
-   */
-  public String getPath() {
-    return path;
-  }
-
-  /**
-   * Return the bean id (which matches the document id).
-   */
-  public Object getBeanId() {
-    return beanId;
-  }
-}

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

@@ -1,312 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.NonNullApi;
-import io.avaje.lang.Nullable;
-import io.ebean.docstore.DocQueryContext;
-import io.ebean.docstore.RawDoc;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-/**
- * Document storage operations.
- */
-@NonNullApi
-public interface DocumentStore {
-
-  /**
-   * Update the associated document store using the result of the query.
-   * <p>
-   * This will execute the query against the database creating a document for each
-   * bean graph and sending this to the document store.
-   * </p>
-   * <p>
-   * Note that the select and fetch paths of the query is set for you to match the
-   * document structure needed based on <code>@DocStore</code> and <code>@DocStoreEmbedded</code>
-   * so what this query requires is the predicates only.
-   * </p>
-   * <p>
-   * This query will be executed using findEach so it is safe to use a query
-   * that will fetch a lot of beans. The default bulkBatchSize is used.
-   * </p>
-   *
-   * @param query The query that selects object to send to the document store.
-   */
-  <T> void indexByQuery(Query<T> query);
-
-  /**
-   * Update the associated document store index using the result of the query additionally specifying a
-   * bulkBatchSize to use for sending the messages to ElasticSearch.
-   *
-   * @param query         The query that selects object to send to the document store.
-   * @param bulkBatchSize The batch size to use when bulk sending to the document store.
-   */
-  <T> void indexByQuery(Query<T> query, int bulkBatchSize);
-
-  /**
-   * Update the document store for all beans of this type.
-   * <p>
-   * This is the same as indexByQuery where the query has no predicates and so fetches all rows.
-   * </p>
-   */
-  void indexAll(Class<?> beanType);
-
-  /**
-   * Return the bean by fetching it's content from the document store.
-   * If the document is not found null is returned.
-   * <p>
-   * Typically this is called indirectly by findOne() on the query.
-   * </p>
-   * <pre>{@code
-   *
-   * Customer customer =
-   *   database.find(Customer.class)
-   *     .setUseDocStore(true)
-   *     .setId(42)
-   *     .findOne();
-   *
-   * }</pre>
-   */
-  @Nullable
-  <T> T find(DocQueryContext<T> request);
-
-  /**
-   * Execute the find list query. This request is prepared to execute secondary queries.
-   * <p>
-   * Typically this is called indirectly by findList() on the query that has setUseDocStore(true).
-   * </p>
-   * <pre>{@code
-   *
-   * List<Customer> newCustomers =
-   *  database.find(Customer.class)
-   *    .setUseDocStore(true)
-   *    .where().eq("status, Customer.Status.NEW)
-   *    .findList();
-   *
-   * }</pre>
-   */
-  <T> List<T> findList(DocQueryContext<T> request);
-
-  /**
-   * Execute the query against the document store returning the paged list.
-   * <p>
-   * The query should have <code>firstRow</code> or <code>maxRows</code> set prior to calling this method.
-   * </p>
-   * <p>
-   * Typically this is called indirectly by findPagedList() on the query that has setUseDocStore(true).
-   * </p>
-   * <pre>{@code
-   *
-   * PagedList<Customer> newCustomers =
-   *  database.find(Customer.class)
-   *    .setUseDocStore(true)
-   *    .where().eq("status, Customer.Status.NEW)
-   *    .setMaxRows(50)
-   *    .findPagedList();
-   *
-   * }</pre>
-   */
-  <T> PagedList<T> findPagedList(DocQueryContext<T> request);
-
-  /**
-   * Execute the query against the document store with the expectation of a large set of results
-   * that are processed in a scrolling resultSet fashion.
-   * <p>
-   * For example, with the ElasticSearch doc store this uses SCROLL.
-   * </p>
-   * <p>
-   * Typically this is called indirectly by findEach() on the query that has setUseDocStore(true).
-   * </p>
-   * <pre>{@code
-   *
-   *  database.find(Order.class)
-   *    .setUseDocStore(true)
-   *    .where()... // perhaps add predicates
-   *    .findEach((Order order) -> {
-   *      // process the bean ...
-   *    });
-   *
-   * }</pre>
-   */
-  <T> void findEach(DocQueryContext<T> query, Consumer<T> consumer);
-
-  /**
-   * Execute the query against the document store with the expectation of a large set of results
-   * that are processed in a scrolling resultSet fashion.
-   * <p>
-   * Unlike findEach() this provides the opportunity to stop iterating through the large query.
-   * </p>
-   * <p>
-   * For example, with the ElasticSearch doc store this uses SCROLL.
-   * </p>
-   * <p>
-   * Typically this is called indirectly by findEachWhile() on the query that has setUseDocStore(true).
-   * </p>
-   * <pre>{@code
-   *
-   *  database.find(Order.class)
-   *    .setUseDocStore(true)
-   *    .where()... // perhaps add predicates
-   *    .findEachWhile(new Predicate<Order>() {
-   *      @Override
-   *      public void accept(Order bean) {
-   *        // process the bean
-   *
-   *        // return true to continue, false to stop
-   *        // boolean shouldContinue = ...
-   *        return shouldContinue;
-   *      }
-   *    });
-   *
-   * }</pre>
-   */
-  <T> void findEachWhile(DocQueryContext<T> query, Predicate<T> consumer);
-
-  /**
-   * Find each processing raw documents.
-   *
-   * @param indexNameType The full index name and type
-   * @param rawQuery      The query to execute
-   * @param consumer      Consumer to process each document
-   */
-  void findEach(String indexNameType, String rawQuery, Consumer<RawDoc> consumer);
-
-  /**
-   * Find each processing raw documents stopping when the predicate returns false.
-   *
-   * @param indexNameType The full index name and type
-   * @param rawQuery      The query to execute
-   * @param consumer      Consumer to process each document until false is returned
-   */
-  void findEachWhile(String indexNameType, String rawQuery, Predicate<RawDoc> consumer);
-
-  /**
-   * Process the queue entries sending updates to the document store or queuing them for later processing.
-   */
-  long process(List<DocStoreQueueEntry> queueEntries) throws IOException;
-
-  /**
-   * Drop the index from the document store (similar to DDL drop table).
-   * <pre>{@code
-   *
-   *   DocumentStore documentStore = database.docStore();
-   *
-   *   documentStore.dropIndex("product_copy");
-   *
-   * }</pre>
-   */
-  void dropIndex(String indexName);
-
-  /**
-   * Create an index given a mapping file as a resource in the classPath (similar to DDL create table).
-   * <pre>{@code
-   *
-   *   DocumentStore documentStore = database.docStore();
-   *
-   *   // uses product_copy.mapping.json resource
-   *   // ... to define mappings for the index
-   *
-   *   documentStore.createIndex("product_copy", null);
-   *
-   * }</pre>
-   *
-   * @param indexName the name of the new index
-   * @param alias     the alias of the index
-   */
-  void createIndex(String indexName, String alias);
-
-  /**
-   * Modify the settings on an index.
-   * <p>
-   * For example, this can be used be used to set elasticSearch refresh_interval
-   * on an index before a bulk update.
-   * </p>
-   * <pre>{@code
-   *
-   *   // refresh_interval -1 ... disable refresh while bulk loading
-   *
-   *   Map<String,Object> settings = new LinkedHashMap<>();
-   *   settings.put("refresh_interval", "-1");
-   *
-   *   documentStore.indexSettings("product", settings);
-   *
-   * }</pre>
-   * <pre>{@code
-   *
-   *   // refresh_interval 1s ... restore after bulk loading
-   *
-   *   Map<String,Object> settings = new LinkedHashMap<>();
-   *   settings.put("refresh_interval", "1s");
-   *
-   *   documentStore.indexSettings("product", settings);
-   *
-   * }</pre>
-   *
-   * @param indexName the name of the index to update settings on
-   * @param settings  the settings to set on the index
-   */
-  void indexSettings(String indexName, Map<String, Object> settings);
-
-  /**
-   * Copy the index to a new index.
-   * <p>
-   * This copy process does not use the database but instead will copy from the source index to a destination index.
-   * </p>
-   * <pre>{@code
-   *
-   *  long copyCount = documentStore.copyIndex(Product.class, "product_copy");
-   *
-   * }</pre>
-   *
-   * @param beanType The bean type of the source index
-   * @param newIndex The name of the index to copy to
-   * @return the number of documents copied to the new index
-   */
-  long copyIndex(Class<?> beanType, String newIndex);
-
-  /**
-   * Copy entries from an index to a new index but limiting to documents that have been
-   * modified since the sinceEpochMillis time.
-   * <p>
-   * To support this the document needs to have a <code>@WhenModified</code> property.
-   * </p>
-   * <pre>{@code
-   *
-   *  long copyCount = documentStore.copyIndex(Product.class, "product_copy", sinceMillis);
-   *
-   * }</pre>
-   *
-   * @param beanType The bean type of the source index
-   * @param newIndex The name of the index to copy to
-   * @return the number of documents copied to the new index
-   */
-  long copyIndex(Class<?> beanType, String newIndex, long sinceEpochMillis);
-
-  /**
-   * Copy from a source index to a new index taking only the documents
-   * matching the given query.
-   * <pre>{@code
-   *
-   *  // predicates to select the source documents to copy
-   *  Query<Product> query = database.find(Product.class)
-   *    .where()
-   *      .ge("whenModified", new Timestamp(since))
-   *      .ge("name", "A")
-   *      .lt("name", "D")
-   *      .query();
-   *
-   *  // copy from the source index to "product_copy" index
-   *  long copyCount = documentStore.copyIndex(query, "product_copy", 1000);
-   *
-   * }</pre>
-   *
-   * @param query         The query to select the source documents to copy
-   * @param newIndex      The target index to copy the documents to
-   * @param bulkBatchSize The ElasticSearch bulk batch size, if 0 uses the default.
-   * @return The number of documents copied to the new index.
-   */
-  long copyIndex(Query<?> query, String newIndex, int bulkBatchSize);
-}

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

@@ -1,198 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.NonNullApi;
-import io.avaje.lang.Nullable;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
-
-/**
- * Query for performing native SQL queries that return DTO Bean's.
- * <p>
- * These beans are just normal classes. They must have public constructors
- * and setters.
- * <p>
- * Constructors with arguments are used if the number of constructor arguments
- * matches the number of columns in the resultSet.
- * </p>
- * <p>
- * If the number of columns in the resultSet is greater than the largest constructor
- * then the largest constructor is used for the first columns and remaining columns
- * are mapped by setter methods.
- * </p>
- *
- * <pre>{@code
- *
- *   // CustomerDto is just a 'bean like' class
- *   // with public constructor(s) and public setter methods
- *
- *   String sql = "select id, name from customer where name like :name and status_code = :status";
- *
- *   List<CustomerDto> beans =
- *     DB.findDto(CustomerDto.class, sql)
- *     .setParameter("name", "Acme%")
- *     .setParameter("status", "ACTIVE")
- *     .findList();
- *
- * }</pre>
- */
-@NonNullApi
-public interface DtoQuery<T> extends CancelableQuery {
-
-  /**
-   * Execute the query returning a list.
-   */
-  List<T> findList();
-
-  /**
-   * Execute the query iterating a row at a time.
-   * <p>
-   * Note that the QueryIterator holds resources related to the underlying
-   * resultSet and potentially connection and MUST be closed. We should use
-   * QueryIterator in a <em>try with resource block</em>.
-   */
-  QueryIterator<T> findIterate();
-
-  /**
-   * Execute the query returning a Stream.
-   * <p>
-   * Note that the Stream holds resources related to the underlying
-   * resultSet and potentially connection and MUST be closed. We should use
-   * the Stream in a <em>try with resource block</em>.
-   */
-  Stream<T> findStream();
-
-  /**
-   * Execute the query iterating a row at a time.
-   * <p>
-   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
-   * </p>
-   */
-  void findEach(Consumer<T> consumer);
-
-  /**
-   * Execute the query iterating the results and batching them for the consumer.
-   * <p>
-   * This runs like findEach streaming results from the database but just collects the results
-   * into batches to pass to the consumer.
-   *
-   * @param batch    The number of dto beans to collect before given them to the consumer
-   * @param consumer The consumer to process the batch of DTO beans
-   */
-  void findEach(int batch, Consumer<List<T>> consumer);
-
-  /**
-   * Execute the query iterating a row at a time with the ability to stop consuming part way through.
-   * <p>
-   * Returning false after processing a row stops the iteration through the query results.
-   * </p>
-   * <p>
-   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
-   * </p>
-   */
-  void findEachWhile(Predicate<T> consumer);
-
-  /**
-   * Execute the query returning a single bean.
-   */
-  @Nullable
-  T findOne();
-
-  /**
-   * Execute the query returning an optional bean.
-   */
-  Optional<T> findOneOrEmpty();
-
-  /**
-   * Bind all the parameters using index positions.
-   * <p>
-   * Binds each parameter moving the index position each time.
-   * <p>
-   * A convenience for multiple calls to {@link #setParameter(Object)}
-   */
-  DtoQuery<T> setParameters(Object... value);
-
-  /**
-   * Bind the next parameter using index position.
-   * <p>
-   * Bind the parameter using index position starting at 1 and incrementing.
-   * <p>
-   */
-  DtoQuery<T> setParameter(Object value);
-
-  /**
-   * Bind the named parameter.
-   */
-  DtoQuery<T> setParameter(String name, Object value);
-
-  /**
-   * Bind the named multi-value array parameter which we would use with Postgres ANY.
-   * <p>
-   * For Postgres this binds an ARRAY rather than expands into multiple bind values.
-   */
-  DtoQuery<T> setArrayParameter(String name, Collection<?> values);
-
-  /**
-   * Bind the parameter by its index position (1 based like JDBC).
-   */
-  DtoQuery<T> setParameter(int position, Object value);
-
-  /**
-   * Set the index of the first row of the results to return.
-   */
-  DtoQuery<T> setFirstRow(int firstRow);
-
-  /**
-   * Set the maximum number of query results to return.
-   */
-  DtoQuery<T> setMaxRows(int maxRows);
-
-  /**
-   * When resultSet columns are not able to be mapped to a bean property then instead of
-   * throwing effectively skip reading that column.
-   */
-  DtoQuery<T> setRelaxedMode();
-
-  /**
-   * Set a label on the query to make it easier to identify queries related to query execution statistics.
-   *
-   * @param label A label that is unique to the DTO bean type.
-   */
-  DtoQuery<T> setLabel(String label);
-
-  /**
-   * Set the profile location of this query. This is used to relate query execution metrics
-   * back to a location like a specific line of code.
-   */
-  DtoQuery<T> setProfileLocation(ProfileLocation profileLocation);
-
-  /**
-   * Set a timeout on this query.
-   * <p>
-   * This will typically result in a call to setQueryTimeout() on a
-   * preparedStatement. If the timeout occurs an exception will be thrown - this
-   * will be a SQLException wrapped up in a PersistenceException.
-   * </p>
-   *
-   * @param secs the query timeout limit in seconds. Zero means there is no limit.
-   */
-  DtoQuery<T> setTimeout(int secs);
-
-  /**
-   * A hint which for JDBC translates to the Statement.fetchSize().
-   * <p>
-   * Gives the JDBC driver a hint as to the number of rows that should be
-   * fetched from the database when more rows are needed for ResultSet.
-   * </p>
-   */
-  DtoQuery<T> setBufferFetchSizeHint(int bufferFetchSizeHint);
-
-  /**
-   * Use the explicit transaction to execute the query.
-   */
-  DtoQuery<T> usingTransaction(Transaction transaction);
-}

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

@@ -1,15 +0,0 @@
-package io.ebean;
-
-/**
- * Thrown when a duplicate is attempted on a unique constraint.
- */
-public class DuplicateKeyException extends DataIntegrityException {
-  private static final long serialVersionUID = -4771932723285724817L;
-
-  /**
-   * Create with a message and cause.
-   */
-  public DuplicateKeyException(String message, Throwable cause) {
-    super(message, cause);
-  }
-}

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

@@ -1,15 +0,0 @@
-package io.ebean;
-
-/**
- * Deprecated - please migrate to <code>io.ebean.Database</code>.
- * Provides the API for fetching and saving beans to a particular Database.
- * <p>
- * Effectively this is an alias for {@link Database} which is now the new
- * and improved name for EbeanServer.
- * <p>
- * The preference is to use DB and Database rather than Ebean and EbeanServer.
- */
-@Deprecated
-public interface EbeanServer extends Database {
-
-}

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

@@ -1,70 +0,0 @@
-package io.ebean;
-
-import io.ebean.config.ContainerConfig;
-import io.ebean.config.ServerConfig;
-
-/**
- * Deprecated - please migrate to DatabaseFactory.
- * <p>
- * Creates EbeanServer instances.
- * <p>
- * This uses either a ServerConfig or properties in the ebean.properties file to
- * configure and create a EbeanServer instance.
- * </p>
- * <p>
- * The EbeanServer instance can either be registered with the Ebean singleton or
- * not. The Ebean singleton effectively holds a map of EbeanServers by a name.
- * If the EbeanServer is registered with the Ebean singleton you can retrieve it
- * later via {@link Ebean#getServer(String)}.
- * </p>
- * <p>
- * One EbeanServer can be nominated as the 'default/primary' EbeanServer. Many
- * methods on the Ebean singleton such as {@link Ebean#find(Class)} are just a
- * convenient way of using the 'default/primary' EbeanServer.
- * </p>
- */
-@Deprecated
-public class EbeanServerFactory {
-
-  /**
-   * Initialise the container with clustering configuration.
-   * <p>
-   * Call this prior to creating any EbeanServer instances or alternatively set the
-   * ContainerConfig on the ServerConfig when creating the first EbeanServer instance.
-   */
-  public static void initialiseContainer(ContainerConfig containerConfig) {
-    DatabaseFactory.initialiseContainer(containerConfig);
-  }
-
-  /**
-   * Create using ebean.properties to configure the database.
-   */
-  public static EbeanServer create(String name) {
-    return (EbeanServer)DatabaseFactory.create(name);
-  }
-
-  /**
-   * Create using the ServerConfig object to configure the database.
-   */
-  public static EbeanServer create(ServerConfig config) {
-    return (EbeanServer)DatabaseFactory.create(config);
-  }
-
-  /**
-   * Create using the ServerConfig additionally specifying a classLoader to use as the context class loader.
-   */
-  public static EbeanServer createWithContextClassLoader(ServerConfig config, ClassLoader classLoader) {
-    return (EbeanServer)DatabaseFactory.createWithContextClassLoader(config, classLoader);
-  }
-
-  /**
-   * Shutdown gracefully all EbeanServers cleaning up any resources as required.
-   * <p>
-   * This is typically invoked via JVM shutdown hook and not explicitly called.
-   * </p>
-   */
-  public static void shutdown() {
-    DatabaseFactory.shutdown();
-  }
-
-}

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

@@ -1,97 +0,0 @@
-package io.ebean;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Properties;
-
-/**
- * Class to determine the ebean version.
- *
- * @author Roland Praml, FOCONIS AG
- */
-public class EbeanVersion {
-
-  private static final Logger log = LoggerFactory.getLogger("io.ebean");
-
-  /**
-   * Maintain the minimum ebean-agent version manually based on required ebean-agent bug fixes.
-   */
-  private static final int MIN_AGENT_MAJOR_VERSION = 12;
-  private static final int MIN_AGENT_MINOR_VERSION = 12;
-  private static String version = "unknown";
-  static {
-    readVersion();
-    checkAgentVersion();
-  }
-
-  private static void readVersion() {
-    try {
-      try (InputStream in = ClassLoader.getSystemResourceAsStream("META-INF/maven/io.ebean/ebean-api/pom.properties")) {
-        if (in != null) {
-          version = readVersion(in);
-        }
-      }
-      log.info("ebean version: {}", version);
-    } catch (IOException e) {
-      log.warn("Could not determine ebean version: {}", e.getMessage());
-    }
-  }
-
-  private static void checkAgentVersion() {
-    try {
-      try (InputStream in = ClassLoader.getSystemResourceAsStream("META-INF/maven/io.ebean/ebean-agent/pom.properties")) {
-        // often we only have ebean-agent during development (with build time enhancement), null is expected
-        if (in != null) {
-          String agentVersion = readVersion(in);
-          if (agentVersion != null) {
-            if (checkMinAgentVersion(agentVersion)) {
-              log.error("Expected minimum ebean-agent version {}.{}.0 but we have {}, please update the ebean-agent", MIN_AGENT_MAJOR_VERSION, MIN_AGENT_MINOR_VERSION, agentVersion);
-            }
-          }
-        }
-      }
-    } catch (IOException e) {
-      log.warn("Could not check minimum ebean-agent version {}.{}.0 required due to - {}", MIN_AGENT_MAJOR_VERSION, MIN_AGENT_MINOR_VERSION, e.getMessage());
-    }
-  }
-
-  /**
-   * Return true if ebean-agent is NOT at our minimum version.
-   */
-  static boolean checkMinAgentVersion(String agentVersion) {
-    String[] versionSegments = agentVersion.split("\\.");
-    if (versionSegments.length != 3) {
-      return true;
-    } else {
-      int major = Integer.parseInt(versionSegments[0]);
-      int minor = Integer.parseInt(versionSegments[1]);
-      if (major < MIN_AGENT_MAJOR_VERSION) {
-        return true;
-      } else {
-        return major == MIN_AGENT_MAJOR_VERSION && minor < MIN_AGENT_MINOR_VERSION;
-      }
-    }
-  }
-
-  private static String readVersion(InputStream in) throws IOException {
-    Properties prop = new Properties();
-    prop.load(in);
-    in.close();
-    return prop.getProperty("version");
-  }
-
-  private EbeanVersion() {
-    // hide
-  }
-
-  /**
-   * Returns the ebean version (read from /META-INF/maven/io.ebean/ebean/pom.properties)
-   */
-  public static String getVersion() {
-    return version;
-  }
-
-}

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

@@ -1,71 +0,0 @@
-package io.ebean;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.Future;
-
-/**
- * An empty PagedList.
- * <p>
- * For use in application code when we need to return a PagedList but don't want to
- * execute a query.
- * </p>
- *
- * <pre>{@code
- *
- *   PagedList<Customer> empty = PagedList.emptyList();
- *
- * }</pre>
- */
-public class EmptyPagedList<T> implements PagedList<T> {
-
-  @Override
-  public void loadCount() {
-    // do nothing
-  }
-
-  @Override
-  public Future<Integer> getFutureCount() {
-    return null;
-  }
-
-  @Override
-  public List<T> getList() {
-    return Collections.emptyList();
-  }
-
-  @Override
-  public int getTotalCount() {
-    return 0;
-  }
-
-  @Override
-  public int getTotalPageCount() {
-    return 0;
-  }
-
-  @Override
-  public int getPageSize() {
-    return 0;
-  }
-
-  @Override
-  public int getPageIndex() {
-    return 0;
-  }
-
-  @Override
-  public boolean hasNext() {
-    return false;
-  }
-
-  @Override
-  public boolean hasPrev() {
-    return false;
-  }
-
-  @Override
-  public String getDisplayXtoYofZ(String to, String of) {
-    return "";
-  }
-}

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

@@ -1,93 +0,0 @@
-package io.ebean;
-
-/**
- * Query by Example expression.
- * <p>
- * Pass in an example entity and for each non-null scalar properties an
- * expression is added.
- * </p>
- * <p>
- * By Default this case sensitive, will ignore numeric zero values and will use
- * a Like for string values (you must put in your own wildcards).
- * </p>
- * <p>
- * To get control over the options you can create an ExampleExpression and set
- * those options such as case insensitive etc.
- * </p>
- *
- * <pre>{@code
- * // create an example bean and set the properties
- * // with the query parameters you want
- * Customer example = new Customer();
- * example.setName("Rob%");
- * example.setNotes("%something%");
- *
- * List<Customer> list =
- *     DB.find(Customer.class)
- *         .where()
- *         // pass the bean into the where() clause
- *         .exampleLike(example)
- *         // you can add other expressions to the same query
- *         .gt("id", 2)
- *         .findList();
- *
- * }</pre>
- *
- * Similarly you can create an ExampleExpression
- *
- * <pre>{@code
- *
- * Customer example = new Customer();
- * example.setName("Rob%");
- * example.setNotes("%something%");
- *
- * // create a ExampleExpression with more control
- * ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO)
- *     .includeZeros();
- *
- * List<Customer> list =
- *     DB.find(Customer.class)
- *         .where()
- *         .add(qbe)
- *         .findList();
- *
- * }</pre>
- */
-public interface ExampleExpression extends Expression {
-
-  /**
-   * By calling this method zero value properties are going to be included in
-   * the expression.
-   * <p>
-   * By default numeric zero values are excluded as they can result from
-   * primitive int and long types.
-   * </p>
-   */
-  ExampleExpression includeZeros();
-
-  /**
-   * Set case insensitive to true.
-   */
-  ExampleExpression caseInsensitive();
-
-  /**
-   * Use startsWith expression for string properties.
-   */
-  ExampleExpression useStartsWith();
-
-  /**
-   * Use contains expression for string properties.
-   */
-  ExampleExpression useContains();
-
-  /**
-   * Use endsWith expression for string properties.
-   */
-  ExampleExpression useEndsWith();
-
-  /**
-   * Use equal to expression for string properties.
-   */
-  ExampleExpression useEqualTo();
-
-}

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

@@ -1,361 +0,0 @@
-package io.ebean;
-
-import java.util.Collection;
-import java.util.Map;
-
-/**
- * Expression factory for creating standard expressions for WHERE and HAVING
- * clauses.
- * <p>
- * Generally you will only need to use this object for creating OR, JUNCTION or
- * CONJUNCTION expressions. To create simple expressions you will most likely
- * just use the methods on the ExpressionList object that is returned via
- * {@link Query#where()}.
- * </p>
- * <p>
- * This provides a convenient way to create expressions for the default
- * database.
- * <p>
- * See also {@link DB#expressionFactory()}
- * </p>
- * <p>
- * Creates standard common expressions for using in a Query Where or Having
- * clause.
- * </p>
- *
- * @see Query#where()
- */
-public class Expr {
-
-  private Expr() {
-  }
-
-  /**
-   * Equal To - property equal to the given value.
-   */
-  public static Expression eq(String propertyName, Object value) {
-    return DB.expressionFactory().eq(propertyName, value);
-  }
-
-  /**
-   * Not Equal To - property not equal to the given value.
-   */
-  public static Expression ne(String propertyName, Object value) {
-    return DB.expressionFactory().ne(propertyName, value);
-  }
-
-  /**
-   * Case Insensitive Equal To - property equal to the given value (typically
-   * using a lower() function to make it case insensitive).
-   */
-  public static Expression ieq(String propertyName, String value) {
-    return DB.expressionFactory().ieq(propertyName, value);
-  }
-
-  /**
-   * In Range - {@code property >= value1 and property < value2}.
-   * <p>
-   * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
-   * </p>
-   */
-  public static Expression inRange(String propertyName, Object value1, Object value2) {
-    return DB.expressionFactory().inRange(propertyName, value1, value2);
-  }
-
-  /**
-   * Between - property between the two given values.
-   */
-  public static Expression between(String propertyName, Object value1, Object value2) {
-    return DB.expressionFactory().between(propertyName, value1, value2);
-  }
-
-  /**
-   * Between - value between two given properties.
-   */
-  public static Expression between(String lowProperty, String highProperty, Object value) {
-    return DB.expressionFactory().betweenProperties(lowProperty, highProperty, value);
-  }
-
-  /**
-   * Greater Than - property greater than the given value.
-   */
-  public static Expression gt(String propertyName, Object value) {
-    return DB.expressionFactory().gt(propertyName, value);
-  }
-
-  /**
-   * Greater Than or Equal to - property greater than or equal to the given
-   * value.
-   */
-  public static Expression ge(String propertyName, Object value) {
-    return DB.expressionFactory().ge(propertyName, value);
-  }
-
-  /**
-   * Less Than - property less than the given value.
-   */
-  public static Expression lt(String propertyName, Object value) {
-    return DB.expressionFactory().lt(propertyName, value);
-  }
-
-  /**
-   * Less Than or Equal to - property less than or equal to the given value.
-   */
-  public static Expression le(String propertyName, Object value) {
-    return DB.expressionFactory().le(propertyName, value);
-  }
-
-  /**
-   * Is Null - property is null.
-   */
-  public static Expression isNull(String propertyName) {
-    return DB.expressionFactory().isNull(propertyName);
-  }
-
-  /**
-   * Is Not Null - property is not null.
-   */
-  public static Expression isNotNull(String propertyName) {
-    return DB.expressionFactory().isNotNull(propertyName);
-  }
-
-  /**
-   * Case insensitive {@link #exampleLike(Object)}
-   */
-  public static ExampleExpression iexampleLike(Object example) {
-    return DB.expressionFactory().iexampleLike(example);
-  }
-
-  /**
-   * Create the query by Example expression which is case sensitive and using
-   * LikeType.RAW (you need to add you own wildcards % and _).
-   */
-  public static ExampleExpression exampleLike(Object example) {
-    return DB.expressionFactory().exampleLike(example);
-  }
-
-  /**
-   * Create the query by Example expression specifying more options.
-   */
-  public static ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType) {
-    return DB.expressionFactory().exampleLike(example, caseInsensitive, likeType);
-  }
-
-  /**
-   * Like - property like value where the value contains the SQL wild card
-   * characters % (percentage) and _ (underscore).
-   */
-  public static Expression like(String propertyName, String value) {
-    return DB.expressionFactory().like(propertyName, value);
-  }
-
-  /**
-   * Case insensitive Like - property like value where the value contains the
-   * SQL wild card characters % (percentage) and _ (underscore). Typically uses
-   * a lower() function to make the expression case insensitive.
-   */
-  public static Expression ilike(String propertyName, String value) {
-    return DB.expressionFactory().ilike(propertyName, value);
-  }
-
-  /**
-   * Starts With - property like value%.
-   */
-  public static Expression startsWith(String propertyName, String value) {
-    return DB.expressionFactory().startsWith(propertyName, value);
-  }
-
-  /**
-   * Case insensitive Starts With - property like value%. Typically uses a
-   * lower() function to make the expression case insensitive.
-   */
-  public static Expression istartsWith(String propertyName, String value) {
-    return DB.expressionFactory().istartsWith(propertyName, value);
-  }
-
-  /**
-   * Ends With - property like %value.
-   */
-  public static Expression endsWith(String propertyName, String value) {
-    return DB.expressionFactory().endsWith(propertyName, value);
-  }
-
-  /**
-   * Case insensitive Ends With - property like %value. Typically uses a lower()
-   * function to make the expression case insensitive.
-   */
-  public static Expression iendsWith(String propertyName, String value) {
-    return DB.expressionFactory().iendsWith(propertyName, value);
-  }
-
-  /**
-   * Contains - property like %value%.
-   */
-  public static Expression contains(String propertyName, String value) {
-    return DB.expressionFactory().contains(propertyName, value);
-  }
-
-  /**
-   * Case insensitive Contains - property like %value%. Typically uses a lower()
-   * function to make the expression case insensitive.
-   */
-  public static Expression icontains(String propertyName, String value) {
-    return DB.expressionFactory().icontains(propertyName, value);
-  }
-
-  /**
-   * For collection properties that are empty (have not existing elements).
-   */
-  public static Expression isEmpty(String propertyName) {
-    return DB.expressionFactory().isEmpty(propertyName);
-  }
-
-  /**
-   * For collection properties that are not empty (have existing elements).
-   */
-  public static Expression isNotEmpty(String propertyName) {
-    return DB.expressionFactory().isNotEmpty(propertyName);
-  }
-
-  /**
-   * In - property has a value in the array of values.
-   */
-  public static Expression in(String propertyName, Object[] values) {
-    return DB.expressionFactory().in(propertyName, values);
-  }
-
-  /**
-   * In - using a subQuery.
-   */
-  public static Expression in(String propertyName, Query<?> subQuery) {
-    return DB.expressionFactory().in(propertyName, subQuery);
-  }
-
-  /**
-   * In - property has a value in the collection of values.
-   */
-  public static Expression in(String propertyName, Collection<?> values) {
-    return DB.expressionFactory().in(propertyName, values);
-  }
-
-  /**
-   * In where null or empty values means that no predicate is added to the query.
-   * <p>
-   * That is, only add the IN predicate if the values are not null or empty.
-   * <p>
-   * Without this we typically need to code an <code>if</code> block to only add
-   * the IN predicate if the collection is not empty like:
-   * </p>
-   *
-   * <h3>Without inOrEmpty()</h3>
-   * <pre>{@code
-   *
-   *   query.where() // add some predicates
-   *     .eq("status", Status.NEW);
-   *
-   *   if (ids != null && !ids.isEmpty()) {
-   *     query.where().in("customer.id", ids);
-   *   }
-   *
-   *   query.findList();
-   *
-   * }</pre>
-   *
-   * <h3>Using inOrEmpty()</h3>
-   * <pre>{@code
-   *
-   *   query.where()
-   *     .eq("status", Status.NEW)
-   *     .inOrEmpty("customer.id", ids)
-   *     .findList();
-   *
-   * }</pre>
-   */
-  public static Expression inOrEmpty(String propertyName, Collection<?> values) {
-    return DB.expressionFactory().inOrEmpty(propertyName, values);
-  }
-
-  /**
-   * Id Equal to - ID property is equal to the value.
-   */
-  public static Expression idEq(Object value) {
-    return DB.expressionFactory().idEq(value);
-  }
-
-  /**
-   * All Equal - Map containing property names and their values.
-   * <p>
-   * Expression where all the property names in the map are equal to the
-   * corresponding value.
-   * </p>
-   *
-   * @param propertyMap a map keyed by property names.
-   */
-  public static Expression allEq(Map<String, Object> propertyMap) {
-    return DB.expressionFactory().allEq(propertyMap);
-  }
-
-  /**
-   * Add raw expression with a single parameter.
-   * <p>
-   * The raw expression should contain a single ? at the location of the
-   * parameter.
-   * </p>
-   */
-  public static Expression raw(String raw, Object value) {
-    return DB.expressionFactory().raw(raw, value);
-  }
-
-  /**
-   * Add raw expression with an array of parameters.
-   * <p>
-   * The raw expression should contain the same number of ? as there are
-   * parameters.
-   * </p>
-   */
-  public static Expression raw(String raw, Object[] values) {
-    return DB.expressionFactory().raw(raw, values);
-  }
-
-  /**
-   * Add raw expression with no parameters.
-   */
-  public static Expression raw(String raw) {
-    return DB.expressionFactory().raw(raw);
-  }
-
-  /**
-   * And - join two expressions with a logical and.
-   */
-  public static Expression and(Expression expOne, Expression expTwo) {
-    return DB.expressionFactory().and(expOne, expTwo);
-  }
-
-  /**
-   * Or - join two expressions with a logical or.
-   */
-  public static Expression or(Expression expOne, Expression expTwo) {
-    return DB.expressionFactory().or(expOne, expTwo);
-  }
-
-  /**
-   * Negate the expression (prefix it with NOT).
-   */
-  public static Expression not(Expression exp) {
-    return DB.expressionFactory().not(exp);
-  }
-
-  /**
-   * Return a list of expressions that will be joined by AND's.
-   */
-  public static <T> Junction<T> conjunction(Query<T> query) {
-    return DB.expressionFactory().conjunction(query);
-  }
-
-  /**
-   * Return a list of expressions that will be joined by OR's.
-   */
-  public static <T> Junction<T> disjunction(Query<T> query) {
-    return DB.expressionFactory().disjunction(query);
-  }
-}

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

@@ -1,8 +0,0 @@
-package io.ebean;
-
-/**
- * An expression that is part of a WHERE or HAVING clause.
- */
-public interface Expression {
-
-}

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

@@ -1,563 +0,0 @@
-package io.ebean;
-
-import io.ebean.search.Match;
-import io.ebean.search.MultiMatch;
-import io.ebean.search.TextCommonTerms;
-import io.ebean.search.TextQueryString;
-import io.ebean.search.TextSimple;
-
-import java.util.Collection;
-import java.util.Map;
-
-/**
- * Expression factory for creating standard expressions.
- * <p>
- * Creates standard common expressions for using in a Query Where or Having
- * clause.
- * </p>
- * <p>
- * You will often not use this class directly but instead just add expressions
- * via the methods on ExpressionList such as
- * {@link ExpressionList#gt(String, Object)}.
- * </p>
- * <p>
- * The ExpressionList is returned from {@link Query#where()}.
- * </p>
- * <pre>{@code
- * // Example: fetch orders where status equals new or orderDate > lastWeek.
- *
- * Expression newOrLastWeek =
- *     Expr.or(Expr.eq("status", Order.Status.NEW),
- *             Expr.gt("orderDate", lastWeek));
- *
- * List<Order> list = DB.find(Order.class)
- *   .where().add(newOrLastWeek)
- *   .findList();
- * ...
- * }</pre>
- *
- * @see Query#where()
- */
-public interface ExpressionFactory {
-
-  /**
-   * Path exists - for the given path in a JSON document.
-   */
-  Expression jsonExists(String propertyName, String path);
-
-  /**
-   * Path does not exist - for the given path in a JSON document.
-   */
-  Expression jsonNotExists(String propertyName, String path);
-
-  /**
-   * Equal to - for the given path in a JSON document.
-   */
-  Expression jsonEqualTo(String propertyName, String path, Object val);
-
-  /**
-   * Not Equal to - for the given path in a JSON document.
-   */
-  Expression jsonNotEqualTo(String propertyName, String path, Object val);
-
-  /**
-   * Greater than - for the given path in a JSON document.
-   */
-  Expression jsonGreaterThan(String propertyName, String path, Object val);
-
-  /**
-   * Greater than or equal to - for the given path in a JSON document.
-   */
-  Expression jsonGreaterOrEqual(String propertyName, String path, Object val);
-
-  /**
-   * Less than - for the given path in a JSON document.
-   */
-  Expression jsonLessThan(String propertyName, String path, Object val);
-
-  /**
-   * Less than or equal to - for the given path in a JSON document.
-   */
-  Expression jsonLessOrEqualTo(String propertyName, String path, Object val);
-
-  /**
-   * Between - for the given path in a JSON document.
-   */
-  Expression jsonBetween(String propertyName, String path, Object lowerValue, Object upperValue);
-
-  /**
-   * Array contains all the given values.
-   * <p>
-   * Array support is effectively limited to Postgres at this time.
-   * </p>
-   */
-  Expression arrayContains(String propertyName, Object... values);
-
-  /**
-   * Array does not contain the given values.
-   * <p>
-   * Array support is effectively limited to Postgres at this time.
-   * </p>
-   */
-  Expression arrayNotContains(String propertyName, Object... values);
-
-  /**
-   * Array is empty - for the given array property.
-   * <p>
-   * Array support is effectively limited to Postgres at this time.
-   * </p>
-   */
-  Expression arrayIsEmpty(String propertyName);
-
-  /**
-   * Array is not empty - for the given array property.
-   * <p>
-   * Array support is effectively limited to Postgres at this time.
-   * </p>
-   */
-  Expression arrayIsNotEmpty(String propertyName);
-
-  /**
-   * Equal To - property equal to the given value.
-   */
-  Expression eq(String propertyName, Object value);
-
-  /**
-   * Equal To or Null - property equal to the given value or null.
-   */
-  Expression eqOrNull(String propertyName, Object value);
-
-  /**
-   * Not Equal To - property not equal to the given value.
-   */
-  Expression ne(String propertyName, Object value);
-
-  /**
-   * Case Insensitive Equal To - property equal to the given value (typically
-   * using a lower() function to make it case insensitive).
-   */
-  Expression ieq(String propertyName, String value);
-
-  /**
-   * Case Insensitive Not Equal To - property not equal to the given value (typically
-   * using a lower() function to make it case insensitive).
-   */
-  Expression ine(String propertyName, String value);
-
-  /**
-   * Case Insensitive Equal To that allows for named parameter use.
-   */
-  Expression ieqObject(String propertyName, Object value);
-
-  /**
-   * Case Insensitive Not Equal To that allows for named parameter use.
-   */
-  Expression ineObject(String propertyName, Object value);
-
-  /**
-   * In Range - {@code property >= value1 and property < value2}.
-   * <p>
-   * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
-   * </p>
-   */
-  Expression inRange(String propertyName, Object value1, Object value2);
-
-  /**
-   * Value in Range between 2 properties.
-   *
-   * <pre>{@code
-   *
-   *    .startDate.inRangeWith(endDate, now)
-   *
-   *    // which equates to
-   *    startDate <= now and (endDate > now or endDate is null)
-   *
-   * }</pre>
-   *
-   * <p>
-   * This is a convenience expression combining a number of simple expressions.
-   * The most common use of this could be called "effective dating" where 2 date or
-   * timestamp columns represent the date range in which
-   */
-  Expression inRangeWith(String lowProperty, String highProperty, Object value);
-
-  /**
-   * Between - property between the two given values.
-   */
-  Expression between(String propertyName, Object value1, Object value2);
-
-  /**
-   * Between - value between two given properties.
-   */
-  Expression betweenProperties(String lowProperty, String highProperty, Object value);
-
-  /**
-   * Greater Than Or Null - property greater than the given value or null.
-   * <p>
-   * A convenient expression combining GT and Is Null.  Most often useful for range
-   * expressions where the top range value is nullable.
-   */
-  Expression gtOrNull(String propertyName, Object value);
-
-  /**
-   * Greater than or Equal to OR Null ({@code >= or null })
-   * <p>
-   * A convenient expression combining GE and Is Null.  Most often useful for range
-   * expressions where the top range value is nullable.
-   */
-  Expression geOrNull(String propertyName, Object value);
-
-  /**
-   * Greater Than - property greater than the given value.
-   */
-  Expression gt(String propertyName, Object value);
-
-  /**
-   * Greater Than or Equal to - property greater than or equal to the given
-   * value.
-   */
-  Expression ge(String propertyName, Object value);
-
-  /**
-   * Less Than or Null - property less than the given value or null.
-   * <p>
-   * A convenient expression combining LT and Is Null.  Most often useful for range
-   * expressions where the bottom range value is nullable.
-   */
-  Expression ltOrNull(String propertyName, Object value);
-
-  /**
-   * Less Than or Equal to OR Null ({@code <= or null })
-   * <p>
-   * A convenient expression combining LE and Is Null.  Most often useful for range
-   * expressions where the bottom range value is nullable.
-   */
-  Expression leOrNull(String propertyName, Object value);
-
-  /**
-   * Less Than - property less than the given value.
-   */
-  Expression lt(String propertyName, Object value);
-
-  /**
-   * Less Than or Equal to - property less than or equal to the given value.
-   */
-  Expression le(String propertyName, Object value);
-
-  /**
-   * Is Null - property is null.
-   */
-  Expression isNull(String propertyName);
-
-  /**
-   * Is Not Null - property is not null.
-   */
-  Expression isNotNull(String propertyName);
-
-  /**
-   * Case insensitive {@link #exampleLike(Object)}
-   */
-  ExampleExpression iexampleLike(Object example);
-
-  /**
-   * Create the query by Example expression which is case sensitive and using
-   * LikeType.RAW (you need to add you own wildcards % and _).
-   */
-  ExampleExpression exampleLike(Object example);
-
-  /**
-   * Create the query by Example expression specifying more options.
-   */
-  ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType);
-
-  /**
-   * Like with support for named parameters.
-   */
-  Expression like(String propertyName, Object value, boolean caseInsensitive, LikeType likeType);
-
-  /**
-   * Like - property like value where the value contains the SQL wild card
-   * characters % (percentage) and _ (underscore).
-   */
-  Expression like(String propertyName, String value);
-
-  /**
-   * Case insensitive Like - property like value where the value contains the
-   * SQL wild card characters % (percentage) and _ (underscore). Typically uses
-   * a lower() function to make the expression case insensitive.
-   */
-  Expression ilike(String propertyName, String value);
-
-  /**
-   * Starts With - property like value%.
-   */
-  Expression startsWith(String propertyName, String value);
-
-  /**
-   * Case insensitive Starts With - property like value%. Typically uses a
-   * lower() function to make the expression case insensitive.
-   */
-  Expression istartsWith(String propertyName, String value);
-
-  /**
-   * Ends With - property like %value.
-   */
-  Expression endsWith(String propertyName, String value);
-
-  /**
-   * Case insensitive Ends With - property like %value. Typically uses a lower()
-   * function to make the expression case insensitive.
-   */
-  Expression iendsWith(String propertyName, String value);
-
-  /**
-   * Contains - property like %value%.
-   */
-  Expression contains(String propertyName, String value);
-
-  /**
-   * Case insensitive Contains - property like %value%. Typically uses a lower()
-   * function to make the expression case insensitive.
-   */
-  Expression icontains(String propertyName, String value);
-
-  /**
-   * In expression using pairs of value objects.
-   */
-  Expression inPairs(Pairs pairs);
-
-  /**
-   * In - property has a value in the array of values.
-   */
-  Expression in(String propertyName, Object[] values);
-
-  /**
-   * In - using a subQuery.
-   */
-  Expression in(String propertyName, Query<?> subQuery);
-
-  /**
-   * In - property has a value in the collection of values.
-   */
-  Expression in(String propertyName, Collection<?> values);
-
-  /**
-   * In where null or empty values means that no predicate is added to the query.
-   * <p>
-   * That is, only add the IN predicate if the values are not null or empty.
-   * <p>
-   * Without this we typically need to code an <code>if</code> block to only add
-   * the IN predicate if the collection is not empty like:
-   * </p>
-   *
-   * <h3>Without inOrEmpty()</h3>
-   * <pre>{@code
-   *
-   *   query.where() // add some predicates
-   *     .eq("status", Status.NEW);
-   *
-   *   if (ids != null && !ids.isEmpty()) {
-   *     query.where().in("customer.id", ids);
-   *   }
-   *
-   *   query.findList();
-   *
-   * }</pre>
-   *
-   * <h3>Using inOrEmpty()</h3>
-   * <pre>{@code
-   *
-   *   query.where()
-   *     .eq("status", Status.NEW)
-   *     .inOrEmpty("customer.id", ids)
-   *     .findList();
-   *
-   * }</pre>
-   */
-  Expression inOrEmpty(String propertyName, Collection<?> values);
-
-  /**
-   * Not In - property has a value in the array of values.
-   */
-  Expression notIn(String propertyName, Object[] values);
-
-  /**
-   * Not In - property has a value in the collection of values.
-   */
-  Expression notIn(String propertyName, Collection<?> values);
-
-  /**
-   * Not In - using a subQuery.
-   */
-  Expression notIn(String propertyName, Query<?> subQuery);
-
-  /**
-   * Exists expression
-   */
-  Expression exists(Query<?> subQuery);
-
-  /**
-   * Not exists expression
-   */
-  Expression notExists(Query<?> subQuery);
-
-  /**
-   * Is empty expression for collection properties.
-   */
-  Expression isEmpty(String propertyName);
-
-  /**
-   * Is not empty expression for collection properties.
-   */
-  Expression isNotEmpty(String propertyName);
-
-  /**
-   * Id Equal to - ID property is equal to the value.
-   */
-  Expression idEq(Object value);
-
-  /**
-   * Id IN a list of Id values.
-   */
-  Expression idIn(Object... idValues);
-
-  /**
-   * Id IN a collection of Id values.
-   */
-  Expression idIn(Collection<?> idCollection);
-
-  /**
-   * All Equal - Map containing property names and their values.
-   * <p>
-   * Expression where all the property names in the map are equal to the
-   * corresponding value.
-   * </p>
-   *
-   * @param propertyMap a map keyed by property names.
-   */
-  Expression allEq(Map<String, Object> propertyMap);
-
-  /**
-   * Add expression for ANY of the given bit flags to be set.
-   *
-   * @param propertyName The property that holds the flags value
-   * @param flags        The flags we are looking for
-   */
-  Expression bitwiseAny(String propertyName, long flags);
-
-  /**
-   * Add expression for ALL of the given bit flags to be set.
-   *
-   * @param propertyName The property that holds the flags value
-   * @param flags        The flags we are looking for
-   */
-  Expression bitwiseAll(String propertyName, long flags);
-
-  /**
-   * Add bitwise AND expression of the given bit flags to compare with the match/mask.
-   *
-   * @param propertyName The property that holds the flags value
-   * @param flags        The flags we are looking for
-   */
-  Expression bitwiseAnd(String propertyName, long flags, long match);
-
-  /**
-   * Add raw expression with a single parameter.
-   * <p>
-   * The raw expression should contain a single ? at the location of the
-   * parameter.
-   * </p>
-   */
-  Expression raw(String raw, Object value);
-
-  /**
-   * Add raw expression with an array of parameters.
-   * <p>
-   * The raw expression should contain the same number of ? as there are
-   * parameters.
-   * </p>
-   */
-  Expression raw(String raw, Object[] values);
-
-  /**
-   * Add raw expression with no parameters.
-   */
-  Expression raw(String raw);
-
-  /**
-   * Create a Text Match expression (currently doc store/Elastic only).
-   */
-  Expression textMatch(String propertyName, String search, Match options);
-
-  /**
-   * Create a Text Multi match expression (currently doc store/Elastic only).
-   */
-  Expression textMultiMatch(String query, MultiMatch options);
-
-  /**
-   * Create a text simple query expression (currently doc store/Elastic only).
-   */
-  Expression textSimple(String search, TextSimple options);
-
-  /**
-   * Create a text query string expression (currently doc store/Elastic only).
-   */
-  Expression textQueryString(String search, TextQueryString options);
-
-  /**
-   * Create a text common terms expression (currently doc store/Elastic only).
-   */
-  Expression textCommonTerms(String search, TextCommonTerms options);
-
-  /**
-   * And - join two expressions with a logical and.
-   */
-  Expression and(Expression expOne, Expression expTwo);
-
-  /**
-   * Or - join two expressions with a logical or.
-   */
-  Expression or(Expression expOne, Expression expTwo);
-
-  /**
-   * Negate the expression (prefix it with NOT).
-   */
-  Expression not(Expression exp);
-
-  /**
-   * Return a list of expressions that will be joined by AND's.
-   */
-  <T> Junction<T> conjunction(Query<T> query);
-
-  /**
-   * Return a list of expressions that will be joined by OR's.
-   */
-  <T> Junction<T> disjunction(Query<T> query);
-
-  /**
-   * Return a list of expressions that will be joined by AND's.
-   */
-  <T> Junction<T> conjunction(Query<T> query, ExpressionList<T> parent);
-
-  /**
-   * Return a list of expressions that will be joined by OR's.
-   */
-  <T> Junction<T> disjunction(Query<T> query, ExpressionList<T> parent);
-
-  /**
-   * Return a Text query junction for MUST, SHOULD or MUST NOT.
-   * <p>
-   * This is doc store Elastic only.
-   * </p>
-   */
-  <T> Junction<T> junction(Junction.Type type, Query<T> query, ExpressionList<T> parent);
-
-  /**
-   * Add the expressions to the given expression list.
-   *
-   * @param where       The expression list to add the expressions to
-   * @param expressions The expressions that are parsed
-   * @param params      Bind parameters to match ? or ?1 bind positions.
-   */
-  <T> void where(ExpressionList<T> where, String expressions, Object[] params);
-}

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

@@ -1,493 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.Nullable;
-
-import javax.persistence.NonUniqueResultException;
-import java.time.Clock;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
-
-/**
- * The extended API for Database.
- * <p>
- * This provides the finder methods that take an explicit transaction rather than obtaining
- * the transaction from the usual mechanism (which is ThreadLocal based).
- * </p>
- * <p>
- * In general we only want to use this ExtendedServer API when we want to avoid / bypass
- * the use of the mechanism to get the current transaction and instead explicitly supply
- * the transaction to use.
- * </p>
- * <p>
- * Note that in all cases the transaction supplied can be null and in this case the Database
- * will use the normal mechanism to obtain the transaction to use.
- * </p>
- */
-public interface ExtendedServer {
-
-  /**
-   * Return the NOW time from the Clock.
-   */
-  long clockNow();
-
-  /**
-   * Set the Clock to use for <code>@WhenCreated</code> and <code>@WhenModified</code>.
-   * <p>
-   * Note that we only expect to change the Clock for testing purposes.
-   * </p>
-   */
-  void setClock(Clock clock);
-
-  /**
-   * Execute the query returning true if a row is found.
-   * <p>
-   * The query is executed using max rows of 1 and will only select the id property.
-   * This method is really just a convenient way to optimise a query to perform a
-   * 'does a row exist in the db' check.
-   * </p>
-   *
-   * <h2>Example:</h2>
-   * <pre>{@code
-   *
-   *   boolean userExists = query().where().eq("email", "rob@foo.com").exists();
-   *
-   * }</pre>
-   *
-   * <h2>Example using a query bean:</h2>
-   * <pre>{@code
-   *
-   *   boolean userExists = new QContact().email.equalTo("rob@foo.com").exists();
-   *
-   * }</pre>
-   *
-   * @return True if the query finds a matching row in the database
-   */
-  <T> boolean exists(Query<T> ormQuery, Transaction transaction);
-
-  /**
-   * Return the number of 'top level' or 'root' entities this query should return.
-   *
-   * @see Query#findCount()
-   * @see Query#findFutureCount()
-   */
-  <T> int findCount(Query<T> query, Transaction transaction);
-
-  /**
-   * Return the Id values of the query as a List.
-   *
-   * @see Query#findIds()
-   */
-  <A, T> List<A> findIds(Query<T> query, Transaction transaction);
-
-  /**
-   * Return a QueryIterator for the query.
-   * <p>
-   * Generally using {@link #findEach(Query, Consumer, Transaction)} or
-   * {@link #findEachWhile(Query, Predicate, Transaction)} is preferred
-   * to findIterate(). The reason is that those methods automatically take care of
-   * closing the queryIterator (and the underlying jdbc statement and resultSet).
-   * <p>
-   * This is similar to findEach in that not all the result beans need to be held
-   * in memory at the same time and as such is good for processing large queries.
-   *
-   * @see Query#findIterate()
-   * @see Query#findEach(Consumer)
-   * @see Query#findEachWhile(Predicate)
-   */
-  <T> QueryIterator<T> findIterate(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning the result as a Stream.
-   * <p>
-   * Note that this can support very large queries iterating any number of results.
-   * To do so internally it can use multiple persistence contexts.
-   * <p>
-   * Note that the stream needs to be closed so use with try with resources.
-   * </p>
-   */
-  <T> Stream<T> findStream(Query<T> query, Transaction transaction);
-
-  /**
-   * Deprecated - migrate to findStream().
-   * <p>
-   * Execute the query returning the result as a Stream.
-   * <p>
-   * Note that this can support very large queries iterating any number of results.
-   * To do so internally it can use multiple persistence contexts.
-   * <p>
-   * Note that the stream needs to be closed so use with try with resources.
-   */
-  @Deprecated
-  <T> Stream<T> findLargeStream(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query visiting the each bean one at a time.
-   * <p>
-   * Unlike findList() this is suitable for processing a query that will return
-   * a very large resultSet. The reason is that not all the result beans need to be
-   * held in memory at the same time and instead processed one at a time.
-   * </p>
-   * <p>
-   * Internally this query using a PersistenceContext scoped to each bean (and the
-   * beans associated object graph).
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   *     DB.find(Order.class)
-   *       .where().eq("status", Order.Status.NEW)
-   *       .order().asc("id")
-   *       .findEach((Order order) -> {
-   *
-   *         // do something with the order bean
-   *         System.out.println(" -- processing order ... " + order);
-   *       });
-   *
-   * }</pre>
-   *
-   * @see Query#findEach(Consumer)
-   * @see Query#findEachWhile(Predicate)
-   */
-  <T> void findEach(Query<T> query, Consumer<T> consumer, Transaction transaction);
-
-  /**
-   * Execute findEach with batch consumer.
-   *
-   * @see Query#findEach(int, Consumer)
-   */
-  <T> void findEach(Query<T> query, int batch, Consumer<List<T>> consumer, Transaction t);
-
-  /**
-   * Execute the query visiting the each bean one at a time.
-   * <p>
-   * Compared to findEach() this provides the ability to stop processing the query
-   * results early by returning false for the Predicate.
-   * </p>
-   * <p>
-   * Unlike findList() this is suitable for processing a query that will return
-   * a very large resultSet. The reason is that not all the result beans need to be
-   * held in memory at the same time and instead processed one at a time.
-   * </p>
-   * <p>
-   * Internally this query using a PersistenceContext scoped to each bean (and the
-   * beans associated object graph).
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   *     DB.find(Order.class)
-   *       .where().eq("status", Order.Status.NEW)
-   *       .order().asc("id")
-   *       .findEachWhile((Order order) -> {
-   *
-   *         // do something with the order bean
-   *         System.out.println(" -- processing order ... " + order);
-   *
-   *         boolean carryOnProcessing = ...
-   *         return carryOnProcessing;
-   *       });
-   *
-   * }</pre>
-   *
-   * @see Query#findEach(Consumer)
-   * @see Query#findEachWhile(Predicate)
-   */
-  <T> void findEachWhile(Query<T> query, Predicate<T> consumer, Transaction transaction);
-
-  /**
-   * Return versions of a @History entity bean.
-   * <p>
-   * Generally this query is expected to be a find by id or unique predicates query.
-   * It will execute the query against the history returning the versions of the bean.
-   * </p>
-   */
-  <T> List<Version<T>> findVersions(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute a query returning a list of beans.
-   * <p>
-   * Generally you are able to use {@link Query#findList()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   * List<Customer> customers = DB.find(Customer.class)
-   *     .where().ilike("name", "rob%")
-   *     .findList();
-   *
-   * }</pre>
-   *
-   * @param <T>         the type of entity bean to fetch.
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the list of fetched beans.
-   * @see Query#findList()
-   */
-  <T> List<T> findList(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute find row count query in a background thread.
-   * <p>
-   * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a
-   * timeout).
-   * </p>
-   *
-   * @param query       the query to execute the row count on
-   * @param transaction the transaction (can be null).
-   * @return a Future object for the row count query
-   * @see Query#findFutureCount()
-   */
-  <T> FutureRowCount<T> findFutureCount(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute find Id's query in a background thread.
-   * <p>
-   * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a
-   * timeout).
-   * </p>
-   *
-   * @param query       the query to execute the fetch Id's on
-   * @param transaction the transaction (can be null).
-   * @return a Future object for the list of Id's
-   * @see Query#findFutureIds()
-   */
-  <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute find list query in a background thread returning a FutureList object.
-   * <p>
-   * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a timeout).
-   * <p>
-   * This query will execute in it's own PersistenceContext and using its own transaction.
-   * What that means is that it will not share any bean instances with other queries.
-   *
-   * @param query       the query to execute in the background
-   * @param transaction the transaction (can be null).
-   * @return a Future object for the list result of the query
-   * @see Query#findFutureList()
-   */
-  <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction);
-
-  /**
-   * Return a PagedList for this query using firstRow and maxRows.
-   * <p>
-   * The benefit of using this over findList() is that it provides functionality to get the
-   * total row count etc.
-   * </p>
-   * <p>
-   * If maxRows is not set on the query prior to calling findPagedList() then a
-   * PersistenceException is thrown.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   *  PagedList<Order> pagedList = DB.find(Order.class)
-   *       .setFirstRow(50)
-   *       .setMaxRows(20)
-   *       .findPagedList();
-   *
-   *       // fetch the total row count in the background
-   *       pagedList.loadRowCount();
-   *
-   *       List<Order> orders = pagedList.getList();
-   *       int totalRowCount = pagedList.getTotalRowCount();
-   *
-   * }</pre>
-   *
-   * @return The PagedList
-   * @see Query#findPagedList()
-   */
-  <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning a set of entity beans.
-   * <p>
-   * Generally you are able to use {@link Query#findSet()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   * Set<Customer> customers = DB.find(Customer.class)
-   *     .where().ilike("name", "rob%")
-   *     .findSet();
-   *
-   * }</pre>
-   *
-   * @param <T>         the type of entity bean to fetch.
-   * @param query       the query to execute
-   * @param transaction the transaction to use (can be null).
-   * @return the set of fetched beans.
-   * @see Query#findSet()
-   */
-  <T> Set<T> findSet(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning the entity beans in a Map.
-   * <p>
-   * Generally you are able to use {@link Query#findMap()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   *
-   * @param <T>         the type of entity bean to fetch.
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the map of fetched beans.
-   * @see Query#findMap()
-   */
-  <K, T> Map<K, T> findMap(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning a list of values for a single property.
-   * <p>
-   * <h3>Example 1:</h3>
-   * <pre>{@code
-   *
-   *  List<String> names =
-   *    DB.find(Customer.class)
-   *      .select("name")
-   *      .order().asc("name")
-   *      .findSingleAttributeList();
-   *
-   * }</pre>
-   * <h3>Example 2:</h3>
-   * <pre>{@code
-   *
-   *  List<String> names =
-   *    DB.find(Customer.class)
-   *      .setDistinct(true)
-   *      .select("name")
-   *      .where().eq("status", Customer.Status.NEW)
-   *      .order().asc("name")
-   *      .setMaxRows(100)
-   *      .findSingleAttributeList();
-   *
-   * }</pre>
-   *
-   * @return the list of values for the selected property
-   * @see Query#findSingleAttributeList()
-   */
-  <A, T> List<A> findSingleAttributeList(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning at most one entity bean or null (if no matching
-   * bean is found).
-   * <p>
-   * This will throw a NonUniqueResultException if the query finds more than one result.
-   * </p>
-   * <p>
-   * Generally you are able to use {@link Query#findOne()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   *
-   * @param <T>         the type of entity bean to fetch.
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the list of fetched beans.
-   * @throws NonUniqueResultException if more than one result was found
-   * @see Query#findOne()
-   */
-  @Nullable
-  <T> T findOne(Query<T> query, Transaction transaction);
-
-  /**
-   * Similar to findOne() but returns an Optional (rather than nullable).
-   */
-  <T> Optional<T> findOneOrEmpty(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute as a delete query deleting the 'root level' beans that match the predicates
-   * in the query.
-   * <p>
-   * Note that if the query includes joins then the generated delete statement may not be
-   * optimal depending on the database platform.
-   * </p>
-   *
-   * @param query       the query used for the delete
-   * @param transaction the transaction to use (can be null)
-   * @param <T>         the type of entity bean to fetch.
-   * @return the number of beans/rows that were deleted
-   */
-  <T> int delete(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the update query returning the number of rows updated.
-   * <p>
-   * The update query must be created using {@link Database#update(Class)}.
-   * </p>
-   *
-   * @param query       the update query to execute
-   * @param transaction the optional transaction to use for the update (can be null)
-   * @param <T>         the type of entity bean
-   * @return The number of rows updated
-   */
-  <T> int update(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the sql query returning a list of MapBean.
-   * <p>
-   * Generally you are able to use {@link SqlQuery#findList()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   *
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the list of fetched MapBean.
-   * @see SqlQuery#findList()
-   */
-  List<SqlRow> findList(SqlQuery query, Transaction transaction);
-
-  /**
-   * Execute the SqlQuery iterating a row at a time.
-   * <p>
-   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
-   * </p>
-   */
-  void findEach(SqlQuery query, Consumer<SqlRow> consumer, Transaction transaction);
-
-  /**
-   * Execute the SqlQuery iterating a row at a time with the ability to stop consuming part way through.
-   * <p>
-   * Returning false after processing a row stops the iteration through the query results.
-   * </p>
-   * <p>
-   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
-   * </p>
-   */
-  void findEachWhile(SqlQuery query, Predicate<SqlRow> consumer, Transaction transaction);
-
-  /**
-   * Execute the sql query returning a single MapBean or null.
-   * <p>
-   * This will throw a PersistenceException if the query found more than one
-   * result.
-   * </p>
-   * <p>
-   * Generally you are able to use {@link SqlQuery#findOne()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   *
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the fetched MapBean or null if none was found.
-   * @see SqlQuery#findOne()
-   */
-  @Nullable
-  SqlRow findOne(SqlQuery query, Transaction transaction);
-
-}

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

@@ -1,243 +0,0 @@
-package io.ebean;
-
-import java.io.Serializable;
-
-/**
- * Defines how a relationship is fetched via either normal SQL join,
- * a eager secondary query, via lazy loading or via eagerly hitting L2 cache.
- * <p>
- * <pre>{@code
- * // Normal fetch join results in a single SQL query
- * List<Order> list = DB.find(Order.class).fetch("details").findList();
- *
- * }</pre>
- * <p>
- * Example: Using a "query join" instead of a "fetch join" we instead use 2 SQL queries
- * </p>
- * <p>
- * <pre>{@code
- *
- * // This will use 2 SQL queries to build this object graph
- * List<Order> list =
- *     DB.find(Order.class)
- *         .fetch("details", FetchConfig.ofQuery())
- *         .findList();
- *
- * // query 1) find order
- * // query 2) find orderDetails where order.id in (?,?...) // first 100 order id's
- *
- * }</pre>
- *
- * @author mario
- * @author rbygrave
- */
-public class FetchConfig implements Serializable {
-
-  private static final long serialVersionUID = 1L;
-
-  private static final int JOIN_MODE = 0;
-  private static final int QUERY_MODE = 1;
-  private static final int LAZY_MODE = 2;
-  private static final int CACHE_MODE = 3;
-
-  private int mode;
-  private int batchSize;
-  private int hashCode;
-
-  /**
-   * Deprecated - migrate to one of the static factory methods like {@link FetchConfig#ofQuery()}
-   * <p>
-   * Construct using default JOIN mode.
-   */
-  @Deprecated
-  public FetchConfig() {
-    //this.mode = JOIN_MODE;
-    this.batchSize = 100;
-    this.hashCode = 1000;
-  }
-
-  private FetchConfig(int mode, int batchSize) {
-    this.mode = mode;
-    this.batchSize = batchSize;
-    this.hashCode = mode + 10 * batchSize;
-  }
-
-  /**
-   * Return FetchConfig to eagerly fetch the relationship using L2 cache.
-   * <p>
-   * Any cache misses will be loaded by secondary query to the database.
-   */
-  public static FetchConfig ofCache() {
-    return new FetchConfig(CACHE_MODE, 100);
-  }
-
-  /**
-   * Return FetchConfig to eagerly fetch the relationship using a secondary query.
-   */
-  public static FetchConfig ofQuery() {
-    return new FetchConfig(QUERY_MODE, 100);
-  }
-
-  /**
-   * Return FetchConfig to eagerly fetch the relationship using a secondary with a given batch size.
-   */
-  public static FetchConfig ofQuery(int batchSize) {
-    return new FetchConfig(QUERY_MODE, batchSize);
-  }
-
-  /**
-   * Return FetchConfig to lazily load the relationship.
-   */
-  public static FetchConfig ofLazy() {
-    return new FetchConfig(LAZY_MODE, 0);
-  }
-
-  /**
-   * Return FetchConfig to lazily load the relationship specifying the batch size.
-   */
-  public static FetchConfig ofLazy(int batchSize) {
-    return new FetchConfig(LAZY_MODE, batchSize);
-  }
-
-  /**
-   * Return FetchConfig to fetch the relationship using SQL join.
-   */
-  public static FetchConfig ofDefault() {
-    return new FetchConfig(JOIN_MODE, 100);
-  }
-
-  /**
-   * We want to migrate away from mutating FetchConfig to a fully immutable FetchConfig.
-   */
-  private FetchConfig mutate(int mode, int batchSize) {
-    if (batchSize < 0) {
-      throw new IllegalArgumentException("batch size " + batchSize + " must be > 0");
-    }
-    this.mode = mode;
-    this.batchSize = batchSize;
-    this.hashCode = mode + 10 * batchSize;
-    return this;
-  }
-
-  /**
-   * Deprecated - migrate to FetchConfig.ofLazy().
-   */
-  @Deprecated
-  public FetchConfig lazy() {
-    return mutate(LAZY_MODE, 0);
-  }
-
-  /**
-   * Deprecated - migrate to FetchConfig.ofLazy(batchSize).
-   */
-  @Deprecated
-  public FetchConfig lazy(int batchSize) {
-    return mutate(LAZY_MODE, batchSize);
-  }
-
-  /**
-   * Deprecated - migrate to FetchConfig.ofQuery().
-   * <p>
-   * Eagerly fetch the beans in this path as a separate query (rather than as
-   * part of the main query).
-   * <p>
-   * This will use the default batch size for separate query which is 100.
-   */
-  @Deprecated
-  public FetchConfig query() {
-    return mutate(QUERY_MODE, 100);
-  }
-
-  /**
-   * Deprecated - migrate to FetchConfig.ofQuery(batchSize).
-   * <p>
-   * Eagerly fetch the beans in this path as a separate query (rather than as
-   * part of the main query).
-   * <p>
-   * The queryBatchSize is the number of parent id's that this separate query
-   * will load per batch.
-   * <p>
-   * This will load all beans on this path eagerly unless a {@link #lazy(int)}
-   * is also used.
-   *
-   * @param batchSize the batch size used to load beans on this path
-   */
-  @Deprecated
-  public FetchConfig query(int batchSize) {
-    return mutate(QUERY_MODE, batchSize);
-  }
-
-  /**
-   * Deprecated - migrate to FetchConfig.ofQuery(batchSize).
-   * <p>
-   * Eagerly fetch the first batch of beans on this path.
-   * This is similar to {@link #query(int)} but only fetches the first batch.
-   * <p>
-   * If there are more parent beans than the batch size then they will not be
-   * loaded eagerly but instead use lazy loading.
-   *
-   * @param batchSize the number of parent beans this path is populated for
-   */
-  @Deprecated
-  public FetchConfig queryFirst(int batchSize) {
-    return query(batchSize);
-  }
-
-  /**
-   * Deprecated - migrate to FetchConfig.ofCache().
-   * <p>
-   * Eagerly fetch the beans fetching the beans from the L2 bean cache
-   * and using the DB for beans not in the cache.
-   */
-  @Deprecated
-  public FetchConfig cache() {
-    return mutate(CACHE_MODE, 100);
-  }
-
-  /**
-   * Return the batch size for fetching.
-   */
-  public int getBatchSize() {
-    return batchSize;
-  }
-
-  /**
-   * Return true if the fetch should use the L2 cache.
-   */
-  public boolean isCache() {
-    return mode == CACHE_MODE;
-  }
-
-  /**
-   * Return true if the fetch should be a eager secondary query.
-   */
-  public boolean isQuery() {
-    return mode == QUERY_MODE;
-  }
-
-  /**
-   * Return true if the fetch should be a lazy query.
-   */
-  public boolean isLazy() {
-    return mode == LAZY_MODE;
-  }
-
-  /**
-   * Return true if the fetch should try to use SQL join.
-   */
-  public boolean isJoin() {
-    return mode == JOIN_MODE;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    return (hashCode == ((FetchConfig) o).hashCode);
-  }
-
-  @Override
-  public int hashCode() {
-    return hashCode;
-  }
-}

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

@@ -1,121 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.NonNullApi;
-import io.ebean.service.SpiFetchGroupQuery;
-
-/**
- * Defines what part of the object graph to load (select and fetch clauses).
- * <p>
- * Using a FetchGroup effectively sets the select() and fetch() clauses for a query. It is alternative
- * to specifying the select() and fetch() clauses on the query allowing for more re-use of "what to load"
- * that can be defined separately from the query and combined with other FetchGroups.
- * </p>
- *
- * <h3>Select example</h3>
- * <pre>{@code
- *
- * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class, "name, status");
- *
- * Customer.query()
- *   .select(fetchGroup)
- *   .findList();
- *
- * }</pre>
- *
- * <h3>Select and fetch example</h3>
- * <pre>{@code
- *
- * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class)
- *   .select("name, status")
- *   .fetch("contacts", "firstName, lastName, email")
- *   .build();
- *
- * Customer.query()
- *   .select(fetchGroup)
- *   .findList();
- *
- * }</pre>
- *
- * <h3>Combining FetchGroups</h3>
- * <p>
- *   FetchGroups can be combined together to form another FetchGroup.
- * </p>
- * <pre>{@code
- *
- *  FetchGroup<Address> FG_ADDRESS = FetchGroup.of(Address.class)
- *    .select("line1, line2, city")
- *    .fetch("country", "name")
- *    .build();
- *
- *  FetchGroup<Customer> FG_CUSTOMER = FetchGroup.of(Customer.class)
- *    .select("name, version")
- *    .fetch("billingAddress", FG_ADDRESS)
- *    .build();
- *
- *
- *  Customer.query()
- *    .select(FG_CUSTOMER)
- *    .findList();
- *
- * }</pre>
- *
- * @param <T> The bean type the Fetch group can be applied to
- */
-@NonNullApi
-public interface FetchGroup<T> {
-
-  /**
-   * Return the FetchGroup with the given select clause.
-   * <p>
-   *   We use this for simple FetchGroup that only select() properties and do not have additional fetch() clause.
-   * </p>
-   * <pre>{@code
-   *
-   * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class, "name, status");
-   *
-   * Customer.query()
-   *   .select(fetchGroup)
-   *   .findList();
-   *
-   * }</pre>
-   *
-   * @param select The select clause of the FetchGroup
-   *
-   * @return The FetchGroup with the given select clause
-   */
-  static <T> FetchGroup<T> of(Class<T> cls, String select) {
-    return XServiceProvider.fetchGroupOf(cls, select);
-  }
-
-  /**
-   * Return the FetchGroupBuilder with the given select clause that we can add fetch clauses to.
-   * <p>
-   * We chain select() with one or more fetch() clauses to define the object graph to load.
-   * </p>
-   * <pre>{@code
-   *
-   * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class)
-   *   .select("name, status")
-   *   .fetch("contacts", "firstName, lastName, email")
-   *   .build();
-   *
-   * Customer.query()
-   *   .select(fetchGroup)
-   *   .findList();
-   *
-   * }</pre>
-   *
-   * @return The FetchGroupBuilder with the given select clause which we will add fetch clauses to
-   */
-  static <T> FetchGroupBuilder<T> of(Class<T> cls) {
-    return XServiceProvider.fetchGroupOf(cls);
-  }
-
-  /**
-   * Return a query to be used by query beans for constructing FetchGroup.
-   */
-  static <T> SpiFetchGroupQuery<T> queryFor(Class<T> beanType) {
-    return XServiceProvider.fetchGroupQueryFor(beanType);
-  }
-
-}

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

@@ -1,95 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.NonNullApi;
-
-/**
- * Builds a FetchGroup by adding fetch clauses.
- * <p>
- * We add select() and fetch() clauses to define the object graph we want to load.
- * </p>
- *
- * <pre>{@code
- *
- * FetchGroup fetchGroup = FetchGroup
- *   .select("name, status")
- *   .fetch("contacts", "firstName, lastName, email")
- *   .build();
- *
- * Customer.query()
- *   .select(fetchGroup)
- *   .where()
- *   ...
- *   .findList();
- *
- * }</pre>
- */
-@NonNullApi
-public interface FetchGroupBuilder<T> {
-
-  /**
-   * Specify specific properties to select (top level properties).
-   */
-  FetchGroupBuilder<T> select(String select);
-
-  /**
-   * Fetch all the properties at the given path.
-   */
-  FetchGroupBuilder<T> fetch(String path);
-
-  /**
-   * Fetch the path with the nested fetch group.
-   */
-  FetchGroupBuilder<T> fetch(String path, FetchGroup<?> nestedGroup);
-
-  /**
-   * Fetch the path using a query join with the nested fetch group.
-   */
-  FetchGroupBuilder<T> fetchQuery(String path, FetchGroup<?> nestedGroup);
-
-  /**
-   * Fetch the path lazily with the nested fetch group.
-   */
-  FetchGroupBuilder<T> fetchLazy(String path, FetchGroup<?> nestedGroup);
-
-  /**
-   * Fetch the path including specified properties.
-   */
-  FetchGroupBuilder<T> fetch(String path, String properties);
-
-  /**
-   * Fetch the path including all its properties using a query join.
-   */
-  FetchGroupBuilder<T> fetchQuery(String path);
-
-  /**
-   * Fetch the path including all its properties using L2 cache.
-   * Cache misses fallback to fetchQuery().
-   */
-  FetchGroupBuilder<T> fetchCache(String path);
-
-  /**
-   * Fetch the path including specified properties using a query join.
-   */
-  FetchGroupBuilder<T> fetchQuery(String path, String properties);
-
-  /**
-   * Fetch the path including specified properties using L2 cache.
-   * Cache misses fallback to fetchQuery().
-   */
-  FetchGroupBuilder<T> fetchCache(String path, String properties);
-
-  /**
-   * Fetch the path including all its properties lazily.
-   */
-  FetchGroupBuilder<T> fetchLazy(String path);
-
-  /**
-   * Fetch the path including specified properties lazily.
-   */
-  FetchGroupBuilder<T> fetchLazy(String path, String properties);
-
-  /**
-   * Build and return the FetchGroup.
-   */
-  FetchGroup<T> build();
-}

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

@@ -1,26 +0,0 @@
-package io.ebean;
-
-import java.util.Set;
-
-/**
- * Provides paths and properties for an object graph that can be used to control what parts of the object graph
- * is fetching (select and fetch clauses) and also can be used to control JSON marshalling (what parts of the object
- * graph are included in the JSON).
- */
-public interface FetchPath {
-
-  /**
-   * Return true if the path is included in this FetchPath.
-   */
-  boolean hasPath(String path);
-
-  /**
-   * Return the properties at the given path.
-   */
-  Set<String> getProperties(String path);
-
-  /**
-   * Apply the fetch path to the query.
-   */
-  <T> void apply(Query<T> query);
-}

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

@@ -1,199 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.NonNullApi;
-
-import java.util.List;
-import java.util.Set;
-
-/**
- * Provides support for filtering and sorting lists of entities without going
- * back to the database.
- * <p>
- * That is, it uses local in-memory sorting and filtering of a list of entity
- * beans. It is not used in a Database query or invoke a Database query.
- * </p>
- * <p>
- * You can optionally specify a sortByClause and if so, the sort will always
- * execute prior to the filter expressions. You can specify any number of filter
- * expressions and they are effectively joined by logical "AND".
- * </p>
- * <p>
- * The result of the filter method will leave the original list unmodified and
- * return a new List instance.
- * </p>
- * <p>
- * <pre>{@code
- *
- * // get a list of entities (query execution statistics in this case)
- *
- * List<MetaQueryStatistic> list =
- *     DB.find(MetaQueryStatistic.class).findList();
- *
- * long nowMinus24Hrs = System.currentTimeMillis() - 24 * (1000 * 60 * 60);
- *
- * // sort and filter the list returning a filtered list...
- *
- * List<MetaQueryStatistic> filteredList =
- *     DB.filter(MetaQueryStatistic.class)
- *         .sort("avgTimeMicros desc")
- *         .gt("executionCount", 0)
- *         .gt("lastQueryTime", nowMinus24Hrs)
- *         .eq("autoTuned", true)
- *         .maxRows(10)
- *         .filter(list);
- *
- * }</pre>
- * <p>
- * The propertyNames can traverse the object graph (e.g. customer.name) by using
- * dot notation. If any point during the object graph traversal to get a
- * property value is null then null is returned.
- * </p>
- * <p>
- * <pre>{@code
- *
- * // examples of property names that
- * // ... will traverse the object graph
- * // ... where customer is a property of our bean
- *
- * customer.name
- * customer.shippingAddress.city
- *
- * }</pre>
- * <p>
- * <pre>{@code
- *
- * // get a list of entities (query execution statistics)
- *
- * List<Order> orders =
- *     DB.find(Order.class).findList();
- *
- * // Apply a filter...
- *
- * List<Order> filteredOrders =
- *     DB.filter(Order.class)
- *         .startsWith("customer.name", "Rob")
- *         .eq("customer.shippingAddress.city", "Auckland")
- *         .filter(orders);
- *
- * }</pre>
- *
- * @param <T> the entity bean type
- */
-@NonNullApi
-public interface Filter<T> {
-
-  /**
-   * Specify a sortByClause.
-   * <p>
-   * The sort (if specified) will always execute first followed by the filter
-   * expressions.
-   * </p>
-   * <p>
-   * Refer to {@link DB#sort(List, String)} for more detail.
-   * </p>
-   */
-  Filter<T> sort(String sortByClause);
-
-  /**
-   * Specify the maximum number of rows/elements to return.
-   */
-  Filter<T> maxRows(int maxRows);
-
-  /**
-   * Equal To - property equal to the given value.
-   */
-  Filter<T> eq(String prop, Object value);
-
-  /**
-   * Not Equal To - property not equal to the given value.
-   */
-  Filter<T> ne(String propertyName, Object value);
-
-  /**
-   * Case Insensitive Equal To.
-   */
-  Filter<T> ieq(String propertyName, String value);
-
-  /**
-   * Between - property between the two given values.
-   */
-  Filter<T> between(String propertyName, Object value1, Object value2);
-
-  /**
-   * Greater Than - property greater than the given value.
-   */
-  Filter<T> gt(String propertyName, Object value);
-
-  /**
-   * Greater Than or Equal to - property greater than or equal to the given
-   * value.
-   */
-  Filter<T> ge(String propertyName, Object value);
-
-  /**
-   * Less Than - property less than the given value.
-   */
-  Filter<T> lt(String propertyName, Object value);
-
-  /**
-   * Less Than or Equal to - property less than or equal to the given value.
-   */
-  Filter<T> le(String propertyName, Object value);
-
-  /**
-   * Is Null - property is null.
-   */
-  Filter<T> isNull(String propertyName);
-
-  /**
-   * Is Not Null - property is not null.
-   */
-  Filter<T> isNotNull(String propertyName);
-
-  /**
-   * Starts With.
-   */
-  Filter<T> startsWith(String propertyName, String value);
-
-  /**
-   * Case insensitive Starts With.
-   */
-  Filter<T> istartsWith(String propertyName, String value);
-
-  /**
-   * Ends With.
-   */
-  Filter<T> endsWith(String propertyName, String value);
-
-  /**
-   * Case insensitive Ends With.
-   */
-  Filter<T> iendsWith(String propertyName, String value);
-
-  /**
-   * Contains - property contains the string "value".
-   */
-  Filter<T> contains(String propertyName, String value);
-
-  /**
-   * Case insensitive Contains.
-   */
-  Filter<T> icontains(String propertyName, String value);
-
-  /**
-   * In - property has a value contained in the set of values.
-   */
-  Filter<T> in(String propertyName, Set<?> values);
-
-  /**
-   * Apply the filter to the list returning a new list of the matching elements
-   * in the sorted order.
-   * <p>
-   * The sourceList will remain unmodified.
-   * </p>
-   *
-   * @return Returns a new list with the sorting and filters applied.
-   */
-  List<T> filter(List<T> sourceList);
-
-}

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

@@ -1,218 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.NonNullApi;
-import io.avaje.lang.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>
- * <pre>{@code
- *
- * public class CustomerFinder extends Finder<Long,Customer> {
- *
- *   public CustomerFinder() {
- *     super(Customer.class);
- *   }
- *
- *   // Add finder methods ...
- *
- *   public Customer byName(String name) {
- *     return query().eq("name", name).findOne();
- *   }
- *
- *   public List<Customer> findNew() {
- *     return query().where()
- *       .eq("status", Customer.Status.NEW)
- *       .order("name")
- *       .findList()
- *   }
- * }
- *
- * @Entity
- * public class Customer extends BaseModel {
- *
- *   public static final CustomerFinder find = new CustomerFinder();
- *   ...
- *
- * }
- * }</pre>
- * <p>
- *  When the Finder is registered as a field on Customer it can then be used like:
- * </p>
- * <pre>{@code
- *
- *   Customer rob = Customer.find.byName("Rob");
- *
- * }</pre>
- *
- */
-@NonNullApi
-public class Finder<I, T> {
-
-  /**
-   * The entity bean type.
-   */
-  private final Class<T> type;
-
-  /**
-   * The name of the database this finder will use, null for the default database.
-   */
-  private final String _$dbName;
-
-  /**
-   * 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._$dbName = null;
-  }
-
-  /**
-   * Create with the type of the entity bean and specific database name.
-   */
-  public Finder(Class<T> type, String databaseName) {
-    this.type = type;
-    this._$dbName = databaseName;
-  }
-
-  /**
-   * Return the current transaction.
-   */
-  public Transaction currentTransaction() {
-    return db().currentTransaction();
-  }
-
-  /**
-   * Flush the JDBC batch on the current transaction.
-   */
-  public void flush() {
-    db().flush();
-  }
-
-  /**
-   * Return the Database this finder will use.
-   */
-  public Database db() {
-    return DB.byName(_$dbName);
-  }
-
-  /**
-   * Return typically a different Database to the default.
-   * <p>
-   * This is equivalent to {@link DB#byName(String)}
-   *
-   * @param databaseName The name of the Database. If this is null then the default database is returned.
-   */
-  public Database db(String databaseName) {
-    return DB.byName(databaseName);
-  }
-
-  /**
-   * Creates an entity reference for this ID.
-   * <p>
-   * Equivalent to {@link Database#reference(Class, Object)}
-   */
-  public T ref(I id) {
-    return db().reference(type, id);
-  }
-
-  /**
-   * Retrieves an entity by ID.
-   * <p>
-   * Equivalent to {@link Database#find(Class, Object)}
-   */
-  @Nullable
-  public T byId(I id) {
-    return db().find(type, id);
-  }
-
-  /**
-   * Delete a bean by Id.
-   * <p>
-   * Equivalent to {@link Database#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 an update query.
-   *
-   * <pre>{@code
-   *
-   *  int rows =
-   *      finder.update()
-   *      .set("status", Customer.Status.ACTIVE)
-   *      .set("updtime", new Timestamp(System.currentTimeMillis()))
-   *      .where()
-   *        .gt("id", 1000)
-   *        .update();
-   *
-   * }</pre>
-   *
-   * <p>
-   * Equivalent to {@link Database#update(Class)}
-   */
-  public UpdateQuery<T> update() {
-    return db().update(type);
-  }
-
-  /**
-   * Creates a query.
-   * <p>
-   * Equivalent to {@link Database#find(Class)}
-   */
-  public Query<T> query() {
-    return db().find(type);
-  }
-
-  /**
-   * Creates a native sql query.
-   */
-  public Query<T> nativeSql(String nativeSql) {
-    return db().findNative(type, nativeSql);
-  }
-
-  /**
-   * Creates a query using the ORM query language.
-   */
-  public Query<T> query(String ormQuery) {
-    return db().createQuery(type, ormQuery);
-  }
-
-}

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

@@ -1,20 +0,0 @@
-package io.ebean;
-
-import java.util.List;
-import java.util.concurrent.Future;
-
-/**
- * FutureIds represents the result of a background query execution for the Id's.
- * <p>
- * It extends the java.util.concurrent.Future with the ability to get the Id's
- * while the query is still executing in the background.
- * </p>
- */
-public interface FutureIds<T> extends Future<List<Object>> {
-
-  /**
-   * Returns the original query used to fetch the Id's.
-   */
-  Query<T> getQuery();
-
-}

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

@@ -1,72 +0,0 @@
-package io.ebean;
-
-import javax.persistence.PersistenceException;
-import java.util.List;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-/**
- * FutureList represents the result of a background query execution that will
- * return a list of entities.
- * <p>
- * It extends the java.util.concurrent.Future with the ability to cancel the
- * query, check if it is finished and get the resulting list waiting for the
- * query to finish (ie. the standard features of java.util.concurrent.Future).
- * </p>
- * <p>
- * A simple example:
- * </p>
- * <pre>{@code
- *
- *  // create a query to find all orders
- * Query<Order> query = DB.find(Order.class);
- *
- *  // execute the query in a background thread
- *  // immediately returning the futureList
- * FutureList<Order> futureList = query.findFutureList();
- *
- *  // do something else ...
- *
- * if (!futureList.isDone()){
- * 	// we can cancel the query execution. This will cancel
- * // the underlying query if that is supported by the JDBC
- * // driver and database
- * 	futureList.cancel(true);
- * }
- *
- * if (!futureList.isCancelled()){
- * 	// wait for the query to finish and return the list
- * 	List<Order> list = futureList.get();
- * 	...
- * }
- *
- * }</pre>
- */
-public interface FutureList<T> extends Future<List<T>> {
-
-  /**
-   * Return the query that is being executed by a background thread.
-   */
-  Query<T> getQuery();
-
-  /**
-   * Same as {@link #get()} but wraps InterruptedException and ExecutionException in the
-   * unchecked PersistenceException.
-   *
-   * @return The query list result
-   * @throws PersistenceException when a InterruptedException or ExecutionException occurs.
-   */
-  List<T> getUnchecked();
-
-  /**
-   * Same as {@link #get(long, java.util.concurrent.TimeUnit)} but wraps InterruptedException
-   * and ExecutionException in the unchecked PersistenceException.
-   *
-   * @return The query list result
-   * @throws TimeoutException     if the wait timed out
-   * @throws PersistenceException if a InterruptedException or ExecutionException occurs.
-   */
-  List<T> getUnchecked(long timeout, TimeUnit unit) throws TimeoutException;
-
-}

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

@@ -1,149 +0,0 @@
-package io.ebean;
-
-/**
- * Represents a Conjunction or a Disjunction.
- * <p>
- * Basically with a Conjunction you join together many expressions with AND, and
- * with a Disjunction you join together many expressions with OR.
- * </p>
- * <p>
- * Note: where() always takes you to the top level WHERE expression list.
- * </p>
- * <pre>{@code
- * Query q =
- *     DB.find(Person.class)
- *       .where()
- *         .or()
- *           .like("name", "Rob%")
- *           .eq("status", Status.NEW)
- *
- *       // where() returns us to the top level expression list
- *       .where().gt("id", 10);
- *
- * // read as...
- * // where ( ((name like Rob%) or (status = NEW)) AND (id &gt; 10) )
- *
- * }</pre>
- * <p>
- * Note: endJunction() takes you to the parent expression list
- * </p>
- * <pre>{@code
- *
- * Query q =
- *     DB.find(Person.class)
- *       .where()
- *         .or()
- *           .like("name", "Rob%")
- *           .eq("status", Status.NEW)
- *           .endJunction()
- *
- *           // endJunction().. takes us to the 'parent' expression list
- *           // which in this case is the top level (same as where())
- *
- *         .gt("id", 10);
- *
- * // read as...
- * // where ( ((name like Rob%) or (status = NEW)) AND (id > 10) )
- * }</pre>
- * <p>
- * Example of a nested disjunction.
- * </p>
- * <pre>{@code
- * Query<Customer> q =
- *  DB.find(Customer.class)
- *      .where()
- *        .or()
- *          .and()
- *            .startsWith("name", "r")
- *            .eq("anniversary", onAfter)
- *            .endAnd()
- *          .and()
- *            .eq("status", Customer.Status.ACTIVE)
- *            .gt("id", 0)
- *            .endAnd()
- *      .order().asc("name");
- *
- * q.findList();
- * String s = q.getGeneratedSql();
- *
- *  // this produces an expression like:
- *  ( name like ? and c.anniversary = ? ) or (c.status = ?  and c.id > ? )
- *
- * }</pre>
- */
-public interface Junction<T> extends Expression, ExpressionList<T> {
-
-  /**
-   * The type of Junction used in full text expressions.
-   */
-  enum Type {
-
-    /**
-     * AND group.
-     */
-    AND(" and ", "", false),
-
-    /**
-     * OR group.
-     */
-    OR(" or ", "", false),
-
-    /**
-     * NOT group.
-     */
-    NOT(" and ", "not ", false),
-
-    /**
-     * FILTER group (for internal use only).
-     */
-    FILTER("filter", "", true),
-
-    /**
-     * Text search AND group.
-     */
-    MUST("must", "", true),
-
-    /**
-     * Text search NOT group.
-     */
-    MUST_NOT("must_not", "", true),
-
-    /**
-     * Text search OR group.
-     */
-    SHOULD("should", "", true);
-
-    private final String prefix;
-    private final String literal;
-    private final boolean text;
-
-    Type(String literal, String prefix, boolean text) {
-      this.literal = literal;
-      this.prefix = prefix;
-      this.text = text;
-    }
-
-    /**
-     * Return the literal value for this type.
-     */
-    public String literal() {
-      return literal;
-    }
-
-    /**
-     * Return the prefix value for this type.
-     */
-    public String prefix() {
-      return prefix;
-    }
-
-    /**
-     * Return true if this is a text type.
-     */
-    public boolean isText() {
-      return text;
-    }
-
-  }
-
-}

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

@@ -1,35 +0,0 @@
-package io.ebean;
-
-/**
- * Used to specify the type of like matching used.
- */
-public enum LikeType {
-
-  /**
-   * You need to put in your own wildcards - no escaping is performed.
-   */
-  RAW,
-
-  /**
-   * The % wildcard is added to the end of the search word and search word is escaped.
-   */
-  STARTS_WITH,
-
-  /**
-   * The % wildcard is added to the beginning of the search word and search word is escaped.
-   */
-  ENDS_WITH,
-
-  /**
-   * The % wildcard is added to the beginning and end of the search word and search word is escaped.
-   */
-  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
-}

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

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

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

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

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

@@ -1,302 +0,0 @@
-package io.ebean;
-
-import io.ebean.bean.EntityBean;
-
-
-/**
- * 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 ebean-mocker project that enables you to use Mockito or similar
- * tools to still mock out the underlying 'default Database' for testing purposes.
- * <p>
- * You may choose not use this Model mapped superclass if you don't like the 'Active Record' style
- * or if you believe it 'pollutes' your entity beans.
- * <p>
- * You can use Dependency Injection like Guice or Spring to construct and wire a Database instance
- * and have that same instance used with this Model and Finder. The way that works is that when the
- * DI container creates the Database instance it can be registered with DB. In this
- * way the Database instance can be injected as per normal Guice / Spring dependency injection and
- * that same instance also used to support the Model and Finder active record style.
- * <p>
- * If you choose to use the Model mapped superclass you will probably also chose to additionally add
- * a {@link Finder} 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;
- *
- *     @WhenCreated Timestamp whenCreated;
- *
- *     @WhenUpdated Timestamp whenUpdated;
- *
- *     ...
- *   }
- * }</pre>
- * <p>
- * <h3>Extend the Model</h3>
- * <pre>{@code
- *
- *     // Extend the mappedSuperclass
- *
- *     @Entity @Table(name="o_account")
- *     public class Customer extends BaseModel {
- *
- *       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>
- */
-public abstract class Model {
-
-  /**
-   * The name of the database this entity will use, null for the default database.
-   */
-  private final String _$dbName;
-
-  /**
-   * Create using the default database.
-   */
-  public Model() {
-    this._$dbName = null;
-  }
-
-  /**
-   * Create with a named database (typically not the default database).
-   */
-  public Model(String dbName) {
-    this._$dbName = dbName;
-  }
-
-  /**
-   * Return the underlying 'default' Database.
-   * <p>
-   * This provides full access to the API such as explicit transaction demarcation etc.
-   * <p>
-   * Example:
-   * <pre>{@code
-   *
-   * try (Transaction transaction = Customer.db().beginTransaction()) {
-   *
-   *   // 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();
-   *
-   * }
-   *
-   * }</pre>
-   */
-  public Database db() {
-    return DB.byName(_$dbName);
-  }
-
-  /**
-   * 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 Database#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 Database#save(Object)
-   */
-  public void save() {
-    db().save(this);
-  }
-
-  /**
-   * Save this entity with an explicit transaction.
-   */
-  public void save(Transaction transaction) {
-    db().save(this, transaction);
-  }
-
-  /**
-   * Flush any batched changes to the database.
-   * <p>
-   * When using JDBC batch flushing occurs automatically at commit() time or when the batch size
-   * is reached. This provides the ability to manually flush the batch.
-   * </p>
-   */
-  public void flush() {
-    db().flush();
-  }
-
-  /**
-   * Update this entity.
-   *
-   * @see Database#update(Object)
-   */
-  public void update() {
-    db().update(this);
-  }
-
-  /**
-   * Update this entity with an explicit transaction.
-   */
-  public void update(Transaction transaction) {
-    db().update(this, transaction);
-  }
-
-  /**
-   * Insert this entity.
-   *
-   * @see Database#insert(Object)
-   */
-  public void insert() {
-    db().insert(this);
-  }
-
-  /**
-   * Insert with an explicit transaction.
-   */
-  public void insert(Transaction transaction) {
-    db().insert(this, transaction);
-  }
-
-  /**
-   * Delete this bean.
-   * <p>
-   * This will return true if the bean was deleted successfully or JDBC batch is being used.
-   * </p>
-   * <p>
-   * If there is no current transaction one will be created and committed for
-   * you automatically.
-   * </p>
-   * <p>
-   * If the Bean does not have a version property (or loaded version property) and
-   * the bean does not exist then this returns false indicating that nothing was
-   * deleted. Note that, if JDBC batch mode is used then this always returns true.
-   * </p>
-   *
-   * @see Database#delete(Object)
-   */
-  public boolean delete() {
-    return db().delete(this);
-  }
-
-  /**
-   * Delete this entity with an explicit transaction.
-   */
-  public boolean delete(Transaction transaction) {
-    return db().delete(this, transaction);
-  }
-
-  /**
-   * Delete a bean permanently without soft delete.
-   * <p>
-   * This is used when the bean contains a <code>@SoftDelete</code> property and we
-   * want to perform a hard/permanent delete.
-   * </p>
-   *
-   * @see Database#deletePermanent(Object)
-   */
-  public boolean deletePermanent() {
-    return db().deletePermanent(this);
-  }
-
-  /**
-   * Delete a bean permanently without soft delete using an explicit transaction.
-   */
-  public boolean deletePermanent(Transaction transaction) {
-    return db().deletePermanent(this, transaction);
-  }
-
-  /**
-   * Refreshes this entity from the database.
-   *
-   * @see Database#refresh(Object)
-   */
-  public void refresh() {
-    db().refresh(this);
-  }
-
-}

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

@@ -1,19 +0,0 @@
-package io.ebean;
-
-/**
- * Owner object notified when a modification is detected.
- */
-public interface ModifyAwareType {
-
-  /**
-   * Return true if the value is considered dirty.
-   * Note that this resets the dirty status back to clean.
-   */
-  boolean isMarkedDirty();
-
-  /**
-   * Marks the object as modified.
-   */
-  void setMarkedDirty(boolean markedDirty);
-
-}

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

@@ -1,470 +0,0 @@
-package io.ebean;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-
-/**
- * Represents an Order By for a Query.
- * <p>
- * Is a ordered list of OrderBy.Property objects each specifying a property and
- * whether it is ascending or descending order.
- * </p>
- * <p>
- * Typically you will not construct an OrderBy yourself but use one that exists
- * on the Query object.
- * </p>
- */
-public class OrderBy<T> implements Serializable {
-
-  private static final long serialVersionUID = 9157089257745730539L;
-
-  private transient Query<T> query;
-
-  private final List<Property> list;
-
-  /**
-   * Create an empty OrderBy with no associated query.
-   */
-  public OrderBy() {
-    this.list = new ArrayList<>(3);
-  }
-
-  private OrderBy(List<Property> list) {
-    this.list = list;
-  }
-
-  /**
-   * Create an orderBy parsing the order by clause.
-   * <p>
-   * The order by clause follows SQL order by clause with comma's between each
-   * property and optionally "asc" or "desc" to represent ascending or
-   * descending order respectively.
-   * </p>
-   */
-  public OrderBy(String orderByClause) {
-    this(null, orderByClause);
-  }
-
-  /**
-   * Construct with a given query and order by clause.
-   */
-  public OrderBy(Query<T> query, String orderByClause) {
-    this.query = query;
-    this.list = new ArrayList<>(3);
-    parse(orderByClause);
-  }
-
-  /**
-   * Reverse the ascending/descending order on all the properties.
-   */
-  public void reverse() {
-    for (Property aList : list) {
-      aList.reverse();
-    }
-  }
-
-  /**
-   * Add a property with ascending order to this OrderBy.
-   */
-  public Query<T> asc(String propertyName) {
-    list.add(new Property(propertyName, true));
-    return query;
-  }
-
-  /**
-   * Add a property with ascending order to this OrderBy.
-   */
-  public Query<T> asc(String propertyName, String collation) {
-    list.add(new Property(propertyName, true, collation));
-    return query;
-  }
-
-  /**
-   * Add a property with descending order to this OrderBy.
-   */
-  public Query<T> desc(String propertyName) {
-    list.add(new Property(propertyName, false));
-    return query;
-  }
-
-  /**
-   * Add a property with descending order to this OrderBy.
-   */
-  public Query<T> desc(String propertyName, String collation) {
-    list.add(new Property(propertyName, false, collation));
-    return query;
-  }
-
-  /**
-   * Return true if the property is known to be contained in the order by clause.
-   */
-  public boolean containsProperty(String propertyName) {
-    for (Property aList : list) {
-      if (propertyName.equals(aList.getProperty())) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Return a copy of this OrderBy with the path trimmed.
-   */
-  public OrderBy<T> copyWithTrim(String path) {
-    List<Property> newList = new ArrayList<>(list.size());
-    for (Property aList : list) {
-      newList.add(aList.copyWithTrim(path));
-    }
-    return new OrderBy<>(newList);
-  }
-
-  /**
-   * Return the properties for this OrderBy.
-   */
-  public List<Property> getProperties() {
-    // not returning an Immutable list at this point
-    return list;
-  }
-
-  /**
-   * Return true if this OrderBy does not have any properties.
-   */
-  public boolean isEmpty() {
-    return list.isEmpty();
-  }
-
-  /**
-   * Return the associated query if there is one.
-   */
-  public Query<T> getQuery() {
-    return query;
-  }
-
-  /**
-   * Associate this OrderBy with a query.
-   */
-  public void setQuery(Query<T> query) {
-    this.query = query;
-  }
-
-  /**
-   * Return a copy of the OrderBy.
-   */
-  public OrderBy<T> copy() {
-    OrderBy<T> copy = new OrderBy<>();
-    for (Property property : list) {
-      copy.add(property.copy());
-    }
-    return copy;
-  }
-
-  /**
-   * Add to the order by by parsing a raw expression.
-   */
-  public void add(String rawExpression) {
-    parse(rawExpression);
-  }
-
-  /**
-   * Add a property to the order by.
-   */
-  public void add(Property p) {
-    list.add(p);
-  }
-
-  @Override
-  public String toString() {
-    return list.toString();
-  }
-
-  /**
-   * Returns the OrderBy in string format.
-   */
-  public String toStringFormat() {
-    if (list.isEmpty()) {
-      return null;
-    }
-    StringBuilder sb = new StringBuilder();
-    for (int i = 0; i < list.size(); i++) {
-      Property property = list.get(i);
-      if (i > 0) {
-        sb.append(", ");
-      }
-      sb.append(property.toStringFormat());
-    }
-    return sb.toString();
-  }
-
-  @Override
-  public boolean equals(Object obj) {
-    if (obj == this) {
-      return true;
-    }
-    if (!(obj instanceof OrderBy<?>)) {
-      return false;
-    }
-    OrderBy<?> e = (OrderBy<?>) obj;
-    return e.list.equals(list);
-  }
-
-  /**
-   * Return a hash value for this OrderBy. This can be to determine logical
-   * equality for OrderBy clauses.
-   */
-  @Override
-  public int hashCode() {
-    return list.hashCode();
-  }
-
-  /**
-   * Clear the orderBy removing any current order by properties.
-   * <p>
-   * This is intended to be used when some code creates a query with a
-   * 'default' order by clause and some other code may clear the 'default'
-   * order by clause and replace.
-   * </p>
-   */
-  public OrderBy<T> clear() {
-    list.clear();
-    return this;
-  }
-
-  /**
-   * Return true if this order by can be used in select clause.
-   */
-  public boolean supportsSelect() {
-    for (Property property : list) {
-      if (!property.supportsSelect()) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * A property and its ascending descending order.
-   */
-  public static class Property implements Serializable {
-
-    private static final long serialVersionUID = 1546009780322478077L;
-
-    private String property;
-
-    private boolean ascending;
-
-    private String collation;
-
-    private String nulls;
-
-    private String highLow;
-
-    public Property(String property, boolean ascending) {
-      this.property = property;
-      this.ascending = ascending;
-    }
-
-    public Property(String property, boolean ascending, String nulls, String highLow) {
-      this.property = property;
-      this.ascending = ascending;
-      this.nulls = nulls;
-      this.highLow = highLow;
-    }
-
-    public Property(String property, boolean ascending, String collation) {
-      this.property = property;
-      this.ascending = ascending;
-      this.collation = collation;
-    }
-
-    public Property(String property, boolean ascending, String collation, String nulls, String highLow) {
-      this.property = property;
-      this.ascending = ascending;
-      this.collation = collation;
-      this.nulls = nulls;
-      this.highLow = highLow;
-    }
-
-    /**
-     * Return a copy of this Property with the path trimmed.
-     */
-    public Property copyWithTrim(String path) {
-      return new Property(property.substring(path.length() + 1), ascending, collation, nulls, highLow);
-    }
-
-    @Override
-    public int hashCode() {
-      int hc = property.hashCode();
-      hc = hc * 92821 + (ascending ? 0 : 1);
-      hc = hc * 92821 + (collation == null ? 0 : collation.hashCode());
-      hc = hc * 92821 + (nulls == null ? 0 : nulls.hashCode());
-      hc = hc * 92821 + (highLow == null ? 0 : highLow.hashCode());
-      return hc;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (obj == this) {
-        return true;
-      }
-      if (!(obj instanceof Property)) {
-        return false;
-      }
-      Property e = (Property) obj;
-      if (ascending != e.ascending) return false;
-      if (!property.equals(e.property)) return false;
-      if (!Objects.equals(collation, e.collation)) return false;
-      if (!Objects.equals(nulls, e.nulls)) return false;
-      return Objects.equals(highLow, e.highLow);
-    }
-
-    @Override
-    public String toString() {
-      return toStringFormat();
-    }
-
-    public String toStringFormat() {
-      if (nulls == null && collation == null) {
-        if (ascending) {
-          return property;
-        } else {
-          return property + " desc";
-        }
-      } else {
-        StringBuilder sb = new StringBuilder();
-        if (collation != null)  {
-          if (collation.contains("${}")) {
-            // this is a complex collation, e.g. DB2 - we must replace the property
-            sb.append(collation.replace("${}", property));
-          } else {
-            sb.append(property);
-            sb.append(" collate ").append(collation);
-          }
-        } else {
-          sb.append(property);
-        }
-        if (!ascending) {
-          sb.append(" ").append("desc");
-        }
-        if (nulls != null) {
-          sb.append(" ").append(nulls).append(" ").append(highLow);
-        }
-        return sb.toString();
-      }
-    }
-
-    /**
-     * Reverse the ascending/descending order for this property.
-     */
-    public void reverse() {
-      this.ascending = !ascending;
-    }
-
-    /**
-     * Trim off the pathPrefix.
-     */
-    public void trim(String pathPrefix) {
-      property = property.substring(pathPrefix.length() + 1);
-    }
-
-    /**
-     * Return a copy of this property.
-     */
-    public Property copy() {
-      return new Property(property, ascending, collation, nulls, highLow);
-    }
-
-    /**
-     * Return the property name.
-     */
-    public String getProperty() {
-      return property;
-    }
-
-    /**
-     * Set the property name.
-     */
-    public void setProperty(String property) {
-      this.property = property;
-    }
-
-    /**
-     * Return true if the order is ascending.
-     */
-    public boolean isAscending() {
-      return ascending;
-    }
-
-    /**
-     * Set to true if the order is ascending.
-     */
-    public void setAscending(boolean ascending) {
-      this.ascending = ascending;
-    }
-
-    /**
-     * Support use in select clause if no collation or nulls ordering.
-     */
-    boolean supportsSelect() {
-      return nulls == null;
-    }
-  }
-
-  private void parse(String orderByClause) {
-    if (orderByClause == null) {
-      return;
-    }
-    for (String chunk : orderByClause.split(",")) {
-      Property p = parseProperty(chunk);
-      if (p != null) {
-        list.add(p);
-      }
-    }
-  }
-
-  private Property parseProperty(String chunk) {
-    String[] pairs = chunk.split(" ");
-    if (pairs.length == 0) {
-      return null;
-    }
-
-    ArrayList<String> wordList = new ArrayList<>(pairs.length);
-    for (String pair : pairs) {
-      if (!isEmptyString(pair)) {
-        wordList.add(pair);
-      }
-    }
-    if (wordList.isEmpty()) {
-      return null;
-    }
-    if (wordList.size() == 1) {
-      return new Property(wordList.get(0), true);
-    }
-    if (wordList.size() == 2) {
-      boolean asc = isAscending(wordList.get(1));
-      return new Property(wordList.get(0), asc);
-    }
-    if (wordList.size() == 4) {
-      // nulls high or nulls low as 3rd and 4th
-      boolean asc = isAscending(wordList.get(1));
-      return new Property(wordList.get(0), asc, wordList.get(2), wordList.get(3));
-    }
-    return new Property(chunk.trim(), true);
-  }
-
-  private boolean isAscending(String s) {
-    s = s.toLowerCase();
-    if (s.startsWith("asc")) {
-      return true;
-    }
-    if (s.startsWith("desc")) {
-      return false;
-    }
-    throw new RuntimeException("Expecting [" + s + "] to be asc or desc?");
-  }
-
-  private boolean isEmptyString(String s) {
-    return s == null || s.isEmpty();
-  }
-}

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

@@ -1,201 +0,0 @@
-package io.ebean;
-
-import java.util.List;
-import java.util.concurrent.Future;
-
-/**
- * Represents a page of results.
- * <p>
- * The benefit of using PagedList over just using the normal Query with
- * {@link Query#setFirstRow(int)} and {@link Query#setMaxRows(int)} is that it additionally wraps
- * functionality that can call {@link Query#findFutureCount()} to determine total row count,
- * total page count etc.
- * </p>
- * <p>
- * Internally this works using {@link Query#setFirstRow(int)} and {@link Query#setMaxRows(int)} on
- * the query. This translates into SQL that uses limit offset, rownum or row_number function to
- * limit the result set.
- * </p>
- * <p>
- * <h4>Example: typical use including total row count</h4>
- * <pre>{@code
- *
- *     // We want to find the first 50 new orders
- *     //  ... so we don't really need setFirstRow(0)
- *
- *     PagedList<Order> pagedList = DB.find(Order.class)
- *       .where().eq("status", Order.Status.NEW)
- *       .order().asc("id")
- *       .setFirstRow(0)
- *       .setMaxRows(50)
- *       .findPagedList();
- *
- *     // Optional: initiate the loading of the total
- *     // row count in a background thread
- *     pagedList.loadRowCount();
- *
- *     // fetch and return the list in the foreground thread
- *     List<Order> orders = pagedList.getList();
- *
- *     // get the total row count (from the future)
- *     int totalRowCount = pagedList.getTotalRowCount();
- *
- * }</pre>
- * <p>
- * <h4>Example: No total row count required</h4>
- * <pre>{@code
- *
- *     // If you are not getting the 'first page' often
- *     // you do not bother getting the total row count again
- *     // so instead just get the page list of data
- *
- *     // fetch and return the list in the foreground thread
- *     List<Order> orders = pagedList.getList();
- *
- * }</pre>
- *
- * @param <T> the entity bean type
- * @see Query#findPagedList()
- */
-public interface PagedList<T> {
-
-  /**
-   * Return an empty PagedList.
-   */
-  static <B> PagedList<B> emptyList() {
-    return new EmptyPagedList<>();
-  }
-
-  /**
-   * Initiate the loading of the total row count in the background.
-   * <pre>{@code
-   *
-   *     // initiate the loading of the total row count
-   *     // in a background thread
-   *     pagedList.loadRowCount();
-   *
-   *     // fetch and return the list in the foreground thread
-   *     List<Order> orders = pagedList.getList();
-   *
-   *     // get the total row count (from the future)
-   *     int totalRowCount = pagedList.getTotalRowCount();
-   *
-   * }</pre>
-   * <p>
-   * Also note that using loadRowCount() and getTotalRowCount() rather than getFutureRowCount()
-   * means that exceptions ExecutionException, InterruptedException, TimeoutException are instead
-   * wrapped in the unchecked PersistenceException (which might be preferrable).
-   * </p>
-   */
-  void loadCount();
-
-  /**
-   * Return the Future row count. You might get this if you wish to cancel the total row count query
-   * or specify a timeout for the row count query.
-   * <p>
-   * The loadRowCount() and getTotalRowCount() methods internally make use of this getFutureRowCount() method.
-   * Generally I expect people to prefer loadRowCount() and getTotalRowCount() over getFutureRowCount().
-   * </p>
-   * <pre>{@code
-   *
-   *     // initiate the row count query in the background thread
-   *     Future<Integer> rowCount = pagedList.getFutureRowCount();
-   *
-   *     // fetch and return the list in the foreground thread
-   *     List<Order> orders = pagedList.getList();
-   *
-   *     // now get the total count with a timeout
-   *     Integer totalRowCount = rowCount.get(30, TimeUnit.SECONDS);
-   *
-   *     // or ge the total count without a timeout
-   *     Integer totalRowCountViaFuture = rowCount.get();
-   *
-   *     // which is actually the same as ...
-   *     int totalRowCount = pagedList.getTotalRowCount();
-   *
-   * }</pre>
-   */
-  Future<Integer> getFutureCount();
-
-  /**
-   * Return the list of entities for this page.
-   */
-  List<T> getList();
-
-  /**
-   * Return the total row count for all pages.
-   * <p>
-   * If loadRowCount() has already been called then the row count query is already executing in a background thread
-   * and this gets the associated Future and gets the value waiting for the future to finish.
-   * </p>
-   * <p>
-   * If loadRowCount() has not been called then this executes the find row count query and returns the result and this
-   * will just occur in the current thread and not use a background thread.
-   * </p>
-   * <pre>{@code
-   *
-   *     // Optional: initiate the loading of the total
-   *     // row count in a background thread
-   *     pagedList.loadRowCount();
-   *
-   *     // fetch and return the list in the foreground thread
-   *     List<Order> orders = pagedList.getList();
-   *
-   *     // get the total row count (which was being executed
-   *     // in a background thread if loadRowCount() was used)
-   *     int totalRowCount = pagedList.getTotalRowCount();
-   *
-   * }</pre>
-   */
-  int getTotalCount();
-
-  /**
-   * Return the total number of pages based on the page size and total row count.
-   * <p>
-   * This method requires that the total row count has been fetched and will invoke
-   * the total row count query if it has not already been invoked.
-   * </p>
-   */
-  int getTotalPageCount();
-
-  /**
-   * Return the page size used for this query. This is the same value as maxRows used by the query.
-   */
-  int getPageSize();
-
-  /**
-   * Return the index position of this page (Zero based).
-   * <p>
-   * This is a calculated value based on firstRow/maxRows.
-   * </p>
-   */
-  int getPageIndex();
-
-  /**
-   * Return true if there is a next page.
-   * <p>
-   * This method requires that the total row count has been fetched and will invoke
-   * the total row count query if it has not already been invoked.
-   * </p>
-   */
-  boolean hasNext();
-
-  /**
-   * Return true if there is a previous page.
-   */
-  boolean hasPrev();
-
-  /**
-   * Helper method to return a "X to Y of Z" string for this page where X is the first row, Y the
-   * last row and Z the total row count.
-   * <p>
-   * This method requires that the total row count has been fetched and will invoke
-   * the total row count query if it has not already been invoked.
-   * </p>
-   *
-   * @param to String to put between the first and last row
-   * @param of String to put between the last row and the total row count
-   * @return String of the format XtoYofZ.
-   */
-  String getDisplayXtoYofZ(String to, String of);
-}

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

@@ -1,236 +0,0 @@
-package io.ebean;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Objects;
-
-/**
- * Holds a list of value object pairs.
- * <p>
- * This feature is to enable use of L2 cache with complex natural keys with findList() queries in cases where the
- * IN clause is not a single property but instead a pair of properties.
- * </p>
- * <p>
- * These queries can have predicates that can be translated into a list of complex natural keys such that the L2
- * cache can be hit with these keys to obtain some or all of the beans from L2 cache rather than the DB.
- * </p>
- * <pre>{@code
- *
- *   // where a bean is annotated with a complex
- *   // natural key made of several properties
- *   @Cache(naturalKey = {"store","code","sku"})
- *
- *
- *   Pairs pairs = new Pairs("sku", "code");
- *   pairs.add("sj2", 1000);
- *   pairs.add("sj2", 1001);
- *   pairs.add("pf3", 1000);
- *
- *   List<OCachedNatKeyBean3> list = DB.find(OCachedNatKeyBean3.class)
- *   .where()
- *   .eq("store", "def")
- *   .inPairs(pairs)       // IN clause with 'pairs' of values
- *   .order("sku desc")
- *
- *   // query expressions cover the natural key properties
- *   // so we can choose to hit the L2 bean cache if we want
- *   .setUseCache(true)
- *   .findList();
- *
- * }</pre>
- * <h3>Important implementation Note</h3>
- * <p>
- * When binding many pairs of values we want to be able to utilise a DB index (as this type of query usually means the
- * pairs are a unique key/index or part of a unique key/index and highly selective). Currently we know we can do this
- * on any DB that supports expression/formula based indexes.
- * using a DB string concatenation formula
- * </p>
- * <p>
- * This means, the implementation converts the list of pairs into a list of strings via concatenation and we use a
- * DB concatenation formula to match. We see SQL like:
- * </p>
- * <pre>{@code sql
- *
- *   ...
- *   where t0.store = ?  and (t0.sku||'-'||t0.code) in (?, ? )
- *
- *   // bind values like: "sj2-1000", "pf3-1000"
- *
- * }</pre>
- * <p>
- * We often create a DB expression index to match the DB concat formula like:
- * </p>
- * <pre>{@code sql
- *
- *   create index ix_name on table_name (sku || '-' || code);
- *
- * }</pre>
- */
-public final class Pairs {
-
-  private final String property0;
-  private final String property1;
-  private final List<Entry> entries = new ArrayList<>();
-
-  /**
-   * Character between the values when combined via DB varchar concatenation.
-   */
-  private String concatSeparator = "-";
-
-  /**
-   * Optional suffix added to DB varchar concatenation formula.
-   */
-  private String concatSuffix;
-
-  /**
-   * Create with 2 property names.
-   *
-   * @param property0 The property of the first value
-   * @param property1 The property of the second value
-   */
-  public Pairs(String property0, String property1) {
-    this.property0 = property0;
-    this.property1 = property1;
-  }
-
-  /**
-   * Add a pair of value objects.
-   * <p>
-   * Both values are expected to be immutable with equals and hashCode implementations.
-   * </p>
-   *
-   * @param a Value of the first property
-   * @param b Value of the second property
-   */
-  public Pairs add(Object a, Object b) {
-    entries.add(new Entry(a, b));
-    return this;
-  }
-
-  /**
-   * Return the first property name.
-   */
-  public String property0() {
-    return property0;
-  }
-
-  /**
-   * Return the second property name.
-   */
-  public String property1() {
-    return property1;
-  }
-
-  /**
-   * Return all the value pairs.
-   */
-  public List<Entry> entries() {
-    return Collections.unmodifiableList(entries);
-  }
-
-  /**
-   * Return the separator character used with DB varchar concatenation to combine the 2 values.
-   */
-  public String concatSeparator() {
-    return concatSeparator;
-  }
-
-  /**
-   * Set the separator character used with DB varchar concatenation to combine the 2 values.
-   */
-  public Pairs concatSeparator(String concatSeparator) {
-    this.concatSeparator = concatSeparator;
-    return this;
-  }
-
-  /**
-   * Deprecated migrate to concatSeparator()
-   */
-  @Deprecated
-  public Pairs setConcatSeparator(String concatSeparator) {
-    return concatSeparator(concatSeparator);
-  }
-
-  /**
-   * Return  a suffix used with DB varchar concatenation to combine the 2 values.
-   */
-  public String concatSuffix() {
-    return concatSuffix;
-  }
-
-  /**
-   * Add a suffix used with DB varchar concatenation to combine the 2 values.
-   */
-  public Pairs concatSuffix(String concatSuffix) {
-    this.concatSuffix = concatSuffix;
-    return this;
-  }
-
-  /**
-   * Deprecated migrate to concatSuffix()
-   */
-  @Deprecated
-  public Pairs setConcatSuffix(String concatSuffix) {
-    return concatSuffix(concatSuffix);
-  }
-
-  @Override
-  public String toString() {
-    return "p0:" + property0 + " p1:" + property1 + " entries:" + entries;
-  }
-
-  /**
-   * A pair of 2 value objects.
-   * <p>
-   * Used to support inPairs() expression.
-   */
-  public static class Entry {
-
-    private final Object a;
-    private final Object b;
-
-    /**
-     * Create with values for property0 and property1 respectively.
-     *
-     * @param a Value of the first property
-     * @param b Value of the second property
-     */
-    public Entry(Object a, Object b) {
-      this.a = a;
-      this.b = b;
-    }
-
-    @Override
-    public String toString() {
-      return "{" + a + "," + b + "}";
-    }
-
-    /**
-     * Return the value for the first property.
-     */
-    public Object getA() {
-      return a;
-    }
-
-    /**
-     * Return the value for the second property.
-     */
-    public Object getB() {
-      return b;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) return true;
-      if (o == null || getClass() != o.getClass()) return false;
-      Entry that = (Entry) o;
-      return a.equals(that.a) && b.equals(that.b);
-    }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(a, b);
-    }
-  }
-}

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

@@ -1,35 +0,0 @@
-package io.ebean;
-
-/**
- * Defines the scope for PersistenceContext.
- * <p/>
- * Ebean has traditionally used Transaction scope for the PersistenceContext. This is used to change the scope to
- * use (by default) and explicitly set the scope to use for an individual query.
- *
- * @see io.ebean.config.DatabaseConfig#setPersistenceContextScope(PersistenceContextScope)
- * @see Query#setPersistenceContextScope(PersistenceContextScope)
- */
-public enum PersistenceContextScope {
-
-  /**
-   * PersistenceContext is scoped to the transaction.
-   * <p/>
-   * If a transaction spans 2 or more queries that fetch the same bean in terms of same type
-   * and same Id value then they share the same bean instance.
-   * <p/>
-   * You may want to change to use QUERY scope when you want a query executing in a transaction to effectively
-   * ignore beans that have already been loaded (by other queries in the same transaction) and instead get a
-   * 'fresh copy' of the bean.
-   */
-  TRANSACTION,
-
-  /**
-   * PersistenceContext is scoped to the query.
-   * <p/>
-   * This means that for this query running in an existing transaction then it will effectively ignore any beans
-   * that have already been queried/loaded by prior queries in the same transaction.
-   * <p/>
-   * You may use QUERY scope on a query that is executed in a transaction and you want to get a 'fresh copy' of the bean.
-   */
-  QUERY
-}

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

@@ -1,20 +0,0 @@
-package io.ebean;
-
-import javax.persistence.PersistenceException;
-
-/**
- * Captures and wraps IOException's occurring during ElasticSearch processing etc.
- */
-public class PersistenceIOException extends PersistenceException {
-
-  private static final long serialVersionUID = -7630050437148176148L;
-
-  public PersistenceIOException(String msg, Exception cause) {
-    super(msg, cause);
-  }
-
-  public PersistenceIOException(Exception cause) {
-    super(cause);
-  }
-
-}

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

@@ -1,67 +0,0 @@
-package io.ebean;
-
-/**
- * A location for profiling transactions and queries.
- * <p>
- * Typically represents a class method in the form of class file and line of code that started
- * the transaction or invoked the query.
- * </p>
- */
-public interface ProfileLocation {
-
-  /**
-   * Create and return a new ProfileLocation.
-   */
-  static ProfileLocation create() {
-    return XServiceProvider.profileLocationFactory().create();
-  }
-
-  /**
-   * Create and return a new ProfileLocation with a given lineNumber and label.
-   */
-  static ProfileLocation create(int lineNumber, String label) {
-    return XServiceProvider.profileLocationFactory().create(lineNumber, label);
-  }
-
-  /**
-   * Create and return a new ProfileLocation with a given location.
-   */
-  static ProfileLocation createAt(String location) {
-    return XServiceProvider.profileLocationFactory().createAt(location);
-  }
-
-  /**
-   * Obtain the description returning true if this is the initial call.
-   */
-  boolean obtain();
-
-  /**
-   * Return a short version of the location description.
-   */
-  String location();
-
-  /**
-   * Return the short label.
-   */
-  String label();
-
-  /**
-   * Return the full location.
-   */
-  String fullLocation();
-
-  /**
-   * Add execution time.
-   */
-  void add(long executionTime);
-
-  /**
-   * Return true if this request should be traced.
-   */
-  boolean trace();
-
-  /**
-   * Set the number of times to trace the transactions for this profile location.
-   */
-  void setTraceCount(int traceCount);
-}

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

@@ -1,78 +0,0 @@
-package io.ebean;
-
-import java.util.Iterator;
-
-/**
- * Used to provide iteration over query results.
- * <p>
- * This can be used when you want to process a very large number of results and
- * means that you don't have to hold all the results in memory at once (unlike
- * findList(), findSet() etc where all the beans are held in the List or Set
- * etc).
- * </p>
- * <p>
- * Note that findIterate (and findEach and findEachWhile) uses a "per graph"
- * persistence context scope and adjusts jdbc fetch buffer size for large
- * queries. As such it is better to use findList for small queries.
- * </p>
- * <p>
- * Remember that with {@link QueryIterator} you must call {@link QueryIterator#close()}
- * when you have finished iterating the results. Use "try with resources" or ensure it
- * is closed in a finally block.
- * </p>
- * <h3>Try finally style</h3>
- * <pre>{@code
- *
- *  Query<Customer> query = database.find(Customer.class)
- *     .where().gt("id", 0)
- *     .order("id")
- *     .setMaxRows(2);
- *
- *  QueryIterator<Customer> it = query.findIterate();
- *  try {
- *    while (it.hasNext()) {
- *      Customer customer = it.next();
- *      // do something with customer ...
- *    }
- *  } finally {
- *    // close the underlying resources
- *    it.close();
- *  }
- *
- * }</pre>
- * <p>
- * <h3>Try with resources style</h3>
- * <pre>{@code
- *
- *  // try with resources
- *  try (QueryIterator<Customer> it = query.findIterate()) {
- *    while (it.hasNext()) {
- *      Customer customer = it.next();
- *      // do something with customer ...
- *    }
- *  }
- *
- * }</pre>
- *
- * @param <T> the type of entity bean in the iteration
- */
-public interface QueryIterator<T> extends Iterator<T>, AutoCloseable {
-
-  /**
-   * Returns <tt>true</tt> if the iteration has more elements.
-   */
-  @Override
-  boolean hasNext();
-
-  /**
-   * Returns the next element in the iteration.
-   */
-  @Override
-  T next();
-
-  /**
-   * Close the underlying resources held by this iterator.
-   */
-  @Override
-  void close();
-}

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

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

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

@@ -1,150 +0,0 @@
-package io.ebean;
-
-/**
- * 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>
- * <b>Unparsed RawSql:</b>
- * <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>
- * <b>Parsed RawSql:</b>
- * <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>
- * 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>
- * <b>Aggregates:</b>
- * <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>
- * <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>
- *
- * <h3>Example 1:</h3>
- *
- * <pre>{@code
- *
- *   String sql = " select order_id, o.status, c.id, c.name, sum(l.order_qty*l.unit_price) as totalAmount"
- *     + " from order o"
- *     + " join customer c on c.id = o.customer_id "
- *     + " join order_line l on l.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 = DB.find(OrderAggregate.class)
- *       .setRawSql(rawSql)
- *       .where().gt("order.id", 0)
- *       .having().gt("totalAmount", 20)
- *       .findList();
- *
- *
- * }</pre>
- *
- * <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.
- *
- * <pre>{@code
- *
- *  String sql = " select order_id, 'ignoreMe', sum(l.order_qty*l.unit_price) as totalAmount "
- *     + " from order_line l"
- *     + " group by order_id ";
- *
- *   RawSql rawSql = RawSqlBuilder.parse(sql)
- *     .columnMapping("order_id", "order.id")
- *     .columnMappingIgnore("'ignoreMe'")
- *     .create();
- *
- *   List<OrderAggregate> orders = DB.find(OrderAggregate.class)
- *     .setRawSql(rawSql)
- *     .fetch("order", "status,orderDate", FetchConfig.ofQuery())
- *     .fetch("order.customer", "name")
- *     .where().gt("order.id", 0)
- *     .having().gt("totalAmount", 20)
- *     .order().desc("totalAmount")
- *     .setMaxRows(10)
- *     .findList();
- *
- * }</pre>
- * <h3>Example 3: tableAliasMapping</h3>
- * <p>
- * Instead of mapping each column you can map each table alias to a path using tableAliasMapping().
- * <pre>{@code
- *
- *   String rs = "select o.id, o.status, c.id, c.name, "+
- *               " l.id, l.order_qty, p.id, p.name " +
- *               "from orders o join o_customer c on c.id = o.customer_id " +
- *               "join order_line l on l.order_id = o.id  " +
- *               "join product p on p.id = l.product_id  " +
- *               "where o.id <= :maxOrderId  and p.id = :productId "+
- *               "order by o.id, l.id asc";
- *
- *  RawSql rawSql = RawSqlBuilder.parse(rs)
- *       .tableAliasMapping("c", "customer")
- *       .tableAliasMapping("l", "lines")
- *       .tableAliasMapping("p", "lines.product")
- *       .create();
- *
- *  List<Order> ordersFromRaw = DB.find(Order.class)
- *       .setRawSql(rawSql)
- *       .setParameter("maxOrderId", 2)
- *       .setParameter("productId", 1)
- *       .findList();
- *
- * }</pre>
- * <p>
- * Note that lazy loading also works with object graphs built with RawSql.
- */
-public interface RawSql {
-
-}

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

@@ -1,95 +0,0 @@
-package io.ebean;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-
-/**
- * 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 interface RawSqlBuilder {
-
-  /**
-   * 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.
-   */
-  static RawSql resultSet(ResultSet resultSet, String... propertyNames) {
-    return XServiceProvider.rawSql().resultSet(resultSet, propertyNames);
-  }
-
-  /**
-   * Create and return a SqlRow based on the resultSet with dbTrueValue and binaryOptimizedUUID options.
-   */
-  static SqlRow sqlRow(ResultSet resultSet, final String dbTrueValue, boolean binaryOptimizedUUID) throws SQLException {
-    return XServiceProvider.rawSql().sqlRow(resultSet, dbTrueValue, binaryOptimizedUUID);
-  }
-
-  /**
-   * Return an unparsed RawSqlBuilder. Unlike a parsed one this query can not be
-   * modified - so no additional WHERE or HAVING expressions can be added to
-   * this query.
-   */
-  static RawSqlBuilder unparsed(String sql) {
-    return XServiceProvider.rawSql().unparsed(sql);
-  }
-
-  /**
-   * 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>
-   */
-  static RawSqlBuilder parse(String sql) {
-    return XServiceProvider.rawSql().parsed(sql);
-  }
-
-  /**
-   * 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.
-   */
-  RawSqlBuilder columnMapping(String dbColumn, String propertyName);
-
-  /**
-   * Ignore this DB column. It is not mapped to any bean property.
-   */
-  RawSqlBuilder columnMappingIgnore(String dbColumn);
-
-  /**
-   * 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>
-   */
-  RawSqlBuilder tableAliasMapping(String tableAlias, String path);
-
-  /**
-   * Create the immutable RawSql object. Do this after all the column mapping
-   * has been defined.
-   */
-  RawSql create();
-
-}

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

@@ -1,40 +0,0 @@
-package io.ebean;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-
-/**
- * Used with SqlQuery to process potentially large queries reading directly from the JDBC ResultSet.
- * <p>
- * This provides a low level option that reads directly from the JDBC ResultSet.
- * </p>
- *
- * <pre>{@code
- *
- *  String sql = "select id, name, status from o_customer order by name desc";
- *
- *  DB.sqlQuery(sql)
- *    .findEachRow((resultSet, rowNum) -> {
- *
- *      // read directly from ResultSet
- *
- *      long id = resultSet.getLong(1);
- *      String name = resultSet.getString(2);
- *
- *      // do something interesting with the data
- *
- *    });
- *
- * }</pre>
- */
-@FunctionalInterface
-public interface RowConsumer {
-
-  /**
-   * Read the data from the ResultSet and process it.
-   *
-   * @param resultSet The JDBC ResultSet positioned to the current row
-   * @param rowNum    The number of the current row being mapped.
-   */
-  void accept(ResultSet resultSet, int rowNum) throws SQLException;
-}

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

@@ -1,63 +0,0 @@
-package io.ebean;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-
-/**
- * Used with SqlQuery to map raw JDBC ResultSet to objects.
- * <p>
- * This provides a low level mapping option with direct use of JDBC ResultSet
- * with the option of having logic in the mapping. For example, only map some
- * columns depending on the values read from other columns.
- * </p>
- * <p>
- * For straight mapping into beans then DtoQuery would be the first choice as
- * it can automatically map the ResultSet into beans.
- * </p>
- *
- * <pre>{@code
- *
- *    //
- *    // Map from ResultSet to CustomerDto bean
- *    //
- *    class CustomerMapper implements RowMapper<CustomerDto> {
- *
- *     @Override
- *     public CustomerDto map(ResultSet rset, int rowNum) throws SQLException {
- *
- *       long id = rset.getLong(1);
- *       String name = rset.getString(2);
- *       String status = rset.getString(3);
- *
- *       return new CustomerDto(id, name, status);
- *     }
- *   }
- *
- *
- *   //
- *   // Then use the mapper
- *   //
- *
- *   String sql = "select id, name, status from o_customer where name = ?";
- *
- *  CustomerDto rob = DB.sqlQuery(sql)
- *    .setParameter(1, "Rob")
- *    .mapTo(CUSTOMER_MAPPER)
- *    .findOne();
- *
- *
- * }</pre>
- *
- * @param <T> The type the row data is mapped into.
- */
-@FunctionalInterface
-public interface RowMapper<T> {
-
-  /**
-   * Read the data from the ResultSet and map to the return type.
-   *
-   * @param resultSet The JDBC ResultSet positioned to the current row
-   * @param rowNum    The number of the current row being mapped.
-   */
-  T map(ResultSet resultSet, int rowNum) throws SQLException;
-}

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

@@ -1,73 +0,0 @@
-package io.ebean;
-
-import java.net.URL;
-import java.nio.file.Path;
-import java.util.Map;
-
-/**
- * Runs DDL and SQL scripts.
- * <p/>
- * Typically these are scripts used for testing such as seed SQL scripts or truncate SQL scripts.
- * <p/>
- * Scripts are executed in their own transaction and committed on successful completion.
- *
- * <h3>Example of simple use</h3>
- * <pre>{@code
- *
- *   Database database = DB.getDefault();
- *   database.script().run("/scripts/test-script.sql");
- *
- * }</pre>
- */
-public interface ScriptRunner {
-
-  /**
-   * Run a script given the resource path (that should start with "/").
-   */
-  void run(String resourcePath);
-
-  /**
-   * Run a script given the resource path (that should start with "/") and place-holders.
-   *
-   * <pre>{@code
-   *
-   *   Map<String,String> placeholders = new HashMap<>();
-   *   placeholders.put("tableName", "e_basic");
-   *
-   *   Database database = DB.getDefault();
-   *   database.script().run("/scripts/test-script.sql", placeholders);
-   *
-   * }</pre>
-   */
-  void run(String resourcePath, Map<String, String> placeholderMap);
-
-  /**
-   * Run a DDL or SQL script given the resource.
-   */
-  void run(URL resource);
-
-  /**
-   * Run a DDL or SQL script given the resource and place-holders.
-   */
-  void run(URL resource, Map<String, String> placeholderMap);
-
-  /**
-   * Run a DDL or SQL script given the file.
-   */
-  void run(Path file);
-
-  /**
-   * Run a DDL or SQL script given the file and place-holders.
-   */
-  void run(Path file, Map<String, String> placeholderMap);
-
-  /**
-   * Run the raw provided DDL or SQL script.
-   *
-   * @param name          The name of the script for logging purposes
-   * @param content       The SQL content
-   * @param useAutoCommit Set to true to use auto commit true and continue when any errors occur
-   */
-  void runScript(String name, String content, boolean useAutoCommit);
-
-}

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

@@ -1,18 +0,0 @@
-package io.ebean;
-
-import javax.persistence.OptimisticLockException;
-
-/**
- * Thrown at SERIALIZABLE isolation level for non-recoverable concurrent conflict.
- */
-public class SerializableConflictException extends OptimisticLockException {
-
-  private static final long serialVersionUID = 1L;
-
-  /**
-   * Create with a message and cause.
-   */
-  public SerializableConflictException(String message, Throwable cause) {
-    super(message, cause);
-  }
-}

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

@@ -1,384 +0,0 @@
-package io.ebean;
-
-import io.avaje.lang.NonNullApi;
-import io.avaje.lang.Nullable;
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-/**
- * Query object for performing native SQL queries that return SqlRow or directly read
- * ResultSet using a RowMapper.
- * <p>
- * The returned SqlRow objects are similar to a LinkedHashMap with some type
- * conversion support added.
- * </p>
- * <p>
- * Refer to {@link DtoQuery} for native sql queries returning DTO beans.
- * </p>
- * <p>
- * Refer to {@link Database#findNative(Class, String)} for native sql queries returning entity beans.
- * </p>
- *
- * <pre>{@code
- *
- *   // example using named parameters
- *
- *   String sql = "select id, name from customer where name like :name and status_code = :status";
- *
- *   List<SqlRow> list =
- *     DB.sqlQuery(sql)
- *       .setParameter("name", "Acme%")
- *       .setParameter("status", "ACTIVE")
- *       .findList();
- *
- * }</pre>
- */
-@NonNullApi
-public interface SqlQuery extends Serializable, CancelableQuery {
-
-  /**
-   * 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>
-   */
-  @Nullable
-  SqlRow findOne();
-
-  /**
-   * Deprecated migrate to use {@link #mapTo(RowMapper)}
-   */
-  @Deprecated
-  <T> T findOne(RowMapper<T> mapper);
-
-  /**
-   * Deprecated migrate to use {@link #mapTo(RowMapper)}
-   */
-  @Deprecated
-  <T> List<T> findList(RowMapper<T> mapper);
-
-  /**
-   * Execute the query reading each row from ResultSet using the RowConsumer.
-   * <p>
-   * This provides a low level option that reads directly from the JDBC ResultSet
-   * and is good for processing very large results where (unlike findList) we don't
-   * hold all the results in memory but instead can process row by row.
-   * </p>
-   *
-   * <pre>{@code
-   *
-   *  String sql = "select id, name, status from customer order by name desc";
-   *
-   *  DB.sqlQuery(sql)
-   *    .findEachRow((resultSet, rowNum) -> {
-   *
-   *      // read directly from ResultSet
-   *
-   *      long id = resultSet.getLong(1);
-   *      String name = resultSet.getString(2);
-   *
-   *      // do something interesting with the data
-   *
-   *    });
-   *
-   * }</pre>
-   *
-   * @param consumer Used to read and process each ResultSet row.
-   */
-  void findEachRow(RowConsumer consumer);
-
-  /**
-   * Execute the query returning an optional row.
-   */
-  Optional<SqlRow> findOneOrEmpty();
-
-  /**
-   * Deprecated - migrate to <code>.mapToScalar(attributeType).findOne()</code>.
-   * <pre>{@code
-   *
-   *    .mapToScalar(BigDecimal.class)
-   *    .findOne();
-   * }
-   */
-  @Deprecated
-  <T> T findSingleAttribute(Class<T> attributeType);
-
-  /**
-   * Deprecated - migrate to <code>.mapToScalar(BigDecimal.class).findOne()</code>.
-   * <pre>{@code
-   *
-   *    .mapToScalar(BigDecimal.class)
-   *    .findOne();
-   * }
-   */
-  @Deprecated
-  BigDecimal findSingleDecimal();
-
-  /**
-   * Deprecated - migrate to <code>.mapToScalar(Long.class).findOne()</code>.
-   * <pre>{@code
-   *
-   *    .mapToScalar(Long.class)
-   *    .findOne();
-   * }
-   */
-  @Deprecated
-  Long findSingleLong();
-
-  /**
-   * Deprecated - migrate to <code>.mapToScalar(Long.class).findList()</code>.
-   * <pre>{@code
-   *
-   *    .mapToScalar(Long.class)
-   *    .findList();
-   * }
-   */
-  @Deprecated
-  <T> List<T> findSingleAttributeList(Class<T> attributeType);
-
-  /**
-   * Set one of more positioned parameters.
-   * <p>
-   * This is a convenient alternative to multiple calls to {@link #setParameter(Object)}.
-   *
-   * <pre>{@code
-   *
-   *   String sql = "select id, name from customer where name like ? and status = ?";
-   *
-   *   List<SqlRow> list =
-   *     DB.sqlQuery(sql)
-   *       .setParameters("Rob", Status.NEW)
-   *       .findList();
-   *
-   *
-   *   // effectively the same as ...
-   *
-   *       .setParameter("Rob")
-   *       .setParameter("Status.NEW)
-   *
-   *   // and ...
-   *
-   *       .setParameter(1, "Rob")
-   *       .setParameter(2, "Status.NEW)
-   *
-   * }</pre>
-   */
-  SqlQuery setParameters(Object... values);
-
-  /**
-   * Deprecated migrate to setParameters(Object... values)
-   */
-  @Deprecated
-  SqlQuery setParams(Object... values);
-
-  /**
-   * Set the next bind parameter by position.
-   * <pre>{@code
-   *
-   *   String sql = "select id, name from customer where name like ? and status = ?";
-   *
-   *   List<SqlRow> list =
-   *     DB.sqlQuery(sql)
-   *       .setParameter("Rob")
-   *       .setParameter("Status.NEW)
-   *       .findList();
-   *
-   *   // the same as ...
-   *
-   *       .setParameters("Rob", Status.NEW)
-   *
-   *   // and ...
-   *
-   *       .setParameter(1, "Rob")
-   *       .setParameter(2, "Status.NEW)
-   *
-   * }</pre>
-   *
-   * <p>
-   * When binding a collection of values into a IN expression we should use
-   * indexed parameters like ?1, ?2, ?3 etc rather than just ?.
-   * </p>
-   *
-   * <pre>{@code
-   *
-   *   String sql = "select c.id, c.name from customer c where c.name in (?1)";
-   *
-   *   List<SqlRow> rows = DB.sqlQuery(sql)
-   *       .setParameter(asList("Rob", "Fiona", "Jack"))
-   *       .findList();
-   *
-   *
-   *   List<SqlRow> rows = DB.sqlQuery(sql)
-   *       .setParameter(1, asList("Rob", "Fiona", "Jack"))
-   *       .findList();
-   * }</pre>
-   *
-   * @param value The value to bind
-   */
-  SqlQuery setParameter(Object value);
-
-  /**
-   * Set a null parameter by position.
-   */
-  SqlQuery setNullParameter(int position, int jdbcType);
-
-  /**
-   * Set a null parameter by name.
-   */
-  SqlQuery setNullParameter(String name, int jdbcType);
-
-  /**
-   * Bind the parameter by its index position (1 based like JDBC).
-   * <p>
-   * When binding a collection of values into a IN expression we should use
-   * indexed parameters like ?1, ?2, ?3 etc rather than just ?.
-   * </p>
-   *
-   * <pre>{@code
-   *
-   *   String sql = "select c.id, c.name from customer c where c.name in (?1)";
-   *
-   *   List<SqlRow> rows = DB.sqlQuery(sql)
-   *       .setParameter(asList("Rob", "Fiona", "Jack"))
-   *       .findList();
-   *
-   *
-   *   List<SqlRow> rows = DB.sqlQuery(sql)
-   *       .setParameter(1, asList("Rob", "Fiona", "Jack"))
-   *       .findList();
-   * }</pre>
-   */
-  SqlQuery setParameter(int position, Object value);
-
-  /**
-   * Bind the named parameter value.
-   */
-  SqlQuery setParameter(String name, 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);
-
-  /**
-   * Set a label that can be put on performance metrics that are collected.
-   */
-  SqlQuery setLabel(String label);
-
-  /**
-   * A hint which for JDBC translates to the Statement.fetchSize().
-   * <p>
-   * 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);
-
-  /**
-   * The query result maps to a single scalar value like Long, BigDecimal,
-   * String, UUID, OffsetDateTime etc.
-   * <p>
-   * Any scalar type Ebean is aware of can be used including java time
-   * types like Instant, LocalDate, OffsetDateTime, UUID, Inet, Cdir etc.
-   *
-   * <pre>{@code
-   *
-   *   String sql = " select min(updtime) from o_order_detail " +
-   *                " where unit_price > ? and updtime is not null ";
-   *
-   *   OffsetDateTime minCreated = DB.sqlQuery(sql)
-   *     .setParameter(42)
-   *     .mapToScalar(OffsetDateTime.class)
-   *     .findOne();
-   *
-   * }</pre>
-   *
-   * @param attributeType The type the result is returned as
-   * @return The query to execute via findOne() findList() etc
-   */
-  <T> TypeQuery<T> mapToScalar(Class<T> attributeType);
-
-  /**
-   * Use a RowMapper to map the result to beans.
-   *
-   * @param mapper Maps rows to beans
-   * @param <T>    The type of beans mapped to
-   * @return The query to execute by findOne() findList() etc
-   */
-  <T> TypeQuery<T> mapTo(RowMapper<T> mapper);
-
-  /**
-   * Query mapping to single scalar values.
-   *
-   * @param <T> The type of the scalar values
-   */
-  interface TypeQuery<T> {
-
-    /**
-     * Return the single value.
-     */
-    @Nullable
-    T findOne();
-
-    /**
-     * Return the single value that is optional.
-     */
-    Optional<T> findOneOrEmpty();
-
-    /**
-     * Return the list of values.
-     */
-    List<T> findList();
-
-    /**
-     * Find streaming the result effectively consuming a row at a time.
-     */
-    void findEach(Consumer<T> consumer);
-  }
-}

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

@@ -1,181 +0,0 @@
-package io.ebean;
-
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.sql.Date;
-import java.sql.Timestamp;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Used to return raw SQL query results.
- * <p>
- * Refer to {@link SqlQuery} for examples.
- * </p>
- * <p>
- * There are convenience methods such as getInteger(), getBigDecimal() etc. The
- * reason for these methods is that the values put into this map often come
- * straight from the JDBC resultSet. Depending on the JDBC driver it may put a
- * different type into a given property. For example an Integer, BigDecimal,
- * Double could all be put into a property depending on the JDBC driver used.
- * These convenience methods automatically convert the value as required
- * returning the type you expect.
- * </p>
- */
-public interface SqlRow extends Serializable, Map<String, Object> {
-
-  /**
-   * Return the property names (String).
-   * <p>
-   * Internally this uses LinkedHashMap and so the order of the property names
-   * should be predictable and ordered by the use of LinkedHashMap.
-   * </p>
-   */
-  Iterator<String> keys();
-
-  /**
-   * Remove a property from the map. Returns the value of the removed property.
-   */
-  @Override
-  Object remove(Object name);
-
-  /**
-   * Return a property value by its name.
-   */
-  @Override
-  Object get(Object name);
-
-  /**
-   * Set a value to a property.
-   */
-  @Override
-  Object put(String name, Object value);
-
-  /**
-   * Exactly the same as the put method.
-   * <p>
-   * I added this method because it seems more bean like to have get and set
-   * methods.
-   * </p>
-   */
-  Object set(String name, Object value);
-
-  /**
-   * Return a property as a Boolean.
-   */
-  Boolean getBoolean(String name);
-
-  /**
-   * Return a property as a UUID.
-   */
-  UUID getUUID(String name);
-
-  /**
-   * Return a property as an Integer.
-   */
-  Integer getInteger(String name);
-
-  /**
-   * Return a property value as a BigDecimal.
-   */
-  BigDecimal getBigDecimal(String name);
-
-  /**
-   * Return a property value as a Long.
-   */
-  Long getLong(String name);
-
-  /**
-   * Return the property value as a Double.
-   */
-  Double getDouble(String name);
-
-  /**
-   * Return the property value as a Float.
-   */
-  Float getFloat(String name);
-
-  /**
-   * Return a property as a String.
-   */
-  String getString(String name);
-
-  /**
-   * Return the property as a java.util.Date.
-   */
-  java.util.Date getUtilDate(String name);
-
-  /**
-   * Return the property as a sql date.
-   */
-  Date getDate(String name);
-
-  /**
-   * Return the property as a sql timestamp.
-   */
-  Timestamp getTimestamp(String name);
-
-  /**
-   * String description of the underlying map.
-   */
-  @Override
-  String toString();
-
-  /**
-   * Clear the map.
-   */
-  @Override
-  void clear();
-
-  /**
-   * Returns true if the map contains the property.
-   */
-  @Override
-  boolean containsKey(Object key);
-
-  /**
-   * Returns true if the map contains the value.
-   */
-  @Override
-  boolean containsValue(Object value);
-
-  /**
-   * Returns the entrySet of the map.
-   */
-  @Override
-  Set<Map.Entry<String, Object>> entrySet();
-
-  /**
-   * Returns true if the map is empty.
-   */
-  @Override
-  boolean isEmpty();
-
-  /**
-   * Returns the key set of the map.
-   */
-  @Override
-  Set<String> keySet();
-
-  /**
-   * Put all the values from t into this map.
-   */
-  @Override
-  void putAll(Map<? extends String, ?> t);
-
-  /**
-   * Return the size of the map.
-   */
-  @Override
-  int size();
-
-  /**
-   * Return the values from this map.
-   */
-  @Override
-  Collection<Object> values();
-
-}

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

@@ -1,347 +0,0 @@
-package io.ebean;
-
-import java.util.Collection;
-
-/**
- * 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>
- * 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>
- * 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.
- *
- * <h2>Positioned parameter example</h2>
- * <pre>{@code
- *
- *   // example using 'positioned' parameters
- *
- *   String sql = "insert into audit_log (group, title, description) values (?, ?, ?);
- *
- *   int rows =
- *     DB.sqlUpdate(sql)
- *       .setParams("login", "new user", "user rob was created")
- *       .executeNow();
- *
- * }</pre>
- *
- * <h2>Named parameter example</h2>
- * <pre>{@code
- *
- *   // example using 'named' parameters
- *
- *   String sql = "update topic set post_count = :count where id = :id";
- *
- *   int rows =
- *     DB.sqlUpdate(sql)
- *       .setParameter("id", 1)
- *       .setParameter("count", 50)
- *       .execute();
- *
- *   String msg = "There were " + rows + " rows updated";
- *
- * }</pre>
- *
- * <h2>Index parameter examples (e.g. ?1, ?2, ?3 ...)</h2>
- * <p>
- * We can use index parameters like ?1, ?2, ?3 etc when binding arrays/collections
- * of values into an IN expression.
- * </p>
- * <pre>{@code
- *
- *   // Binding a list of 3 values (9991, 9992, 9993) into an IN expression
- *
- *   DB.sqlUpdate("delete from o_customer where name = ? and id in (?2)")
- *     .setParameter(1, "Foo")
- *     .setParameter(2, asList(9991, 9992, 9993))
- *     .execute();
- *
- *   // note this effectively is the same as
- *
- *   DB.sqlUpdate("delete from o_customer where name = ? and id in (?2)")
- *     .setParameter("Foo")
- *     .setParameter(asList(9991, 9992, 9993))
- *     .execute();
- *
- * }</pre>
- *
- * <h3>Example: Using setParameter()</h3>
- * <pre>{@code
- *
- *  String sql = "insert into audit_log (id, description, modified_description) values (?,?,?)";
- *
- *  SqlUpdate insert = DB.sqlUpdate(sql);
- *
- *  try (Transaction txn = DB.beginTransaction()) {
- *    txn.setBatchMode(true);
- *
- *    insert.setParameter(10000);
- *    insert.setParameter("hello");
- *    insert.setParameter("rob");
- *    insert.execute();
- *
- *    insert.setParameter(10001);
- *    insert.setParameter("goodbye");
- *    insert.setParameter("rob");
- *    insert.execute();
- *
- *    insert.setParameter(10002);
- *    insert.setParameter("chow");
- *    insert.setParameter("bob");
- *    insert.execute();
- *
- *    txn.commit();
- *  }
- * }</pre>
- * <p>
- * An alternative to the batch mode on the transaction is to use addBatch() and executeBatch() like:
- * </p>
- * <pre>{@code
- *
- *   try (Transaction txn = DB.beginTransaction()) {
- *
- *     insert.setParameter(10000);
- *     insert.setParameter("hello");
- *     insert.setParameter("rob");
- *     insert.addBatch();
- *
- *     insert.setParameter(10001);
- *     insert.setParameter("goodbye");
- *     insert.setParameter("rob");
- *     insert.addBatch();
- *
- *     insert.setParameter(10002);
- *     insert.setParameter("chow");
- *     insert.setParameter("bob");
- *     insert.addBatch();
- *
- *     int[] rows = insert.executeBatch();
- *
- *     txn.commit();
- *   }
- *
- * }</pre>
- *
- * @see Update
- * @see SqlQuery
- * @see CallableSql
- */
-public interface SqlUpdate {
-
-  /**
-   * Execute the update returning the number of rows modified.
-   * <p>
-   * Note that if the transaction has batch mode on then this update will use JDBC batch and may not execute until
-   * later - at commit time or a transaction flush. In this case this method returns -1 indicating that the
-   * update has been batched for later execution.
-   * </p>
-   * <p>
-   * After you have executed the SqlUpdate you can bind new variables using
-   * {@link #setParameter(String, Object)} etc and then execute the SqlUpdate
-   * again.
-   * </p>
-   * <p>
-   * For JDBC batch processing refer to
-   * {@link Transaction#setBatchMode(boolean)} and
-   * {@link Transaction#setBatchSize(int)}.
-   * </p>
-   */
-  int execute();
-
-  /**
-   * Execute the statement now regardless of the JDBC batch mode of the transaction.
-   */
-  int executeNow();
-
-  /**
-   * Execute when addBatch() has been used to batch multiple bind executions.
-   *
-   * @return The row counts for each of the batched statements.
-   */
-  int[] executeBatch();
-
-  /**
-   * Add the statement to batch processing to then later execute via executeBatch().
-   */
-  void addBatch();
-
-  /**
-   * Return the generated key value.
-   */
-  Object getGeneratedKey();
-
-  /**
-   * Execute and return the generated key. This is effectively a short cut for:
-   * <p>
-   * <pre>{@code
-   *
-   *   sqlUpdate.execute();
-   *   Object key = sqlUpdate.getGeneratedKey();
-   *
-   * }</pre>
-   *
-   * @return The generated key value
-   */
-  Object executeGetKey();
-
-  /**
-   * Return true if eBean should automatically deduce the table modification
-   * information and process it.
-   * <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);
-
-  /**
-   * Set to true when we want to use getGeneratedKeys with this statement.
-   */
-  SqlUpdate setGetGeneratedKeys(boolean getGeneratedKeys);
-
-  /**
-   * 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 one of more positioned parameters.
-   * <p>
-   * This is a convenient alternative to multiple setParameter() calls.
-   *
-   * <pre>{@code
-   *
-   *   String sql = "insert into audit_log (id, name, version) values (?,?,?)";
-   *
-   *   DB.sqlUpdate(sql)
-   *       .setParameters(UUID.randomUUID(), "Hello", 1)
-   *       .executeNow();
-   *
-   *
-   *   // is the same as ...
-   *
-   *   DB.sqlUpdate(sql)
-   *       .setParameter(UUID.randomUUID())
-   *       .setParameter("Hello")
-   *       .setParameter(1)
-   *       .executeNow();
-   *
-   *   // which is the same as ...
-   *
-   *   DB.sqlUpdate(sql)
-   *       .setParameter(1, UUID.randomUUID())
-   *       .setParameter(2, "Hello")
-   *       .setParameter(3, 1)
-   *       .executeNow();
-   *
-   * }</pre>
-   */
-  SqlUpdate setParameters(Object... values);
-
-  /**
-   * Deprecated migrate to setParameters(Object... values).
-   */
-  @Deprecated
-  SqlUpdate setParams(Object... values);
-
-  /**
-   * Set the next bind parameter by position.
-   *
-   * @param value The value to bind
-   */
-  SqlUpdate setParameter(Object value);
-
-  /**
-   * Deprecated migrate to setParameter(value).
-   */
-  @Deprecated
-  SqlUpdate setNextParameter(Object value);
-
-  /**
-   * 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);
-
-  /**
-   * Bind the named multi-value array parameter which we would use with Postgres ANY.
-   * <p>
-   * For Postgres this binds an ARRAY rather than expands into multiple bind values.
-   */
-  SqlUpdate setArrayParameter(String name, Collection<?> values);
-
-  /**
-   * 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);
-
-}

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

@@ -1,577 +0,0 @@
-package io.ebean;
-
-import io.ebean.annotation.DocStoreMode;
-import io.ebean.annotation.PersistBatch;
-import io.ebean.config.DatabaseConfig;
-import io.ebean.config.DocStoreConfig;
-
-import javax.persistence.PersistenceException;
-import java.sql.Connection;
-
-/**
- * The Transaction object. Typically representing a JDBC or JTA transaction.
- */
-public interface Transaction extends AutoCloseable {
-
-  /**
-   * Return the current transaction (of the default database) or null if there is
-   * no current transaction in scope.
-   * <p>
-   * This is the same as <code>DB.currentTransaction()</code>
-   * </p>
-   * <p>
-   * This returns the current transaction for the default database.
-   * </p>
-   *
-   * @see DB#currentTransaction()
-   * @see Database#currentTransaction()
-   */
-  static Transaction current() {
-    return DB.currentTransaction();
-  }
-
-  /**
-   * Read Committed transaction isolation. Same as
-   * java.sql.Connection.TRANSACTION_READ_COMMITTED.
-   */
-  int READ_COMMITTED = java.sql.Connection.TRANSACTION_READ_COMMITTED;
-
-  /**
-   * Read Uncommitted transaction isolation. Same as
-   * java.sql.Connection.TRANSACTION_READ_UNCOMMITTED.
-   */
-  int READ_UNCOMMITTED = java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
-
-  /**
-   * Repeatable read transaction isolation. Same as
-   * java.sql.Connection.TRANSACTION_REPEATABLE_READ.
-   */
-  int REPEATABLE_READ = java.sql.Connection.TRANSACTION_REPEATABLE_READ;
-
-  /**
-   * Serializable transaction isolation. Same as
-   * java.sql.Connection.TRANSACTION_SERIALIZABLE.
-   */
-  int SERIALIZABLE = java.sql.Connection.TRANSACTION_SERIALIZABLE;
-
-  /**
-   * Register a TransactionCallback with this transaction.
-   */
-  void register(TransactionCallback callback);
-
-  /**
-   * EXPERIMENTAL - turn on automatic persistence of dirty beans and batchMode true.
-   * <p>
-   * With this turned on beans that are dirty in the persistence context
-   * are automatically persisted on flush() and commit().
-   */
-  void setAutoPersistUpdates(boolean autoPersistUpdates);
-
-  /**
-   * Set a label on the transaction.
-   * <p>
-   * This label is used to group transaction execution times for performance metrics reporting.
-   * </p>
-   */
-  void setLabel(String label);
-
-  /**
-   * Return true if this transaction is read only.
-   */
-  boolean isReadOnly();
-
-  /**
-   * Set whether this transaction should be readOnly.
-   */
-  void setReadOnly(boolean readOnly);
-
-  /**
-   * Commits the transaction at this point with the expectation that another
-   * commit (or rollback or end) will occur later to complete the transaction.
-   * <p>
-   * This is similar to commit() but leaves the transaction "Active".
-   * </p>
-   * <h3>Functions</h3>
-   * <ul>
-   * <li>Flush the JDBC batch buffer</li>
-   * <li>Call commit on the underlying JDBC connection</li>
-   * <li>Trigger any registered TransactionCallbacks</li>
-   * <li>Perform post-commit processing updating L2 cache, ElasticSearch etc</li>
-   * </ul>
-   */
-  void commitAndContinue();
-
-  /**
-   * Commit the transaction.
-   * <p>
-   * This performs commit and completes the transaction closing underlying resources and
-   * marking the transaction as "In active".
-   * </p>
-   * <h3>Functions</h3>
-   * <ul>
-   * <li>Flush the JDBC batch buffer</li>
-   * <li>Call commit on the underlying JDBC connection</li>
-   * <li>Trigger any registered TransactionCallbacks</li>
-   * <li>Perform post-commit processing updating L2 cache, ElasticSearch etc</li>
-   * <li>Close any underlying resources, closing the underlying JDBC connection</li>
-   * <li>Mark the transaction as "Inactive"</li>
-   * </ul>
-   */
-  void commit();
-
-  /**
-   * Rollback the transaction.
-   * <p>
-   * This performs rollback, closes underlying resources and marks the transaction as "In active".
-   * </p>
-   * <h3>Functions</h3>
-   * <ul>
-   * <li>Call rollback on the underlying JDBC connection</li>
-   * <li>Trigger any registered TransactionCallbacks</li>
-   * <li>Close any underlying resources, closing the underlying JDBC connection</li>
-   * <li>Mark the transaction as "Inactive"</li>
-   * </ul>
-   */
-  void rollback() throws PersistenceException;
-
-  /**
-   * Rollback the transaction specifying a throwable that caused the rollback to
-   * occur.
-   * <p>
-   * If you are using transaction logging this will log the throwable in the
-   * transaction logs.
-   * </p>
-   */
-  void rollback(Throwable e) throws PersistenceException;
-
-  /**
-   * Set when we want nested transactions to use Savepoint's.
-   * <p>
-   * This means that for a nested transaction:
-   * <ul>
-   * <li>begin transaction maps to creating a savepoint</li>
-   * <li>commit transaction maps to releasing a savepoint</li>
-   * <li>rollback transaction maps to rollback a savepoint</li>
-   * </ul>
-   */
-  void setNestedUseSavepoint();
-
-  /**
-   * Mark the transaction for rollback only.
-   */
-  void setRollbackOnly();
-
-  /**
-   * Return true if the transaction is marked as rollback only.
-   */
-  boolean isRollbackOnly();
-
-  /**
-   * If the transaction is active then perform rollback. Otherwise do nothing.
-   */
-  void end();
-
-  /**
-   * Synonym for end() to support AutoClosable.
-   */
-  @Override
-  void close();
-
-  /**
-   * Return true if the transaction is active.
-   */
-  boolean isActive();
-
-  /**
-   * Set the behavior for document store updates on this transaction.
-   * <p>
-   * For example, set the mode to DocStoreEvent.IGNORE for this transaction and
-   * then any changes via this transaction are not sent to the doc store. This
-   * would be used when doing large bulk inserts into the database and we want
-   * to control how that is sent to the document store.
-   * </p>
-   */
-  void setDocStoreMode(DocStoreMode mode);
-
-  /**
-   * Set the batch size to use for sending messages to the document store.
-   * <p>
-   * You might set this if you know the changes in this transaction result in especially large or
-   * especially small payloads and want to adjust the batch size to match.
-   * </p>
-   * <p>
-   * Setting this overrides the default of {@link DocStoreConfig#getBulkBatchSize()}
-   * </p>
-   */
-  void setDocStoreBatchSize(int batchSize);
-
-  /**
-   * Explicitly turn off or on the cascading nature of save() and delete(). This
-   * gives the developer exact control over what beans are saved and deleted
-   * rather than Ebean cascading detecting 'dirty/modified' beans etc.
-   * <p>
-   * This is useful if you can getting back entity beans from a layer of code
-   * (potentially remote) and you prefer to have exact control.
-   * </p>
-   * <p>
-   * This may also be useful if you are using jdbc batching with jdbc drivers
-   * that do not support getGeneratedKeys.
-   * </p>
-   */
-  void setPersistCascade(boolean persistCascade);
-
-  /**
-   * Set to true when you want all loaded properties to be included in the update
-   * (rather than just the changed properties).
-   * <p>
-   * You might set this when using JDBC batch in order to get multiple updates
-   * with slightly different sets of changed properties into the same statement
-   * and hence better JDBC batch performance.
-   * </p>
-   */
-  void setUpdateAllLoadedProperties(boolean updateAllLoadedProperties);
-
-  /**
-   * Set if the L2 cache should be skipped for "find by id" and "find by natural key" queries.
-   * <p>
-   * By default {@link DatabaseConfig#isSkipCacheAfterWrite()} is true and that means that for
-   * "find by id" and "find by natural key" queries which normally hit L2 bean cache automatically
-   * - will not do so after a persist/write on the transaction.
-   * </p>
-   * <p>
-   * This method provides explicit control over whether "find by id" and "find by natural key"
-   * will skip the L2 bean cache or not (regardless of whether the transaction is considered "read only").
-   * </p>
-   * <p>
-   * Refer to {@link DatabaseConfig#setSkipCacheAfterWrite(boolean)} for configuring the default behavior
-   * for using the L2 bean cache in transactions spanning multiple query/persist requests.
-   * </p>
-   *
-   * <pre>{@code
-   *
-   *   // assume Customer has L2 bean caching enabled ...
-   *
-   *   try (Transaction transaction = DB.beginTransaction()) {
-   *
-   *     // this uses L2 bean cache as the transaction
-   *     // ... is considered "query only" at this point
-   *     Customer.find.byId(42);
-   *
-   *     // transaction no longer "query only" once
-   *     // ... a bean has been saved etc
-   *     someBean.save();
-   *
-   *     // will NOT use L2 bean cache as the transaction
-   *     // ... is no longer considered "query only"
-   *     Customer.find.byId(55);
-   *
-   *
-   *
-   *     // explicit control - please use L2 bean cache
-   *
-   *     transaction.setSkipCache(false);
-   *     Customer.find.byId(77); // hit the l2 bean cache
-   *
-   *
-   *     // explicit control - please don't use L2 bean cache
-   *
-   *     transaction.setSkipCache(true);
-   *     Customer.find.byId(99); // skips l2 bean cache
-   *
-   *
-   *     transaction.commit();
-   *   }
-   *
-   * }</pre>
-   *
-   * @see DatabaseConfig#isSkipCacheAfterWrite()
-   */
-  void setSkipCache(boolean skipCache);
-
-  /**
-   * Return true if the L2 cache should be skipped. More accurately if true then find by id
-   * and find by natural key queries should NOT automatically use the L2 bean cache.
-   */
-  boolean isSkipCache();
-
-  /**
-   * Turn on or off use of JDBC statement batching.
-   * <p>
-   * Calls to save(), delete(), insert() and execute() all support batch
-   * processing. This includes normal beans, CallableSql and UpdateSql.
-   * </p>
-   *
-   * <pre>{@code
-   *
-   * try (Transaction transaction = database.beginTransaction()) {
-   *
-   *   // turn on JDBC batch
-   *   transaction.setBatchMode(true);
-   *
-   *   // tune the batch size
-   *   transaction.setBatchSize(50);
-   *
-   *   ...
-   *
-   *   transaction.commit();
-   * }
-   *
-   * }</pre>
-   *
-   * <h3>getGeneratedKeys</h3>
-   * <p>
-   * Often with large batch inserts we want to turn off getGeneratedKeys. We do
-   * this via {@link #setGetGeneratedKeys(boolean)}.
-   * Also note that some JDBC drivers do not support getGeneratedKeys in JDBC batch mode.
-   * </p>
-   * <pre>{@code
-   *
-   * try (Transaction transaction = database.beginTransaction()) {
-   *
-   *   transaction.setBatchMode(true);
-   *   transaction.setBatchSize(100);
-   *   // insert but don't bother getting back the generated keys
-   *   transaction.setBatchGetGeneratedKeys(false);
-   *
-   *
-   *   // perform lots of inserts ...
-   *   ...
-   *
-   *   transaction.commit();
-   * }
-   *
-   * }</pre>
-   *
-   * <h3>Flush</h3>
-   * <p>
-   * The batch is automatically flushed when it hits the batch size and also when we
-   * execute queries or when we mix UpdateSql and CallableSql with save and delete of
-   * beans.
-   * <p>
-   * We use {@link #flush()} to explicitly flush the batch and we can use
-   * {@link #setFlushOnQuery(boolean)} and {@link #setFlushOnMixed(boolean)}
-   * to control the automatic flushing behaviour.
-   * <p>
-   * Example: batch processing of CallableSql executing every 10 rows
-   *
-   * <pre>{@code
-   *
-   * String data = "This is a simple test of the batch processing"
-   *             + " mode and the transaction execute batch method";
-   *
-   * String[] da = data.split(" ");
-   *
-   * String sql = "{call sp_t3(?,?)}";
-   *
-   * CallableSql cs = new CallableSql(sql);
-   * cs.registerOut(2, Types.INTEGER);
-   *
-   * // (optional) inform Ebean this stored procedure
-   * // inserts into a table called sp_test
-   * cs.addModification("sp_test", true, false, false);
-   *
-   * try (Transaction txn = DB.beginTransaction()) {
-   *   txn.setBatchMode(true);
-   *   txn.setBatchSize(10);
-   *
-   *   for (int i = 0; i < da.length;) {
-   *     cs.setParameter(1, da[i]);
-   *     DB.execute(cs);
-   *   }
-   *
-   *   // Note: commit implicitly flushes
-   *   txn.commit();
-   * }
-   *
-   * }</pre>
-   */
-  void setBatchMode(boolean useBatch);
-
-  /**
-   * Return the batch mode at the transaction level.
-   */
-  boolean isBatchMode();
-
-  /**
-   * Set the JDBC batch mode to use for a save() or delete() when cascading to children.
-   * <p>
-   * This only takes effect when batch mode on the transaction has not already meant that
-   * JDBC batch mode is being used.
-   * <p>
-   * This is useful when the single save() or delete() cascades. For example, inserting a 'master' cascades
-   * and inserts a collection of 'detail' beans. The detail beans can be inserted using JDBC batch.
-   * <p>
-   * This is effectively already turned on for all platforms apart from older Sql Server.
-   *
-   * @param batchMode the batch mode to use per save(), insert(), update() or delete()
-   * @see io.ebean.config.DatabaseConfig#setPersistBatchOnCascade(PersistBatch)
-   */
-  void setBatchOnCascade(boolean batchMode);
-
-  /**
-   * Return the batch mode at the request level.
-   */
-  boolean isBatchOnCascade();
-
-  /**
-   * Specify the number of statements before a batch is flushed automatically.
-   */
-  void setBatchSize(int batchSize);
-
-  /**
-   * Return the current batch size.
-   */
-  int getBatchSize();
-
-  /**
-   * Specify if we want batched inserts to use getGeneratedKeys.
-   * <p>
-   * By default batched inserts will try to use getGeneratedKeys if it is
-   * supported by the underlying jdbc driver and database.
-   * <p>
-   * We want to turn off getGeneratedKeys when we are inserting a large
-   * number of objects and we don't care about getting back the ids. In this
-   * way we avoid the extra cost of getting back the generated id values
-   * from the database.
-   * <p>
-   * Note that when we do turn off getGeneratedKeys then we have the limitation
-   * that after a bean has been inserted we are unable to then mutate the bean
-   * and update it in the same transaction as we have not obtained it's id value.
-   */
-  void setGetGeneratedKeys(boolean getGeneratedKeys);
-
-  /**
-   * Deprecated renamed to setGetGeneratedKeys().
-   */
-  @Deprecated
-  default void setBatchGetGeneratedKeys(boolean getGeneratedKeys) {
-    setGetGeneratedKeys(getGeneratedKeys);
-  }
-
-  /**
-   * By default when mixing UpdateSql (or CallableSql) with Beans the batch is
-   * automatically flushed when you change (between persisting beans and
-   * executing UpdateSql or CallableSql).
-   * <p>
-   * If you want to execute both WITHOUT having the batch automatically flush
-   * you need to call this with batchFlushOnMixed = false.
-   * <p>
-   * Note that UpdateSql and CallableSql are ALWAYS executed first (before the
-   * beans are executed). This is because the UpdateSql and CallableSql have
-   * already been bound to their PreparedStatements. The beans on the other hand
-   * have a 2 step process (delayed binding).
-   */
-  void setFlushOnMixed(boolean batchFlushOnMixed);
-
-  /**
-   * Deprecated renamed to setFlushOnMixed().
-   */
-  @Deprecated
-  default void setBatchFlushOnMixed(boolean batchFlushOnMixed) {
-    setFlushOnMixed(batchFlushOnMixed);
-  }
-
-  /**
-   * By default executing a query will automatically flush any batched
-   * statements (persisted beans, executed UpdateSql etc).
-   * <p>
-   * Calling this method with batchFlushOnQuery = false means that you can
-   * execute a query and the batch will not be automatically flushed.
-   */
-  void setFlushOnQuery(boolean batchFlushOnQuery);
-
-  /**
-   * Deprecated renamed to setFlushOnQuery().
-   */
-  @Deprecated
-  default void setBatchFlushOnQuery(boolean batchFlushOnQuery) {
-    setFlushOnQuery(batchFlushOnQuery);
-  }
-
-  /**
-   * Return true if the batch (of persisted beans or executed UpdateSql etc)
-   * should be flushed prior to executing a query.
-   * <p>
-   * The default is for this to be true.
-   */
-  boolean isFlushOnQuery();
-
-  /**
-   * Deprecated renamed to isFlushOnQuery().
-   */
-  @Deprecated
-  default boolean isBatchFlushOnQuery() {
-    return isFlushOnQuery();
-  }
-
-  /**
-   * The batch will be flushing automatically but you can use this to explicitly
-   * flush the batch if you like.
-   * <p>
-   * Flushing occurs automatically when:
-   * <ul>
-   * <li>the batch size is reached</li>
-   * <li>A query is executed on the same transaction</li>
-   * <li>UpdateSql or CallableSql are mixed with bean save and delete</li>
-   * <li>Transaction commit occurs</li>
-   * <li>A getter method is called on a batched bean</li>
-   * </ul>
-   */
-  void flush() throws PersistenceException;
-
-  /**
-   * Deprecated - migrate to flush().
-   * <p>
-   * flush() is preferred as it matches the JPA flush() method.
-   */
-  @Deprecated
-  void flushBatch() throws PersistenceException;
-
-  /**
-   * Return the underlying Connection object.
-   * <p>
-   * Useful where a Developer wishes to use the JDBC API directly. Note that the
-   * commit() rollback() and end() methods on the Transaction should still be
-   * used. Calling these methods on the Connection would be a big no no unless
-   * you know what you are doing.
-   * <p>
-   * Examples of when a developer may wish to use the connection directly are:
-   * Savepoints, advanced CLOB BLOB use and advanced stored procedure calls.
-   */
-  Connection connection();
-
-  /**
-   * Deprecated migrate to connection().
-   */
-  @Deprecated
-  default Connection getConnection() {
-    return connection();
-  }
-
-  /**
-   * Add table modification information to the TransactionEvent.
-   * <p>
-   * Use this in conjunction with getConnection() and raw JDBC.
-   * <p>
-   * This effectively informs Ebean of the data that has been changed by the
-   * transaction and this information is normally automatically handled by Ebean
-   * when you save entity beans or use UpdateSql etc.
-   * <p>
-   * If you use raw JDBC then you can use this method to inform Ebean for the
-   * tables that have been modified. Ebean uses this information to keep its
-   * caches in synch and maintain text indexes.
-   */
-  void addModification(String tableName, boolean inserts, boolean updates, boolean deletes);
-
-  /**
-   * Add an arbitrary user object to the transaction. The objects added have no
-   * impact on any internals of ebean and are solely meant as a convenient
-   * method push user information (although somewhat replaced by TransactionCallback).
-   */
-  void putUserObject(String name, Object value);
-
-  /**
-   * Get an object added with {@link #putUserObject(String, Object)}.
-   */
-  Object getUserObject(String name);
-}

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

@@ -1,34 +0,0 @@
-package io.ebean;
-
-/**
- * Provides a callback that can be registered with a Transaction.
- * <p/>
- * The callback methods are called just prior to and after the transaction performs a commit or rollback.
- * <p/>
- * A typical use of TransactionCallback would be to clean up non-transactional resources like files. For example,
- * when processing files on postCommit/postRollback clean up the associated files. As another example when
- * on postCommit of a delete remove associated resources from the file system or remote service.
- */
-public interface TransactionCallback {
-
-  /**
-   * Perform processing just prior to the transaction commit.
-   */
-  void preCommit();
-
-  /**
-   * Perform processing just after the transaction commit.
-   */
-  void postCommit();
-
-  /**
-   * Perform processing just prior to the transaction rollback.
-   */
-  void preRollback();
-
-  /**
-   * Perform processing just after the transaction rollback.
-   */
-  void postRollback();
-
-}

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

@@ -1,42 +0,0 @@
-package io.ebean;
-
-/**
- * Adapter that can be extended for easier implementation of TransactionCallback.
- * <p/>
- * Provides 'no operation' implementation for each of the TransactionCallback methods. It is expected that this
- * class is extended and override the methods you need to.
- */
-public abstract class TransactionCallbackAdapter implements TransactionCallback {
-
-  /**
-   * Perform processing just prior to the transaction commit.
-   */
-  @Override
-  public void preCommit() {
-    // do nothing - override as necessary
-  }
-
-  /**
-   * Perform processing just after the transaction commit.
-   */
-  @Override
-  public void postCommit() {
-    // do nothing - override as necessary
-  }
-
-  /**
-   * Perform processing just prior to the transaction rollback.
-   */
-  @Override
-  public void preRollback() {
-    // do nothing - override as necessary
-  }
-
-  /**
-   * Perform processing just after the transaction rollback.
-   */
-  @Override
-  public void postRollback() {
-    // do nothing - override as necessary
-  }
-}

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

@@ -1,460 +0,0 @@
-package io.ebean;
-
-import io.ebean.annotation.PersistBatch;
-import io.ebean.annotation.TxIsolation;
-import io.ebean.annotation.TxOption;
-import io.ebean.annotation.TxType;
-
-import java.util.ArrayList;
-import java.util.concurrent.Callable;
-
-/**
- * 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 Runnable or Callable via
- * {@link DB#execute(TxScope, Runnable)} or
- * {@link DB#executeCall(TxScope, Callable)}.
- * </p>
- * <p>
- * This object is used internally with the enhancement of a method with
- * Transactional annotation.
- * </p>
- *
- * @see DB#execute(TxScope, Runnable)
- * @see DB#executeCall(TxScope, Callable)
- */
-public final class TxScope {
-
-  private int profileId;
-
-  private TxType type;
-
-  private String serverName;
-
-  private TxIsolation isolation;
-
-  private TxOption autoPersistUpdates;
-
-  private PersistBatch batch;
-
-  private PersistBatch batchOnCascade;
-
-  private int batchSize;
-
-  private boolean skipGeneratedKeys;
-
-  private boolean readOnly;
-
-  /**
-   * Set this to false if the JDBC batch should not be automatically be flushed when a query is executed.
-   */
-  private boolean flushOnQuery = true;
-
-  private boolean skipCache;
-
-  private String label;
-
-  private ArrayList<Class<? extends Throwable>> rollbackFor;
-
-  private ArrayList<Class<? extends Throwable>> noRollbackFor;
-
-  private ProfileLocation profileLocation;
-
-  /**
-   * 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.
-   */
-  @Override
-  public String toString() {
-    return "TxScope[" + type + "] readOnly[" + readOnly + "] isolation[" + isolation
-      + "] serverName[" + serverName + "] rollbackFor[" + rollbackFor + "] noRollbackFor[" + noRollbackFor + "]";
-  }
-
-  /**
-   * Return the AutoPersistUpdates mode as a nullable Boolean.
-   */
-  public Boolean getAutoPersistUpdates() {
-    return autoPersistUpdates == null ? null : autoPersistUpdates.asBoolean();
-  }
-
-  /**
-   * 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;
-  }
-
-  /**
-   * Set the autoPersistUpdates mode.
-   */
-  public TxScope setAutoPersistUpdates(TxOption autoPersistUpdates) {
-    this.autoPersistUpdates = autoPersistUpdates;
-    return this;
-  }
-
-  /**
-   * Return the transaction profile id.
-   */
-  public int getProfileId() {
-    return profileId;
-  }
-
-  /**
-   * Set the transaction profile id.
-   */
-  public TxScope setProfileId(int profileId) {
-    this.profileId = profileId;
-    return this;
-  }
-
-  /**
-   * Return the profile location.
-   */
-  public ProfileLocation getProfileLocation() {
-    return profileLocation;
-  }
-
-  /**
-   * Set the profile location.
-   */
-  public TxScope setProfileLocation(ProfileLocation profileLocation) {
-    this.profileLocation = profileLocation;
-    return this;
-  }
-
-  /**
-   * Return true if the L2 cache should be skipped for this transaction.
-   */
-  public boolean isSkipCache() {
-    return skipCache;
-  }
-
-  /**
-   * Set to true if the transaction should skip L2 cache access.
-   */
-  public TxScope setSkipCache(boolean skipCache) {
-    this.skipCache = skipCache;
-    return this;
-  }
-
-  /**
-   * Return the label for the transaction.
-   */
-  public String getLabel() {
-    return label;
-  }
-
-  /**
-   * Set a label for the transaction.
-   */
-  public TxScope setLabel(String label) {
-    this.label = label;
-    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 false if the JDBC batch buffer should not be flushed automatically when a query is executed.
-   */
-  public boolean isFlushOnQuery() {
-    return flushOnQuery;
-  }
-
-  /**
-   * Set flushOnQuery to be false to stop automatically flushing the JDBC batch buffer when a query is executed.
-   */
-  public TxScope setFlushOnQuery(boolean flushOnQuery) {
-    this.flushOnQuery = flushOnQuery;
-    return this;
-  }
-
-  /**
-   * Return the isolation level.
-   */
-  public int getIsolationLevel() {
-    return isolation != null ? isolation.getLevel() : -1;
-  }
-
-  /**
-   * 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;
-  }
-
-  public boolean isBatchMode() {
-    return PersistBatch.ALL.equals(batch);
-  }
-
-  public boolean isBatchOnCascade() {
-    return PersistBatch.ALL.equals(batchOnCascade);
-  }
-}

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

@@ -1,166 +0,0 @@
-package io.ebean;
-
-/**
- * An Insert Update or Delete statement.
- * <p>
- * Generally a named update will be defined on the entity bean. This will take
- * the form of either an actual sql insert update delete statement or a similar
- * statement with bean name and property names in place of database table and
- * column names. The statement will likely include named parameters.
- * </p>
- * <p>
- * The following is an example of named updates on an entity bean.
- * </p>
- * <pre>{@code
- *    ...
- *   @NamedUpdates(value = {
- *     @NamedUpdate(
- *       name = "setTitle",
- *       notifyCache = false,
- *       update = "update topic set title = :title, postCount = :count where id = :id"),
- *    @NamedUpdate(
- *       name = "setPostCount",
- *       notifyCache = false,
- *       update = "update f_topic set post_count = :postCount where id = :id"),
- *    @NamedUpdate(
- *       name = "incrementPostCount",
- *       notifyCache = false,
- *       update = "update Topic set postCount = postCount + 1 where id = :id")
- *       //update = "update f_topic set post_count = post_count + 1 where id = :id")
- *   })
- *   @Entity
- *   @Table(name = "f_topic")
- *   public class Topic {
- *     ...
- *   }
- * }</pre>
- *
- * <p>
- * The following show code that would use a named update on the Topic entity
- * bean.
- * </p>
- * <p>
- * <pre>{@code
- *
- * Update<Topic> update = DB.createUpdate(Topic.class, "incrementPostCount");
- * update.setParameter("id", 1);
- * int rows = update.execute();
- *
- * }</pre>
- *
- * @param <T> the type of entity beans inserted updated or deleted
- */
-public interface Update<T> {
-
-  /**
-   * Return the name if it is a named update.
-   */
-  String getName();
-
-  /**
-   * Set this to false if you do not want the cache to invalidate related
-   * objects.
-   * <p>
-   * If you don't set this Ebean will automatically invalidate the appropriate
-   * parts of the "L2" server cache.
-   * </p>
-   */
-  Update<T> setNotifyCache(boolean notifyCache);
-
-  /**
-   * Set a timeout for statement execution.
-   * <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 timeout in seconds. Zero implies unlimited.
-   */
-  Update<T> setTimeout(int secs);
-
-  /**
-   * Execute the statement returning the number of rows modified.
-   */
-  int execute();
-
-  /**
-   * Set an ordered bind parameter.
-   * <p>
-   * position starts at value 1 (not 0) to be consistent with PreparedStatement.
-   * </p>
-   * <p>
-   * Set a value for each ? you have in the sql.
-   * </p>
-   *
-   * @param position the index position of the parameter starting with 1.
-   * @param value    the parameter value to bind.
-   */
-  Update<T> set(int position, Object value);
-
-  /**
-   * Set and ordered bind parameter (same as bind).
-   *
-   * @param position the index position of the parameter starting with 1.
-   * @param value    the parameter value to bind.
-   */
-  Update<T> setParameter(int position, Object value);
-
-  /**
-   * Set an ordered parameter that is null. The JDBC type of the null must be
-   * specified.
-   * <p>
-   * position starts at value 1 (not 0) to be consistent with PreparedStatement.
-   * </p>
-   */
-  Update<T> setNull(int position, int jdbcType);
-
-  /**
-   * Set an ordered parameter that is null (same as bind).
-   */
-  Update<T> setNullParameter(int position, int jdbcType);
-
-  /**
-   * Set a named parameter. Named parameters have a colon to prefix the name.
-   * <p>
-   * A more succinct version of setParameter() to be consistent with Query.
-   * </p>
-   *
-   * @param name  the parameter name.
-   * @param value the parameter value.
-   */
-  Update<T> set(String name, Object value);
-
-  /**
-   * Bind a named parameter (same as bind).
-   */
-  Update<T> setParameter(String name, Object param);
-
-  /**
-   * Set a named parameter that is null. The JDBC type of the null must be
-   * specified.
-   * <p>
-   * A more succinct version of setNullParameter().
-   * </p>
-   *
-   * @param name     the parameter name.
-   * @param jdbcType the type of the property being bound.
-   */
-  Update<T> setNull(String name, int jdbcType);
-
-  /**
-   * Bind a named parameter that is null (same as bind).
-   */
-  Update<T> setNullParameter(String name, int jdbcType);
-
-  /**
-   * Set a label meaning performance metrics will be collected for the execution of this update.
-   */
-  Update<T> setLabel(String label);
-
-  /**
-   * Return the sql that is actually executed.
-   */
-  String getGeneratedSql();
-
-}

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

@@ -1,166 +0,0 @@
-package io.ebean;
-
-/**
- * An update query typically intended to perform a bulk update of many rows that match the query.
- * <p>
- * Also note that you can also just use a raw SQL update via {@link SqlUpdate} which is pretty light and simple.
- * This UpdateQuery is more for the cases where we want to build the where expression of the update using the
- * {@link ExpressionList} "Criteria API" that is used with a normal ORM query.
- * </p>
- * <p>
- * <h4>Example: Simple update</h4>
- * <p>
- * <pre>{@code
- *
- *  int rows = DB.update(Customer.class)
- *      .set("status", Customer.Status.ACTIVE)
- *      .set("updtime", new Timestamp(System.currentTimeMillis()))
- *      .where()
- *      .gt("id", 1000)
- *      .update();
- *
- * }</pre>
- * <pre>{@code sql
- *
- *   update o_customer set status=?, updtime=? where id > ?
- *
- * }</pre>
- * <p>
- * Note that if the where() clause contains a join then the SQL update changes to use a
- * <code> WHERE ID IN () </code> form.
- * </p>
- * <p>
- * <h4>Example: Update with a JOIN</h4>
- * <p>
- * In this example the expression <code>.eq("billingAddress.country", nz)</code> requires a join
- * to the address table.
- * </p>
- * <p>
- * <pre>{@code
- *
- *   int rows = DB.update(Customer.class)
- *       .set("status", Customer.Status.ACTIVE)
- *       .set("updtime", new Timestamp(System.currentTimeMillis()))
- *       .where()
- *         .eq("status", Customer.Status.NEW)
- *         .eq("billingAddress.country", nz)
- *         .gt("id", 1000)
- *         .update();
- * }</pre>
- * <p>
- * <pre>{@code sql
- *
- *   update o_customer set status=?, updtime=?
- *   where id in (
- *     select t0.id c0
- *     from o_customer t0
- *     left join o_address t1 on t1.id = t0.billing_address_id
- *     where t0.status = ?
- *       and t1.country_code = ?
- *       and t0.id > ? )
- *
- * }</pre>
- *
- * @param <T> The type of entity bean being updated
- * @see SqlUpdate
- */
-public interface UpdateQuery<T> {
-
-  /**
-   * Set the value of a property.
-   * <p>
-   * <pre>{@code
-   *
-   *   int rows = DB.update(Customer.class)
-   *      .set("status", Customer.Status.ACTIVE)
-   *      .set("updtime", new Timestamp(System.currentTimeMillis()))
-   *      .where()
-   *      .gt("id", 1000)
-   *      .update();
-   *
-   * }</pre>
-   *
-   * @param property The bean property to be set
-   * @param value    The value to set the property to
-   */
-  UpdateQuery<T> set(String property, Object value);
-
-  /**
-   * Set the property to be null.
-   * <p>
-   * <pre>{@code
-   *
-   *   int rows = DB.update(Customer.class)
-   *      .setNull("notes")
-   *      .where()
-   *      .gt("id", 1000)
-   *      .update();
-   *
-   * }</pre>
-   *
-   * @param property The property to be set to null.
-   */
-  UpdateQuery<T> setNull(String property);
-
-  /**
-   * Set using a property expression that does not need any bind values.
-   * <p>
-   * The property expression typically contains database functions.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   *   int rows = DB.update(Customer.class)
-   *      .setRaw("status = coalesce(status, 'A')")
-   *      .where()
-   *      .gt("id", 1000)
-   *      .update();
-   *
-   * }</pre>
-   *
-   * @param propertyExpression A property expression
-   */
-  UpdateQuery<T> setRaw(String propertyExpression);
-
-  /**
-   * Set using a property expression that can contain <code>?</code> bind value placeholders.
-   * <p>
-   * For each <code>?</code> in the property expression there should be a matching bind value supplied.
-   * </p>
-   * <pre>{@code
-   *
-   *   int rows = DB.update(Customer.class)
-   *      .setRaw("status = coalesce(status, ?)", Customer.Status.ACTIVE)
-   *      .where()
-   *      .gt("id", 1000)
-   *      .update();
-   *
-   * }</pre>
-   *
-   * @param propertyExpression A raw property expression
-   * @param values             The values to bind with the property expression
-   */
-  UpdateQuery<T> setRaw(String propertyExpression, Object... values);
-
-  /**
-   * Set the profile location of this update query. This is used to relate query execution metrics
-   * back to a location like a specific line of code.
-   */
-  UpdateQuery<T> setProfileLocation(ProfileLocation profileLocation);
-
-  /**
-   * Set the label on the update query.
-   */
-  UpdateQuery<T> setLabel(String label);
-
-  /**
-   * Return the query expression list to add predicates to.
-   */
-  ExpressionList<T> where();
-
-  /**
-   * Execute the update returning the number of rows updated.
-   */
-  int update();
-
-}

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

@@ -1,58 +0,0 @@
-package io.ebean;
-
-/**
- * Holds two values as the result of a difference comparison.
- */
-public class ValuePair {
-
-  protected Object newValue;
-
-  protected Object oldValue;
-
-  /**
-   * Default constructor for JSON tools.
-   */
-  public ValuePair() {
-  }
-
-  /**
-   * Construct with the pair of new and old values.
-   */
-  public ValuePair(Object newValue, Object oldValue) {
-    this.newValue = newValue;
-    this.oldValue = oldValue;
-  }
-
-  /**
-   * Return the new value.
-   */
-  public Object getNewValue() {
-    return newValue;
-  }
-
-  /**
-   * Return the old value.
-   */
-  public Object getOldValue() {
-    return oldValue;
-  }
-
-  /**
-   * Set the new value.
-   */
-  public void setNewValue(Object newValue) {
-    this.newValue = newValue;
-  }
-
-  /**
-   * Set the old value.
-   */
-  public void setOldValue(Object oldValue) {
-    this.oldValue = oldValue;
-  }
-
-  @Override
-  public String toString() {
-    return newValue + "," + oldValue;
-  }
-}

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

@@ -1,111 +0,0 @@
-package io.ebean;
-
-import java.sql.Timestamp;
-import java.util.Map;
-
-/**
- * Wraps a version of a @History bean.
- */
-public class Version<T> {
-
-  /**
-   * The version of the bean.
-   */
-  protected T bean;
-
-  /**
-   * The effective start date time of this version.
-   */
-  protected Timestamp start;
-
-  /**
-   * The effective end date time of this version.
-   */
-  protected Timestamp end;
-
-  /**
-   * The map of changed properties.
-   */
-  protected Map<String, ValuePair> diff;
-
-  /**
-   * Construct with bean and an effective date time range.
-   */
-  public Version(T bean, Timestamp start, Timestamp end) {
-    this.bean = bean;
-    this.start = start;
-    this.end = end;
-  }
-
-  /**
-   * Default constructor - useful for JSON tools such as Jackson.
-   */
-  public Version() {
-  }
-
-  /**
-   * Return the bean instance for this version.
-   */
-  public T getBean() {
-    return bean;
-  }
-
-  /**
-   * Set the bean instance for this version.
-   */
-  public void setBean(T bean) {
-    this.bean = bean;
-  }
-
-  /**
-   * Return the effective start date time of this version.
-   */
-  public Timestamp getStart() {
-    return start;
-  }
-
-  /**
-   * Set the effective start date time of this version.
-   */
-  public void setStart(Timestamp start) {
-    this.start = start;
-  }
-
-  /**
-   * Return the effective end date time of this version.
-   */
-  public Timestamp getEnd() {
-    return end;
-  }
-
-  /**
-   * Set the effective end date time of this version.
-   */
-  public void setEnd(Timestamp end) {
-    this.end = end;
-  }
-
-  /**
-   * Set the map of differences from this bean to the prior version.
-   */
-  public void setDiff(Map<String, ValuePair> diff) {
-    this.diff = diff;
-  }
-
-  /**
-   * Return the map of differences from this bean to the prior version.
-   */
-  public Map<String, ValuePair> getDiff() {
-    return diff;
-  }
-
-  @Override
-  public String toString() {
-    return "Version{" +
-      "bean=" + bean +
-      ", start=" + start +
-      ", end=" + end +
-      ", diff=" + diff +
-      '}';
-  }
-}

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

@@ -1,76 +0,0 @@
-package io.ebean;
-
-import io.ebean.service.SpiFetchGroupQuery;
-import io.ebean.service.SpiFetchGroupService;
-import io.ebean.service.SpiProfileLocationFactory;
-import io.ebean.service.SpiRawSqlService;
-
-import java.util.Iterator;
-import java.util.ServiceLoader;
-
-/**
- * Lookup internal services.
- */
-class XServiceProvider {
-
-  private static SpiRawSqlService rawSqlService = initRawSql();
-
-  private static SpiProfileLocationFactory profileLocationFactory = initProfileLocation();
-
-  private static SpiFetchGroupService fetchGroupService = initSpiFetchGroupService();
-
-  private static SpiFetchGroupService initSpiFetchGroupService() {
-    return loadFirstService(SpiFetchGroupService.class);
-  }
-
-  private static SpiRawSqlService initRawSql() {
-    return loadFirstService(SpiRawSqlService.class);
-  }
-
-  private static SpiProfileLocationFactory initProfileLocation() {
-    return loadFirstService(SpiProfileLocationFactory.class);
-  }
-
-  private static <T> T loadFirstService(Class<T> cls) {
-    Iterator<T> loader = ServiceLoader.load(cls).iterator();
-    if (loader.hasNext()) {
-      return loader.next();
-    }
-    throw new IllegalStateException("No service implementation found for " + cls);
-  }
-
-  /**
-   * Return the RawSqlService implementation.
-   */
-  static SpiRawSqlService rawSql() {
-    return rawSqlService;
-  }
-
-  /**
-   * Return the RawSqlService implementation.
-   */
-  static SpiProfileLocationFactory profileLocationFactory() {
-    return profileLocationFactory;
-  }
-
-  /**
-   * Return the FetchGroup with the given select clause.
-   */
-  static <T> FetchGroup<T> fetchGroupOf(Class<T> cls, String select) {
-    return fetchGroupService.of(cls, select);
-  }
-
-  /**
-   * Return the FetchGroupBuilder with the given select clause.
-   */
-  static <T> FetchGroupBuilder<T> fetchGroupOf(Class<T> cls) {
-    return fetchGroupService.of(cls);
-  }
-
-  /**
-   * Return the FetchGroup Query for building fetch groups via query beans.
-   */
-  static <T> SpiFetchGroupQuery<T> fetchGroupQueryFor(Class<T> cls) {
-    return fetchGroupService.queryFor(cls);
-  }
-}

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

@@ -1,243 +0,0 @@
-package io.ebean.bean;
-
-import io.ebean.ExpressionList;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.Set;
-
-/**
- * Lazy loading capable Maps, Lists and Sets.
- * <p>
- * This also includes the ability to listen for additions and removals to or
- * from the Map Set or List. The purpose of gathering the additions and removals
- * is to support persisting ManyToMany objects. The additions and removals
- * become inserts and deletes from the intersection table.
- * <p>
- * Technically this is <em>NOT</em> an extension of
- * <em>java.util.Collection</em>. The reason being that java.util.Map is not a
- * Collection. I realise this makes this name confusing so I apologise for that.
- */
-public interface BeanCollection<E> extends Serializable {
-
-  enum ModifyListenMode {
-    /**
-     * The common mode
-     */
-    NONE,
-    /**
-     * Mode used for PrivateOwned
-     */
-    REMOVALS,
-    /**
-     * Mode used for ManyToMany relationships
-     */
-    ALL
-  }
-
-  /**
-   * Set the disableLazyLoad state.
-   */
-  void setDisableLazyLoad(boolean disableLazyLoad);
-
-  /**
-   * Load bean from another collection.
-   */
-  void loadFrom(BeanCollection<?> other);
-
-  /**
-   * Add a bean to the list/set with modifyListen notification.
-   */
-  void addBean(E bean);
-
-  /**
-   * Remove a bean to the list/set with modifyListen notification.
-   */
-  void removeBean(E bean);
-
-  /**
-   * Reset the collection back to an empty state ready for reloading.
-   * <p>
-   * This is done as part of bean refresh.
-   */
-  void reset(EntityBean ownerBean, String propertyName);
-
-  /**
-   * Return true if the collection is uninitialised or is empty without any held modifications.
-   * <p>
-   * Returning true means can safely skip cascade save for this bean collection.
-   */
-  boolean isSkipSave();
-
-  /**
-   * Return true if the collection holds modifications.
-   */
-  boolean holdsModifications();
-
-  /**
-   * Return the bean that owns this collection.
-   */
-  EntityBean getOwnerBean();
-
-  /**
-   * Return the bean property name this collection represents.
-   */
-  String getPropertyName();
-
-  /**
-   * Check after the lazy load that the underlying collection is not null
-   * (handle case where join to many not outer).
-   * <p>
-   * That is, if the collection was not loaded due to filterMany predicates etc
-   * then make sure the collection is set to empty.
-   */
-  boolean checkEmptyLazyLoad();
-
-  /**
-   * Return the filter (if any) that was used in building this collection.
-   * <p>
-   * This is so that the filter can be applied on refresh.
-   * </p>
-   */
-  ExpressionList<?> getFilterMany();
-
-  /**
-   * Set the filter that was used in building this collection.
-   */
-  void setFilterMany(ExpressionList<?> filterMany);
-
-  /**
-   * Return true if the collection has been registered with the batch loading context.
-   */
-  boolean isRegisteredWithLoadContext();
-
-  /**
-   * Set the loader that will be used to lazy/query load this collection.
-   * <p>
-   * This is effectively the batch loading context this collection is registered with.
-   * </p>
-   */
-  void setLoader(BeanCollectionLoader beanLoader);
-
-  /**
-   * Set to true if you want the BeanCollection to be treated as read only. This
-   * means no elements can be added or removed etc.
-   */
-  void setReadOnly(boolean readOnly);
-
-  /**
-   * Return true if the collection should be treated as readOnly and no elements
-   * can be added or removed etc.
-   */
-  boolean isReadOnly();
-
-  /**
-   * Add the bean to the collection. This is disallowed for BeanMap.
-   */
-  void internalAdd(Object bean);
-
-  /**
-   * Add the bean with a check to see if it is already contained.
-   */
-  void internalAddWithCheck(Object bean);
-
-  /**
-   * Return the number of elements in the List Set or Map.
-   */
-  int size();
-
-  /**
-   * Return true if the List Set or Map is empty.
-   */
-  boolean isEmpty();
-
-  /**
-   * Returns the underlying collection of beans from the Set, Map or List.
-   */
-  Collection<E> getActualDetails();
-
-  /**
-   * Returns the underlying entries so for Maps this is a collection of
-   * Map.Entry.
-   * <p>
-   * For maps this returns the entrySet as we need the keys of the map.
-   */
-  Collection<?> getActualEntries();
-
-  /**
-   * return true if there are real rows held. Return false is this is using
-   * Deferred fetch to lazy load the rows and the rows have not yet been
-   * fetched.
-   */
-  boolean isPopulated();
-
-  /**
-   * Return true if this is a reference (lazy loading) bean collection. This is
-   * the same as !isPopulated();
-   */
-  boolean isReference();
-
-  /**
-   * Return true if the collection is modify listening and has modifications.
-   */
-  boolean hasModifications();
-
-  /**
-   * Set modify listening on or off. This is used to keep track of objects that
-   * have been added to or removed from the list set or map.
-   * <p>
-   * This is required only for ManyToMany collections. The additions and
-   * deletions are used to insert or delete entries from the intersection table.
-   * Otherwise modifyListening is false.
-   */
-  void setModifyListening(ModifyListenMode modifyListenMode);
-
-  /**
-   * Return the current modify listening mode. Can be null for on newly created beans.
-   */
-  ModifyListenMode getModifyListening();
-
-  /**
-   * Add an object to the additions list.
-   * <p>
-   * This will potentially end up as an insert into a intersection table for a
-   * ManyToMany.
-   */
-  void modifyAddition(E bean);
-
-  /**
-   * Add an object to the deletions list.
-   * <p>
-   * This will potentially end up as an delete from an intersection table for a
-   * ManyToMany.
-   */
-  void modifyRemoval(Object bean);
-
-  /**
-   * Return the list of objects added to the list set or map. These will used to
-   * insert rows into the intersection table of a ManyToMany.
-   */
-  Set<E> getModifyAdditions();
-
-  /**
-   * Return the list of objects removed from the list set or map. These will
-   * used to delete rows from the intersection table of a ManyToMany.
-   */
-  Set<E> getModifyRemovals();
-
-  /**
-   * Reset the set of additions and deletions. This is called after the
-   * additions and removals have been processed.
-   */
-  void modifyReset();
-
-  /**
-   * Has been modified by an addition or removal.
-   */
-  boolean wasTouched();
-
-  /**
-   * Return a shallow copy of this collection that is modifiable.
-   */
-  BeanCollection<E> getShallowCopy();
-}