[maven-release-plugin] prepare release ebean-spring-7.1.2

Change groupId to ... org.avaje.ebean, and artifactId to ... ebean-spring
[maven-release-plugin] prepare for next development iteration
2024-04-21 10:51:47 +00:00 · 2016-08-03 17:46:18 +12:00 · 2016-08-03 17:45:51 +12:00 · 2016-05-18 08:33:54 +12:00 · 2016-05-18 08:33:34 +12:00 · 2016-05-18 08:33:04 +12:00
2163 changed files with 1075 additions and 232107 deletions
@@ -1,19 +0,0 @@
-
-GITHUB ISSUES ARE STRICTLY CONTROLLED FOR THIS PROJECT.
-
-Refer to http://ebean-orm.github.io/support for the policies controlling the use of github issues.
-Please post issues to the Ebean group https://groups.google.com/forum/#!forum/ebean first.
-
-## Expected behavior
-
-## Actual behavior
-
-### Steps to reproduce
-
-```java
-  // some java code
-```
-
-```console
-  // some logging output
-```
@@ -1,22 +1,9 @@
-*.autofetch
-*create-all.sql
-*drop-all.sql
-*.orig
+*.sql
 .classpath
 .project
 .settings/
 target/
 logs/
-log/
-ebean-autotune.xml
-ebean-profiling*.xml
-/db
-/mydb.db
-!src/test/ddl-review/*.sql
-
-
-# Intellij project files
-*.iml
-*.ipr
-*.iws
 .idea/
+*.iml
+
@@ -1,32 +0,0 @@
-sudo: required
-language: java
-jdk:
-  - oraclejdk8
-
-git:
-  depth: 3
-
-addons:
-  postgresql: "9.4"
-
-services:
-  - postgresql
-
-before_script:
-  - ./.travis/setup_database
-
-env:
-  - EBEAN_DB=h2
-  - EBEAN_DB=pg
-
-install: true
-
-script:
-  - mvn clean test
-
-after_failure:
-  - ./.travis/print_surefire_reports
-
-cache:
-  directories:
-  - $HOME/.m2
@@ -1,10 +0,0 @@
-#!/bin/sh
-
-echo "\n=== SUREFIRE REPORTS ===\n"
-
-for file in target/surefire-reports/*.txt
-do
-    echo ${file}
-    cat ${file}
-    echo
-done
@@ -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;'
-
@@ -1,15 +0,0 @@
-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.
@@ -1,17 +1,4 @@
-# Need help?
-Post questions or issues to the Ebean google group - https://groups.google.com/forum/#!forum/ebean
-
-# Documentation
-Goto [https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Website")
-
-
-## Maven cental links:
-[Maven central - avaje-ebeanorm](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22org.avaje.ebeanorm%22%20AND%20a%3A%22avaje-ebeanorm%22 "maven central ebeanorm")
-
-[Maven central - all related projects](http://search.maven.org/#search%7Cga%7C1%7Cavaje-ebeanorm "maven central ebeanorm")
-
-## Current versions
-* [![Maven Central : avaje-ebeanorm](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm) - avaje-ebeanorm 
-* [![Maven Central : avaje-ebeanorm-agent](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm-agent) - avaje-ebeanorm-agent
-* [![Maven Central : avaje-ebeanorm-agent](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm-mavenenhancer/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm-mavenenhancer) - avaje-ebeanorm-mavenenhancer
+avaje-ebeanorm-spring
+=====================

+Spring integration with EbeanORM
@@ -1,24 +1,27 @@
-<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">
+<?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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.avaje</groupId>
-    <artifactId>oss-parent</artifactId>
-    <version>1.1</version>
+    <artifactId>avaje-javaparent</artifactId>
+    <version>1.2</version>
  </parent>

  <groupId>org.avaje.ebean</groupId>
-  <artifactId>ebean</artifactId>
-  <version>8.1.1</version>
+  <artifactId>ebean-spring</artifactId>
+  <name>ebean-spring</name>
+  <version>7.1.2</version>
  <packaging>jar</packaging>
-
-  <name>ebean</name>
-  <url>http://ebean-orm.github.io/</url>
+  <description>Support for Spring transactions and IOC setup of Ebean server config</description>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <spring.framework.version>4.1.7.RELEASE</spring.framework.version>
  </properties>

+  <url>http://www.avaje.org</url>
+
  <licenses>
    <license>
      <name>The Apache Software License, Version 2.0</name>
@@ -27,237 +30,127 @@
    </license>
  </licenses>

-  <developers>
-    <developer>
-      <id>rbygrave</id>
-      <name>Rob Bygrave</name>
-      <email>robin.bygrave@gmail.com</email>
-    </developer>
-  </developers>
-
  <scm>
-    <developerConnection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm.git</developerConnection>
-    <tag>ebean-8.1.1</tag>
+    <connection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm-spring.git</connection>
+    <developerConnection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm-spring.git</developerConnection>
+    <url>https://github.com/ebean-orm/avaje-ebeanorm-spring.git</url>
  </scm>

  <dependencies>

-    <dependency>
-      <groupId>org.jetbrains</groupId>
-      <artifactId>annotations</artifactId>
-      <version>13.0</version>
-    </dependency>
-
-    <dependency>
-      <groupId>javax.persistence</groupId>
-      <artifactId>persistence-api</artifactId>
-      <version>1.0</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-datasource-api</artifactId>
-      <version>1.1</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-datasource</artifactId>
-      <version>1.1.3</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-classpath-scanner-api</artifactId>
-      <version>2.2</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-classpath-scanner</artifactId>
-      <version>2.2.1</version>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-dbmigration</artifactId>
-      <version>1.2.1</version>
-    </dependency>
-
    <dependency>
      <groupId>org.slf4j</groupId>
-      <artifactId>slf4j-api</artifactId>
-      <version>[1.7.1,1.7.99)</version>
+      <artifactId>jcl-over-slf4j</artifactId>
+      <version>[1.7,)</version>
    </dependency>

+    <!-- Provided: Bring in explicitly -->
    <dependency>
-      <groupId>org.antlr</groupId>
-      <artifactId>antlr4-runtime</artifactId>
-      <version>4.5.3</version>
-    </dependency>
-
-    <!-- Jackson core used internally by Ebean -->
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-core</artifactId>
-      <version>2.6.5</version>
-    </dependency>
-
-    <!-- provided scope for JsonNode support -->
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-databind</artifactId>
-      <version>2.6.5</version>
+      <groupId>org.avaje.ebean</groupId>
+      <artifactId>ebean</artifactId>
+      <version>8.1.1</version>
      <scope>provided</scope>
    </dependency>

-    <dependency>
-      <groupId>javax.transaction</groupId>
-      <artifactId>jta</artifactId>
-      <version>1.1</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <!-- provided scope to read validation annotations Size etc -->
-    <dependency>
-      <groupId>javax.validation</groupId>
-      <artifactId>validation-api</artifactId>
-      <version>1.0.0.GA</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>javax.servlet</groupId>
-      <artifactId>servlet-api</artifactId>
-      <version>2.4</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>joda-time</groupId>
-      <artifactId>joda-time</artifactId>
-      <version>1.6</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <!-- Provided scope for Postgres JSON/JSONB support -->
-    <dependency>
-      <groupId>org.postgresql</groupId>
-      <artifactId>postgresql</artifactId>
-      <version>9.4-1202-jdbc41</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <!-- Test scope -->
-
-    <!--<dependency>-->
-      <!--<groupId>oracle</groupId>-->
-      <!--<artifactId>oracle-jdbc</artifactId>-->
-      <!--<version>7.0</version>-->
-      <!--<scope>test</scope>-->
-    <!--</dependency>-->
-
-    <!--<dependency>-->
-      <!--<groupId>microsoft</groupId>-->
-      <!--<artifactId>sqlserver-jdbc</artifactId>-->
-      <!--<version>4.2</version>-->
-      <!--<scope>test</scope>-->
-    <!--</dependency>-->
-
-    <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-agentloader</artifactId>
-      <version>1.1.1</version>
-      <scope>test</scope>
-    </dependency>
-
+    <!-- Optional: Add to use AgentLoaderSupport -->
    <dependency>
      <groupId>org.avaje.ebean</groupId>
      <artifactId>ebean-agent</artifactId>
      <version>8.1.1</version>
-      <scope>test</scope>
-    </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>1.4.192</version>
      <scope>provided</scope>
    </dependency>
-    
+
+    <!-- Optional: Add to use AgentLoaderSupport -->
    <dependency>
-      <groupId>org.xerial</groupId>
-      <artifactId>sqlite-jdbc</artifactId>
-      <version>3.8.11.2</version>
-      <scope>test</scope>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-agentloader</artifactId>
+      <version>2.1.2</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <!-- Provided: Spring, bring in explicitly -->
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-context</artifactId>
+      <version>${spring.framework.version}</version>
+      <scope>provided</scope>
    </dependency>

    <dependency>
-      <groupId>org.hsqldb</groupId>
-      <artifactId>hsqldb</artifactId>
-      <version>2.0.0</version>
-      <scope>test</scope>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-core</artifactId>
+      <version>${spring.framework.version}</version>
+      <scope>provided</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>commons-logging</groupId>
+          <artifactId>commons-logging</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-aspects</artifactId>
+      <version>${spring.framework.version}</version>
+      <scope>provided</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>commons-logging</groupId>
+          <artifactId>commons-logging</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-jdbc</artifactId>
+      <version>${spring.framework.version}</version>
+      <scope>provided</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>commons-logging</groupId>
+          <artifactId>commons-logging</artifactId>
+        </exclusion>
+      </exclusions>
    </dependency>

+    <!-- Test dependencies -->
    <dependency>
-      <groupId>mysql</groupId>
-      <artifactId>mysql-connector-java</artifactId>
-      <version>5.1.36</version>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-test</artifactId>
+      <version>${spring.framework.version}</version>
      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>commons-logging</groupId>
+          <artifactId>commons-logging</artifactId>
+        </exclusion>
+      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.avaje.composite</groupId>
-      <artifactId>avaje-composite-testing</artifactId>
-      <version>1.1</version>
-      <scope>test</scope>
+      <artifactId>avaje-composite-testing-ebean</artifactId>
+      <version>4.1</version>
      <type>pom</type>
-    </dependency>
-
-    <dependency>
-      <groupId>commons-io</groupId>
-      <artifactId>commons-io</artifactId>
-      <version>2.4</version>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.avaje.moduuid</groupId>
-      <artifactId>avaje-moduuid</artifactId>
-      <version>1.2</version>
      <scope>test</scope>
    </dependency>

  </dependencies>

-
  <build>
    <plugins>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.2</version>
-        <configuration>
-          <source>1.6</source>
-          <target>1.6</target>
-        </configuration>
-      </plugin>
-
      <plugin>
        <groupId>org.avaje.ebean</groupId>
        <artifactId>ebean-maven-plugin</artifactId>
        <version>8.1.1</version>
        <executions>
          <execution>
-            <id>test</id>
+            <id>main</id>
            <phase>process-test-classes</phase>
            <configuration>
              <classSource>target/test-classes</classSource>
-              <!--<packages>com.avaje.tests.**</packages>-->
-              <transformArgs>debug=1</transformArgs>
+              <packages>com.avaje.**</packages>
+              <transformArgs>debug=9</transformArgs>
            </configuration>
            <goals>
              <goal>enhance</goal>
@@ -265,77 +158,80 @@
          </execution>
        </executions>
      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-surefire-plugin</artifactId>
-        <version>2.5</version>
-        <configuration>
-          <useSystemClassLoader>false</useSystemClassLoader>
-          <failIfNoTests>false</failIfNoTests>
-          <includes>
-            <include>**/Test*.java</include>
-            <include>**/*Test.java</include>
-            <include>**/*Tests.java</include>
-          </includes>
-          <systemProperties>
-            <property>
-              <!-- transfer datasource.default parameter -->
-              <name>datasource.default</name>
-              <value>${datasource.default}</value>
-            </property>
-          </systemProperties>
-        </configuration>
-      </plugin>
-
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
-        <version>2.5</version>
        <configuration>
          <archive>
            <manifestFile>src/main/resources/META-INF/MANIFEST.MF</manifestFile>
          </archive>
        </configuration>
      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-javadoc-plugin</artifactId>
-        <version>2.9.1</version>
-        <configuration>
-          <doctitle>Ebean 8</doctitle>
-          <overview>src/main/java/com/avaje/ebean/overview.html</overview>
-          <source>1.8</source>
-          <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
-          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util:com.avaje.ebean.dbmigration.ddlgeneration:com.avaje.ebean.dbmigration.migration:com.avaje.ebean.dbmigration.migrationreader:com.avaje.ebean.dbmigration.model</excludePackageNames>
-          <docletArtifact>
-            <groupId>org.avaje</groupId>
-            <artifactId>pygments-doclet</artifactId>
-            <version>1.0.0</version>
-          </docletArtifact>
-          <additionalparam>
-            -Xdoclint:none
-            -include-basedir ${project.basedir}
-            -attributes "idseparator=-; project_name=${project.name}; \
-            project_version=${project.version}; \
-            project_desc=${project.description}"
-          </additionalparam>
-          <linksource>true</linksource>
-          <overview>src/main/java/com/avaje/ebean/overview.html</overview>
-        </configuration>
-        <executions>
-          <execution>
-            <id>attach-javadocs</id>
-            <goals>
-              <goal>jar</goal>
-            </goals>
-          </execution>
-        </executions>
-      </plugin>
-
    </plugins>
+    <pluginManagement>
+      <plugins>
+        <!--This plugin's configuration is used to store Eclipse m2e settings 
+          only. It has no influence on the Maven build itself. -->
+        <plugin>
+          <groupId>org.eclipse.m2e</groupId>
+          <artifactId>lifecycle-mapping</artifactId>
+          <version>1.0.0</version>
+          <configuration>
+            <lifecycleMappingMetadata>
+              <pluginExecutions>
+                <pluginExecution>
+                  <pluginExecutionFilter>
+                    <groupId>
+                      org.avaje.ebean
+                    </groupId>
+                    <artifactId>
+                      ebean-maven-plugin
+                    </artifactId>
+                    <versionRange>
+                      [3,4)
+                    </versionRange>
+                    <goals>
+                      <goal>enhance</goal>
+                    </goals>
+                  </pluginExecutionFilter>
+                  <action>
+                    <ignore />
+                  </action>
+                </pluginExecution>
+              </pluginExecutions>
+            </lifecycleMappingMetadata>
+          </configuration>
+        </plugin>

+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-javadoc-plugin</artifactId>
+          <version>2.9.1</version>
+          <configuration>
+            <source>1.8</source>
+            <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
+            <docletArtifact>
+              <groupId>org.avaje</groupId>
+              <artifactId>pygments-doclet</artifactId>
+              <version>1.0.0</version>
+            </docletArtifact>
+            <additionalparam>
+              -Xdoclint:none
+            </additionalparam>
+            <linksource>true</linksource>
+          </configuration>
+
+          <executions>
+            <execution>
+              <id>attach-javadocs</id>
+              <goals>
+                <goal>jar</goal>
+              </goals>
+            </execution>
+          </executions>
+        </plugin>
+        
+      </plugins>
+    </pluginManagement>
  </build>
- 
 </project>
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Class-Path: 
+
@@ -1,24 +0,0 @@
-package com.avaje.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();
-
-}
@@ -1,40 +0,0 @@
-package com.avaje.ebean;
-
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Background thread pool service for executing of tasks asynchronously.
- * <p>
- * This service is used internally by Ebean for executing background tasks such
- * as the {@link Query#findFutureList()} and also for executing background tasks
- * periodically.
- * </p>
- * <p>
- * This service has been made available so you can use it for your application
- * code if you want. It can be useful for some server caching implementations
- * (background population and trimming of the cache etc).
- * </p>
- * 
- * @author rbygrave
- */
-public interface BackgroundExecutor {
-
-  /**
-   * Execute a task in the background.
-   */
-  void execute(Runnable r);
-
-  /**
-   * Execute a task periodically with a fixed delay between each execution.
-   * <p>
-   * For example, execute a runnable every minute.
-   * </p>
-   * <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)}
-   * </p>
-   */
-  void executePeriodically(Runnable r, long delay, TimeUnit unit);
-}
@@ -1,123 +0,0 @@
-package com.avaje.ebean;
-
-import java.beans.PropertyChangeListener;
-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
-   *   Ebean.getBeanState(user).setPropertyLoaded("email", false);
-   *
-   *   user.update();
-   *
-   * }</pre>
-   *
-   *
-   * 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.
-   * </p>
-   */
-  Set<String> getLoadedProps();
-
-  /**
-   * Return the set of changed properties.
-   */
-  Set<String> getChangedProps();
-
-  /**
-   * Return a map of the updated properties and their new and old values.
-   */
-  Map<String,ValuePair> getDirtyValues();
-  
-  /**
-   * Return true if the bean is readOnly.
-   * <p>
-   * If a setter is called on a readOnly bean it will throw an exception.
-   * </p>
-   */
-  boolean isReadOnly();
-
-  /**
-   * Set the readOnly status for the bean.
-   */
-  void setReadOnly(boolean readOnly);
-
-  /**
-   * Add a propertyChangeListener.
-   */
-  void addPropertyChangeListener(PropertyChangeListener listener);
-
-  /**
-   * Remove a propertyChangeListener.
-   */
-  void removePropertyChangeListener(PropertyChangeListener listener);
-
-  /**
-   * Advanced - Used to programmatically build a partially or fully loaded
-   * entity bean. First create an entity bean via
-   * {@link EbeanServer#createEntityBean(Class)}, then populate its properties
-   * and then call this method specifying which properties where loaded or null
-   * for a fully loaded entity bean.
-   */
-  void setLoaded();
-}
@@ -1,193 +0,0 @@
-package com.avaje.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 class="code">
- * String sql = &quot;{call sp_order_mod(?,?)}&quot;;
- * 
- * CallableSql cs = Ebean.createCallableSql(sql);
- * cs.setParameter(1, &quot;turbo&quot;);
- * cs.registerOut(2, Types.INTEGER);
- * 
- * Ebean.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 class="code">
- * String sql = &quot;{call sp_insert_order(?,?)}&quot;;
- * 
- * CallableSql cs = Ebean.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(&quot;oe_order&quot;, true, false, false);
- * cs.addModification(&quot;oe_order_detail&quot;, true, true, false);
- * 
- * Transaction t = Ebean.startTransaction();
- * 
- * // execute using JDBC batching 10 statements at a time
- * t.setBatchMode(true);
- * t.setBatchSize(10);
- * try {
- *   cs.setParameter(1, &quot;Was&quot;);
- *   cs.setParameter(2, &quot;Banana&quot;);
- *   Ebean.execute(cs);
- * 
- *   cs.setParameter(1, &quot;Here&quot;);
- *   cs.setParameter(2, &quot;Kumera&quot;);
- *   Ebean.execute(cs);
- * 
- *   cs.setParameter(1, &quot;More&quot;);
- *   cs.setParameter(2, &quot;Apple&quot;);
- *   Ebean.execute(cs);
- * 
- *   // Ebean.externalModification(&quot;oe_order&quot;,true,false,false);
- *   // Ebean.externalModification(&quot;oe_order_detail&quot;,true,true,false);
- *   Ebean.commitTransaction();
- * 
- * } finally {
- *   Ebean.endTransaction();
- * }
- * </pre>
- * 
- * @see com.avaje.ebean.SqlUpdate
- * @see com.avaje.ebean.Ebean#execute(CallableSql)
- */
-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>Ebean.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);
-
-}
@@ -1,97 +0,0 @@
-package com.avaje.ebean;
-
-import java.util.ArrayList;
-
-import javax.persistence.PersistenceException;
-
-import com.avaje.ebean.RawSql.ColumnMapping;
-
-/**
- * Parses columnMapping (select clause) mapping columns to bean properties.
- */
-final class DRawSqlColumnsParser {
-
-  private final int end;
-
-  private final String sqlSelect;
-
-  private int pos;
-
-  private int indexPos;
-
-  public static ColumnMapping parse(String sqlSelect) {
-    return new DRawSqlColumnsParser(sqlSelect).parse();
-  }
-
-  private DRawSqlColumnsParser(String sqlSelect) {
-    this.sqlSelect = sqlSelect;
-    this.end = sqlSelect.length();
-  }
-
-  private ColumnMapping parse() {
-
-    ArrayList<ColumnMapping.Column> columns = new ArrayList<ColumnMapping.Column>();
-    while (pos <= end) {
-      ColumnMapping.Column c = nextColumnInfo();
-      columns.add(c);
-    }
-
-    return new ColumnMapping(columns);
-  }
-
-  private ColumnMapping.Column nextColumnInfo() {
-    int start = pos;
-    nextComma();
-    String colInfo = sqlSelect.substring(start, pos++);
-    colInfo = colInfo.trim();
-
-    String[] split = colInfo.split("\\s(?=[^\\)]*(?:\\(|$))");
-    if (split.length > 1) {
-      ArrayList<String> tmp = new ArrayList<String>(split.length);
-      for (int i = 0; i < split.length; i++) {
-        if (!split[i].trim().isEmpty()) {
-          tmp.add(split[i].trim());
-        }
-      }
-      split = tmp.toArray(new String[tmp.size()]);
-    }
-
-    if (split.length == 0) {
-      throw new PersistenceException("Huh? Not expecting length=0 when parsing column " + colInfo);
-    }
-    if (split.length == 1) {
-      // default to column the same name as the property
-      return new ColumnMapping.Column(indexPos++, split[0], null);
-    }
-    if (split.length == 2) {
-      return new ColumnMapping.Column(indexPos++, split[0], split[1]);
-    }
-    // Ok, we now expect/require the AS keyword and it should be the 
-    // second to last word in the colInfo content 
-    if (!split[split.length - 2].equalsIgnoreCase("as")) {
-      throw new PersistenceException("Expecting AS keyword as second to last word when parsing column " + colInfo);
-    }
-    // build back the 'column formula' that precedes the AS keyword
-    StringBuilder sb = new StringBuilder();
-    sb.append(split[0]);
-    for (int i = 1; i < split.length-2; i++) {
-      sb.append(" ").append(split[i]);
-    }
-    return new ColumnMapping.Column(indexPos++, sb.toString(), split[split.length - 1]);
-  }
-
-  private void nextComma() {
-    boolean inQuote = false;
-    int inbrackets = 0;
-    while (pos < end) {
-      char c = sqlSelect.charAt(pos);
-      if (c == '\'') inQuote = !inQuote;
-      else if (c == '(') inbrackets++;
-      else if (c == ')') inbrackets--;
-      else if (!inQuote && inbrackets == 0 && c == ',') {
-        return;
-      }
-      pos++;
-    }
-  }
-}
@@ -1,290 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.RawSql.Sql;
-
-/**
- * Parses sql-select queries to try and determine the location where WHERE and
- * HAVING clauses can be added dynamically to the sql.
- */
-class DRawSqlParser {
-
-  public static final String $_AND_HAVING = "${andHaving}";
-
-  public static final String $_HAVING = "${having}";
-
-  public static final String $_AND_WHERE = "${andWhere}";
-
-  public static final String $_WHERE = "${where}";
-
-  private final SimpleTextParser textParser;
-
-  private String sql;
-
-  private int placeHolderWhere;
-  private int placeHolderAndWhere;
-  private int placeHolderHaving;
-  private int placeHolderAndHaving;
-  private final boolean hasPlaceHolders;
-
-  private int selectPos = -1;
-  private int distinctPos = -1;
-  private int fromPos = -1;
-  private int wherePos = -1;
-  private int groupByPos = -1;
-  private int havingPos = -1;
-  private int orderByPos = -1;
-  private int orderByStmtPos = -1;
-
-  private boolean whereExprAnd;
-  private int whereExprPos = -1;
-  private boolean havingExprAnd;
-  private int havingExprPos = -1;
-
-  public static Sql parse(String sql) {
-    return new DRawSqlParser(sql).parse();
-  }
-
-  private DRawSqlParser(String sqlString) {
-    sqlString = sqlString.trim();
-    sqlString = sqlString.replace('\n',' ');
-    this.sql = sqlString;
-    this.hasPlaceHolders = findAndRemovePlaceHolders();
-    this.textParser = new SimpleTextParser(sqlString);
-  }
-
-  private Sql parse() {
-
-    if (!hasPlaceHolders()) {
-      // parse the sql for the keywords...
-      // select, from, where, having, group by, order by
-      parseSqlFindKeywords(true);
-    }
-
-    whereExprPos = findWhereExprPosition();
-    havingExprPos = findHavingExprPosition();
-
-    String preFrom = removeWhitespace(findPreFromSql());
-    String preWhere = removeWhitespace(findPreWhereSql());
-    String preHaving = removeWhitespace(findPreHavingSql());
-    String orderByPrefix = findOrderByPrefixSql();
-    String orderBySql = findOrderBySql();
-
-    preFrom = trimSelectKeyword(preFrom);
-
-    return new Sql(sql, preFrom, preWhere, whereExprAnd, preHaving, havingExprAnd, orderByPrefix, orderBySql, (distinctPos > -1));
-  }
-
-  /**
-   * Find and remove the known place holders such as ${where}.
-   */
-  private boolean findAndRemovePlaceHolders() {
-    placeHolderWhere = removePlaceHolder($_WHERE);
-    placeHolderAndWhere = removePlaceHolder($_AND_WHERE);
-    placeHolderHaving = removePlaceHolder($_HAVING);
-    placeHolderAndHaving = removePlaceHolder($_AND_HAVING);
-    return hasPlaceHolders();
-  }
-
-  private int removePlaceHolder(String placeHolder) {
-    int pos = sql.indexOf(placeHolder);
-    if (pos > -1) {
-      int after = pos + placeHolder.length() + 1;
-      if (after > sql.length()) {
-        sql = sql.substring(0, pos);
-      } else {
-        sql = sql.substring(0, pos) + sql.substring(after);
-      }
-    }
-    return pos;
-  }
-
-  private boolean hasPlaceHolders() {
-    return placeHolderWhere > -1 || placeHolderAndWhere > -1 || placeHolderHaving > -1 || placeHolderAndHaving > -1;
-  }
-
-  /**
-   * Trim off the select keyword (to support row_number() limit function).
-   */
-  private String trimSelectKeyword(String preWhereExprSql) {
-
-    if (selectPos < 0) {
-      throw new IllegalStateException("select keyword not found?");
-    }
-    // trim of select keyword
-    preWhereExprSql = preWhereExprSql.trim();
-    String select = preWhereExprSql.substring(0, 7);
-    if (!select.equalsIgnoreCase("select ")) {
-      throw new RuntimeException("Expecting [" + preWhereExprSql + "] to start with \"select\"");
-    }
-    preWhereExprSql = preWhereExprSql.substring(7).trim();
-    if (distinctPos > -1) {
-      // trim of distinct keyword
-      String distinct = preWhereExprSql.substring(0, 9);
-      if (!distinct.equalsIgnoreCase("distinct ")) {
-        throw new RuntimeException("Expecting [" + preWhereExprSql + "] to start with \"select distinct\"");
-      }
-      preWhereExprSql = preWhereExprSql.substring(9);
-    }
-
-    return preWhereExprSql;
-  }
-
-  private String findOrderByPrefixSql() {
-    return (orderByPos < 1) ? null : sql.substring(orderByPos, orderByStmtPos);
-  }
-
-  private String findOrderBySql() {
-    return (orderByStmtPos < 1) ? null : sql.substring(orderByStmtPos).trim();
-  }
-
-  private String findPreHavingSql() {
-    if (havingExprPos > whereExprPos) {
-      // an order by clause follows...
-      return sql.substring(whereExprPos, havingExprPos - 1);
-    }
-    if (whereExprPos > -1) {
-      if (orderByPos == -1) {
-        return sql.substring(whereExprPos);
-
-      } else if (whereExprPos == orderByPos) {
-        return "";
-
-      } else {
-        return sql.substring(whereExprPos, orderByPos - 1);
-      }
-    }
-    return null;
-  }
-
-  private String findPreFromSql() {
-    return sql.substring(0, fromPos - 1);
-  }
-
-  private String findPreWhereSql() {
-    if (whereExprPos > -1) {
-      return sql.substring(fromPos, whereExprPos - 1);
-    } else {
-      return sql.substring(fromPos);
-    }
-  }
-
-  private void parseSqlFindKeywords(boolean allKeywords) {
-
-    selectPos = textParser.findWordLower("select");
-    if (selectPos == -1) {
-      String msg = "Error parsing sql, can not find SELECT keyword in:";
-      throw new RuntimeException(msg + sql);
-    }
-
-    String possibleDistinct = textParser.nextWord();
-    if ("distinct".equals(possibleDistinct)) {
-      distinctPos = textParser.getPos() - 8;
-    }
-
-    fromPos = textParser.findWordLower("from");
-    if (fromPos == -1) {
-      String msg = "Error parsing sql, can not find FROM keyword in:";
-      throw new RuntimeException(msg + sql);
-    }
-
-    if (!allKeywords) {
-      return;
-    }
-
-    wherePos = textParser.findWordLower("where");
-    if (wherePos == -1) {
-      groupByPos = textParser.findWordLower("group", fromPos + 5);
-    } else {
-      groupByPos = textParser.findWordLower("group");
-    }
-    if (groupByPos > -1) {
-      havingPos = textParser.findWordLower("having");
-    }
-
-    int startOrderBy = havingPos;
-    if (startOrderBy == -1) {
-      startOrderBy = groupByPos;
-    }
-    if (startOrderBy == -1) {
-      startOrderBy = wherePos;
-    }
-    if (startOrderBy == -1) {
-      startOrderBy = fromPos;
-    }
-
-    orderByPos = textParser.findWordLower("order", startOrderBy);
-    if (orderByPos > 1) {
-      // there might be keywords like siblings in between the order
-      // and by so search for the by keyword explicitly
-      orderByStmtPos = 2 + textParser.findWordLower("by", orderByPos);
-    }
-  }
-
-  private int findWhereExprPosition() {
-    if (hasPlaceHolders) {
-      if (placeHolderWhere > -1) {
-        return placeHolderWhere;
-      } else {
-        whereExprAnd = true;
-        return placeHolderAndWhere;
-      }
-    }
-    whereExprAnd = wherePos > 0;
-    if (groupByPos > 0) {
-      return groupByPos;
-    }
-    if (havingPos > 0) {
-      return havingPos;
-    }
-    if (orderByPos > 0) {
-      return orderByPos;
-    }
-    return -1;
-  }
-
-  private int findHavingExprPosition() {
-    if (hasPlaceHolders) {
-      if (placeHolderHaving > -1) {
-        return placeHolderHaving;
-      } else {
-        havingExprAnd = true;
-        return placeHolderAndHaving;
-      }
-    }
-    havingExprAnd = havingPos > 0;
-    if (orderByPos > 0) {
-      return orderByPos;
-    }
-    return -1;
-  }
-
-  private String removeWhitespace(String sql) {
-    if (sql == null) {
-      return "";
-    }
-
-    boolean removeWhitespace = false;
-
-    int length = sql.length();
-    StringBuilder sb = new StringBuilder();
-    for (int i = 0; i < length; i++) {
-      char c = sql.charAt(i);
-      if (removeWhitespace) {
-        if (!Character.isWhitespace(c)) {
-          sb.append(c);
-          removeWhitespace = false;
-        }
-      } else {
-        if (c == '\r' || c == '\n') {
-          sb.append('\n');
-          removeWhitespace = true;
-        } else {
-          sb.append(c);
-        }
-      }
-    }
-
-    String s = sb.toString();
-    return s.trim();
-  }
-}
@@ -1,94 +0,0 @@
-package com.avaje.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;
-    }
-  }
-
-  final Action type;
-
-  final String queueId;
-
-  final String path;
-
-  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;
-  }
-}
@@ -1,304 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebeanservice.docstore.api.DocQueryRequest;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Document storage operations.
- */
-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 findUnique() on the query.
-   * </p>
-   * <pre>{@code
-   *
-   * Customer customer =
-   *   server.find(Customer.class)
-   *     .setUseDocStore(true)
-   *     .setId(42)
-   *     .findUnique();
-   *
-   * }</pre>
-   */
-  @Nullable
-  <T> T find(DocQueryRequest<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 =
-   *  server.find(Customer.class)
-   *    .setUseDocStore(true)
-   *    .where().eq("status, Customer.Status.NEW)
-   *    .findList();
-   *
-   * }</pre>
-   */
-  <T> List<T> findList(DocQueryRequest<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 =
-   *  server.find(Customer.class)
-   *    .setUseDocStore(true)
-   *    .where().eq("status, Customer.Status.NEW)
-   *    .setMaxRows(50)
-   *    .findPagedList();
-   *
-   * }</pre>
-   *
-   */
-  <T> PagedList<T> findPagedList(DocQueryRequest<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
-   *
-   *  server.find(Order.class)
-   *    .setUseDocStore(true)
-   *    .where()... // perhaps add predicates
-   *    .findEach(new QueryEachConsumer<Order>() {
-   *      @Override
-   *      public void accept(Order bean) {
-   *        // process the bean
-   *      }
-   *    });
-   *
-   * }</pre>
-   */
-  <T> void findEach(DocQueryRequest<T> query, QueryEachConsumer<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
-   *
-   *  server.find(Order.class)
-   *    .setUseDocStore(true)
-   *    .where()... // perhaps add predicates
-   *    .findEachWhile(new QueryEachWhileConsumer<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(DocQueryRequest<T> query, QueryEachWhileConsumer<T> 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 = server.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 = server.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 = server.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);
-}
@@ -1,148 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.common.SpiContainer;
-import com.avaje.ebean.config.ContainerConfig;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebeaninternal.server.lib.ShutdownManager;
-
-import javax.persistence.PersistenceException;
-import java.lang.reflect.Constructor;
-import java.util.Properties;
-
-/**
- * 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>
- */
-public class EbeanServerFactory {
-
-
-  private static final String DEFAULT_CONTAINER = "com.avaje.ebeaninternal.server.core.DefaultContainer";
-
-  private static SpiContainer container;
-
-  /**
-   * Initialise the container with clustering configuration.
-   *
-   * Call this prior to creating any EbeanServer instances or alternatively set the
-   * ContainerConfig on the ServerConfig when creating the first EbeanServer instance.
-   */
-  public static synchronized void initialiseContainer(ContainerConfig containerConfig) {
-    getContainer(containerConfig);
-  }
-
-  /**
-   * Create using ebean.properties to configure the server.
-   */
-  public static synchronized EbeanServer create(String name) {
-
-    // construct based on loading properties files
-    // and if invoked by Ebean then it handles registration
-    SpiContainer serverFactory = getContainer(null);
-    return serverFactory.createServer(name);
-  }
-
-  /**
-   * Create using the ServerConfig object to configure the server.
-   */
-  public static synchronized EbeanServer create(ServerConfig config) {
-
-    if (config.getName() == null) {
-      throw new PersistenceException("The name is null (it is required)");
-    }
-
-    EbeanServer server = createInternal(config);
-
-    if (config.isDefaultServer()) {
-      PrimaryServer.setSkip(true);
-    }
-    if (config.isRegister()) {
-      Ebean.register(server, config.isDefaultServer());
-    }
-
-    return server;
-  }
-
-  /**
-   * Create using the ServerConfig additionally specifying a classLoader to use as the context class loader.
-   */
-  public static synchronized EbeanServer createWithContextClassLoader(ServerConfig config, ClassLoader classLoader) {
-
-    ClassLoader currentContextLoader = Thread.currentThread().getContextClassLoader();
-    Thread.currentThread().setContextClassLoader(classLoader);
-    try {
-      return EbeanServerFactory.create(config);
-
-    } finally {
-      // set the currentContextLoader back
-      Thread.currentThread().setContextClassLoader(currentContextLoader);
-    }
-  }
-
-  /**
-   * 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 synchronized void shutdown() {
-    ShutdownManager.shutdown();
-  }
-
-
-  private static EbeanServer createInternal(ServerConfig config) {
-
-    return getContainer(config.getContainerConfig()).createServer(config);
-  }
-
-  /**
-   * Get the EbeanContainer initialising it if necessary.
-   *
-   * @param containerConfig the configuration controlling clustering communication
-   */
-  private static SpiContainer getContainer(ContainerConfig containerConfig) {
-
-    // thread safe in that all calling methods are synchronized
-    if (container != null) {
-      return container;
-    }
-
-    if (containerConfig == null) {
-      // effectively load configuration from ebean.properties
-      Properties properties = PrimaryServer.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) {
-
-    String implClassName = System.getProperty("ebean.container", DEFAULT_CONTAINER);
-
-    try {
-      Class<?> cls = Class.forName(implClassName);
-      Constructor<?> constructor = cls.getConstructor(ContainerConfig.class);
-      return (SpiContainer) constructor.newInstance(containerConfig);
-    } catch (Exception ex) {
-      throw new RuntimeException(ex);
-    }
-  }
-}
@@ -1,93 +0,0 @@
-package com.avaje.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 class="code">
- * // create an example bean and set the properties
- * // with the query parameters you want
- * Customer example = new Customer();
- * example.setName(&quot;Rob%&quot;);
- * example.setNotes(&quot;%something%&quot;);
- * 
- * List&lt;Customer&gt; list =
- *     Ebean.find(Customer.class)
- *         .where()
- *         // pass the bean into the where() clause
- *         .exampleLike(example)
- *         // you can add other expressions to the same query
- *         .gt(&quot;id&quot;, 2)
- *         .findList();
- * 
- * </pre>
- * 
- * Similarly you can create an ExampleExpression
- * 
- * <pre>
- * Customer example = new Customer();
- * example.setName(&quot;Rob%&quot;);
- * example.setNotes(&quot;%something%&quot;);
- * 
- * // create a ExampleExpression with more control
- * ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO)
- *     .includeZeros();
- * 
- * List&lt;Customer&gt; list =
- *     Ebean.find(Customer.class)
- *         .where()
- *         .add(qbe)
- *         .findList();
- * </pre>
- * 
- * @author Rob Bygrave
- */
-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();
-
-}
@@ -1,336 +0,0 @@
-package com.avaje.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'
- * server. It is actually a short cut for using the ExpressionFactory of the
- * 'default' EbeanServer.
- * <p>
- * See also {@link Ebean#getExpressionFactory()}
- * </p>
- * <p>
- * Creates standard common expressions for using in a Query Where or Having
- * clause.
- * </p>
- * 
- * <pre class="code">
- *  // Example: Using an Expr.or() method
- * Query&lt;Order&gt; query = Ebean.createQuery(Order.class);
- * query.where( 
- * 		Expr.or(Expr.eq(&quot;status&quot;, Order.NEW),
- *     		    Expr.gt(&quot;orderDate&quot;, lastWeek));
- *     
- * List&lt;Order&gt; list = query.findList();
- * ...
- * </pre>
- * 
- * @see Query#where()
- * @author Rob Bygrave
- */
-public class Expr {
-
-  private Expr() {
-  }
-
-  /**
-   * Equal To - property equal to the given value.
-   */
-  public static Expression eq(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().eq(propertyName, value);
-  }
-
-  /**
-   * Not Equal To - property not equal to the given value.
-   */
-  public static Expression ne(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().ieq(propertyName, value);
-  }
-
-  /**
-   * Between - property between the two given values.
-   */
-  public static Expression between(String propertyName, Object value1, Object value2) {
-
-    return Ebean.getExpressionFactory().between(propertyName, value1, value2);
-  }
-
-  /**
-   * Between - value between two given properties.
-   */
-  public static Expression between(String lowProperty, String highProperty, Object value) {
-    
-    return Ebean.getExpressionFactory().betweenProperties(lowProperty, highProperty, value);
-  }
-  
-  /**
-   * Greater Than - property greater than the given value.
-   */
-  public static Expression gt(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().ge(propertyName, value);
-  }
-
-  /**
-   * Less Than - property less than the given value.
-   */
-  public static Expression lt(String propertyName, Object value) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().le(propertyName, value);
-  }
-
-  /**
-   * Is Null - property is null.
-   */
-  public static Expression isNull(String propertyName) {
-    return Ebean.getExpressionFactory().isNull(propertyName);
-  }
-
-  /**
-   * Is Not Null - property is not null.
-   */
-  public static Expression isNotNull(String propertyName) {
-    return Ebean.getExpressionFactory().isNotNull(propertyName);
-  }
-
-  /**
-   * Case insensitive {@link #exampleLike(Object)}
-   */
-  public static ExampleExpression iexampleLike(Object example) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().exampleLike(example);
-  }
-
-  /**
-   * Create the query by Example expression specifying more options.
-   */
-  public static ExampleExpression exampleLike(Object example, boolean caseInsensitive,
-      LikeType likeType) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().ilike(propertyName, value);
-  }
-
-  /**
-   * Starts With - property like value%.
-   */
-  public static Expression startsWith(String propertyName, String value) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().istartsWith(propertyName, value);
-  }
-
-  /**
-   * Ends With - property like %value.
-   */
-  public static Expression endsWith(String propertyName, String value) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().iendsWith(propertyName, value);
-  }
-
-  /**
-   * Contains - property like %value%.
-   */
-  public static Expression contains(String propertyName, String value) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().icontains(propertyName, value);
-  }
-
-  /**
-   * For collection properties that are empty (have not existing elements).
-   */
-  public static Expression isEmpty(String propertyName) {
-    return Ebean.getExpressionFactory().isEmpty(propertyName);
-  }
-
-  /**
-   * For collection properties that are not empty (have existing elements).
-   */
-  public static Expression isNotEmpty(String propertyName) {
-    return Ebean.getExpressionFactory().isNotEmpty(propertyName);
-  }
-
-  /**
-   * In - property has a value in the array of values.
-   */
-  public static Expression in(String propertyName, Object[] values) {
-    return Ebean.getExpressionFactory().in(propertyName, values);
-  }
-
-  /**
-   * In - using a subQuery.
-   */
-  public static Expression in(String propertyName, Query<?> subQuery) {
-    return Ebean.getExpressionFactory().in(propertyName, subQuery);
-  }
-
-  /**
-   * In - property has a value in the collection of values.
-   */
-  public static Expression in(String propertyName, Collection<?> values) {
-    return Ebean.getExpressionFactory().in(propertyName, values);
-  }
-
-  /**
-   * Id Equal to - ID property is equal to the value.
-   */
-  public static Expression idEq(Object value) {
-    return Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().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 Ebean.getExpressionFactory().raw(raw, values);
-  }
-
-  /**
-   * Add raw expression with no parameters.
-   */
-  public static Expression raw(String raw) {
-    return Ebean.getExpressionFactory().raw(raw);
-  }
-
-  /**
-   * And - join two expressions with a logical and.
-   */
-  public static Expression and(Expression expOne, Expression expTwo) {
-
-    return Ebean.getExpressionFactory().and(expOne, expTwo);
-  }
-
-  /**
-   * Or - join two expressions with a logical or.
-   */
-  public static Expression or(Expression expOne, Expression expTwo) {
-
-    return Ebean.getExpressionFactory().or(expOne, expTwo);
-  }
-
-  /**
-   * Negate the expression (prefix it with NOT).
-   */
-  public static Expression not(Expression exp) {
-
-    return Ebean.getExpressionFactory().not(exp);
-  }
-
-  /**
-   * Return a list of expressions that will be joined by AND's.
-   */
-  public static <T> Junction<T> conjunction(Query<T> query) {
-
-    return Ebean.getExpressionFactory().conjunction(query);
-  }
-
-  /**
-   * Return a list of expressions that will be joined by OR's.
-   */
-  public static <T> Junction<T> disjunction(Query<T> query) {
-
-    return Ebean.getExpressionFactory().disjunction(query);
-  }
-}
@@ -1,8 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * An expression that is part of a WHERE or HAVING clause.
- */
-public interface Expression {
-
-}
@@ -1,419 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.search.Match;
-import com.avaje.ebean.search.MultiMatch;
-import com.avaje.ebean.search.TextCommonTerms;
-import com.avaje.ebean.search.TextQueryString;
-import com.avaje.ebean.search.TextSimple;
-
-import java.util.Collection;
-import java.util.List;
-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 class="code">
- *  // Example: fetch orders where status equals new or orderDate > lastWeek.
- *  
- * Expression newOrLastWeek = 
- *   Expr.or(Expr.eq(&quot;status&quot;, Order.Status.NEW), 
- *           Expr.gt(&quot;orderDate&quot;, lastWeek));
- * 
- * Query&lt;Order&gt; query = Ebean.createQuery(Order.class);
- * query.where().add(newOrLastWeek);
- * List&lt;Order&gt; list = query.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);
-
-  /**
-   * 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 Equal To that allows for named parameter use.
-   */
-  Expression ieqObject(String propertyName, 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 - 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 - 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 - 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);
-
-  /**
-   * 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 list of Id values.
-   */
-  Expression idIn(List<?> idList);
-
-  /**
-   * 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 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);
-
-}
@@ -1,264 +0,0 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-
-/**
- * Defines the configuration options for a "query fetch" or a
- * "lazy loading fetch". This gives you the ability to use multiple smaller
- * queries to populate an object graph as opposed to a single large query.
- * <p>
- * The primary goal is to provide efficient ways of loading complex object
- * graphs avoiding SQL Cartesian product and issues around populating object
- * graphs that have multiple *ToMany relationships.
- * </p>
- * <p>
- * It also provides the ability to control the lazy loading queries (batch size,
- * selected properties and fetches) to avoid N+1 queries etc.
- * <p>
- * There can also be cases loading across a single OneToMany where 2 SQL queries
- * using Ebean FetchConfig.query() can be more efficient than one SQL query.
- * When the "One" side is wide (lots of columns) and the cardinality difference
- * is high (a lot of "Many" beans per "One" bean) then this can be more
- * efficient loaded as 2 SQL queries.
- * </p>
- * 
- * <pre>{@code
- * // Normal fetch join results in a single SQL query
- * List<Order> list = Ebean.find(Order.class).fetch("details").findList();
- * 
- * // Find Orders join details using a single SQL query
- * }</pre>
- * <p>
- * Example: Using a "query join" instead of a "fetch join" we instead use 2 SQL queries
- * </p>
- * 
- * <pre>{@code
- * // This will use 2 SQL queries to build this object graph
- * List<Order> list =
- *     Ebean.find(Order.class)
- *         .fetch("details", new FetchConfig().query())
- *         .findList();
- * 
- * // query 1) find order
- * // query 2) find orderDetails where order.id in (?,?...) // first 100 order id's
- * }</pre>
- * <p>
- * Example: Using 2 "query joins"
- * </p>
- * 
- * <pre>{@code
- * // This will use 3 SQL queries to build this object graph
- * List<Order> list =
- *     Ebean.find(Order.class)
- *         .fetch("details", new FetchConfig().query())
- *         .fetch("customer", new FetchConfig().queryFirst(5))
- *         .findList();
- * 
- * // query 1) find order
- * // query 2) find orderDetails where order.id in (?,?...) // first 100 order id's
- * // query 3) find customer where id in (?,?,?,?,?) // first 5 customers
- * }</pre>
- * <p>
- * Example: Using "query joins" and partial objects
- * </p>
- * 
- * <pre>{@code
- * // This will use 3 SQL queries to build this object graph
- * List<Order> list =
- *     Ebean.find(Order.class)
- *         .select("status, shipDate")
- *         .fetch("details", "quantity, price", new FetchConfig().query())
- *         .fetch("details.product", "sku, name")
- *         .fetch("customer", "name", new FetchConfig().queryFirst(5))
- *         .fetch("customer.contacts")
- *         .fetch("customer.shippingAddress")
- *         .findList();
- * 
- * // query 1) find order (status, shipDate)
- * // query 2) find orderDetail (quantity, price) fetch product (sku, name) where
- * // order.id in (?,? ...)
- * // query 3) find customer (name) fetch contacts (*) fetch shippingAddress (*)
- * // where id in (?,?,?,?,?)
- * 
- * // Note: the fetch of "details.product" is automatically included into the
- * // fetch of "details"
- * //
- * // Note: the fetch of "customer.contacts" and "customer.shippingAddress"
- * // are automatically included in the fetch of "customer"
- * }</pre>
- * <p>
- * You can use query() and lazy together on a single join. The query is executed
- * immediately and the lazy defines the batch size to use for further lazy
- * loading (if lazy loading is invoked).
- * </p>
- * 
- * <pre>{@code
- * List<Order> list =
- *     Ebean.find(Order.class)
- *         .fetch("customer", new FetchConfig().query(10).lazy(5))
- *         .findList();
- * 
- * // query 1) find order
- * // query 2) find customer where id in (?,?,?,?,?,?,?,?,?,?) // first 10 customers
- * // .. then if lazy loading of customers is invoked
- * // .. use a batch size of 5 to load the customers
- * 
- * }</pre>
- * 
- * <p>
- * Example of controlling the lazy loading query:
- * </p>
- * <p>
- * This gives us the ability to optimise the lazy loading query for a given use
- * case.
- * </p>
- * 
- * <pre>{@code
- * List<Order> list = Ebean.find(Order.class)
- *   .fetch("customer","name", new FetchConfig().lazy(5))
- *   .fetch("customer.contacts","contactName, phone, email")
- *   .fetch("customer.shippingAddress")
- *   .where().eq("status",Order.Status.NEW)
- *   .findList();
- * 
- * // query 1) find order where status = Order.Status.NEW
- * //  
- * // .. if lazy loading of customers is invoked 
- * // .. use a batch size of 5 to load the customers
- * 
- * }</pre>
- * 
- * @author mario
- * @author rbygrave
- */
-public class FetchConfig implements Serializable {
-
-  private static final long serialVersionUID = 1L;
-
-  private int lazyBatchSize = -1;
-
-  private int queryBatchSize = -1;
-
-  private boolean queryAll;
-
-  /**
-   * Construct the fetch configuration object.
-   */
-  public FetchConfig() {
-  }
-
-  /**
-   * Specify that this path should be lazy loaded using the default batch load
-   * size.
-   */
-  public FetchConfig lazy() {
-    this.lazyBatchSize = 0;
-    this.queryAll = false;
-    return this;
-  }
-
-  /**
-   * Specify that this path should be lazy loaded with a specified batch size.
-   * 
-   * @param lazyBatchSize
-   *          the batch size for lazy loading
-   */
-  public FetchConfig lazy(int lazyBatchSize) {
-    this.lazyBatchSize = lazyBatchSize;
-    this.queryAll = false;
-    return this;
-  }
-
-  /**
-   * 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.
-   * </p>
-   */
-  public FetchConfig query() {
-    this.queryBatchSize = 0;
-    this.queryAll = true;
-    return this;
-  }
-
-  /**
-   * 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>
-   * <p>
-   * This will load all beans on this path eagerly unless a {@link #lazy(int)}
-   * is also used.
-   * </p>
-   * 
-   * @param queryBatchSize
-   *          the batch size used to load beans on this path
-   */
-  public FetchConfig query(int queryBatchSize) {
-    this.queryBatchSize = queryBatchSize;
-    // queryAll true as long as a lazy batch size has not already been set
-    this.queryAll = (lazyBatchSize == -1);
-    return this;
-  }
-
-  /**
-   * 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.
-   * </p>
-   * 
-   * @param queryBatchSize
-   *          the number of parent beans this path is populated for
-   */
-  public FetchConfig queryFirst(int queryBatchSize) {
-    this.queryBatchSize = queryBatchSize;
-    this.queryAll = false;
-    return this;
-  }
-
-  /**
-   * Return the batch size for lazy loading.
-   */
-  public int getLazyBatchSize() {
-    return lazyBatchSize;
-  }
-  
-  /**
-   * Return the batch size for separate query load.
-   */
-  public int getQueryBatchSize() {
-    return queryBatchSize;
-  }
-
-  /**
-   * Return true if the query fetch should fetch 'all' rather than just the
-   * 'first' batch.
-   */
-  public boolean isQueryAll() {
-    return queryAll;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-
-    FetchConfig that = (FetchConfig) o;
-    if (lazyBatchSize != that.lazyBatchSize) return false;
-    if (queryBatchSize != that.queryBatchSize) return false;
-    return queryAll == that.queryAll;
-  }
-
-  @Override
-  public int hashCode() {
-    int result = lazyBatchSize;
-    result = 92821 * result + queryBatchSize;
-    result = 92821 * result + (queryAll ? 1 : 0);
-    return result;
-  }
-}
@@ -1,26 +0,0 @@
-package com.avaje.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);
-}
@@ -1,197 +0,0 @@
-package com.avaje.ebean;
-
-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>
- * 
- * <pre class="code">
- * 
- * // get a list of entities (query execution statistics in this case)
- * 
- * List&lt;MetaQueryStatistic&gt; list =
- *     Ebean.find(MetaQueryStatistic.class).findList();
- * 
- * long nowMinus24Hrs = System.currentTimeMillis() - 24 * (1000 * 60 * 60);
- * 
- * // sort and filter the list returning a filtered list...
- * 
- * List&lt;MetaQueryStatistic&gt; filteredList =
- *     Ebean.filter(MetaQueryStatistic.class)
- *         .sort(&quot;avgTimeMicros desc&quot;)
- *         .gt(&quot;executionCount&quot;, 0)
- *         .gt(&quot;lastQueryTime&quot;, nowMinus24Hrs)
- *         .eq(&quot;autoTuned&quot;, 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>
- * 
- * <pre>
- * // 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 class="code">
- * 
- * // get a list of entities (query execution statistics)
- * 
- * List&lt;Order&gt; orders =
- *     Ebean.find(Order.class).findList();
- * 
- * // Apply a filter...
- * 
- * List&lt;Order&gt; filteredOrders =
- *     Ebean.filter(Order.class)
- *         .startsWith(&quot;customer.name&quot;, &quot;Rob&quot;)
- *         .eq(&quot;customer.shippingAddress.city&quot;, &quot;Auckland&quot;)
- *         .filter(orders);
- * 
- * </pre>
- * 
- * @param <T>
- *          the entity bean type
- */
-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 Ebean#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);
-
-}
@@ -1,167 +0,0 @@
-package com.avaje.ebean;
-
-import org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-
-/**
- * Intended to be used as a base class for 'Finder' implementations that can then
- * be injected or used as public static fields on the associated entity bean.
- * <p>
- * These 'finders' are a place to organise all the finder methods for that bean type
- * and specific finder methods are expected to be added (find by unique properties etc).
- * </p>
- *
- * <h3>Testing</h3>
- * <p>
- *   For testing the mocki-ebean project has the ability to replace the finder implementation
- *
- * </p>
- * <pre>{@code
- *
- * public class CustomerFinder extends Finder<Customer> {
- *
- *   public CustomerFinder() {
- *     super(Customer.class);
- *   }
- *
- *   // Add your customer finder methods ...
- *
- *   public Customer byName(String name) {
- *     return query().eq("name", name).findUnique();
- *   }
- *
- *   public List<Customer> findNew() {
- *     return query()
- *       .eq("status", Customer.Status.NEW)
- *       .orderBy("name")
- *       .findList()
- *   }
- * }
- *
- * @Entity
- * public class Customer extends BaseModel {
- *
- *   public static final CustomerFinder find = new CustomerFinder();
- *   ...
- *
- * }</pre>
- */
-public class Finder<I, T> {
-
-  /**
-   * The entity bean type.
-   */
-  private final Class<T> type;
-
-  /**
-   * The name of the EbeanServer, null for the default server.
-   */
-  private final String serverName;
-
-  /**
-   * Create with the type of the entity bean.
-   *
-   * <pre>{@code
-   *
-   * public class CustomerFinder extends Finder<Customer> {
-   *
-   *   public CustomerFinder() {
-   *     super(Customer.class);
-   *   }
-   *
-   *   // ... add extra customer specific finder methods
-   * }
-   *
-   * @Entity
-   * public class Customer extends BaseModel {
-   *
-   *   public static final CustomerFinder find = new CustomerFinder();
-   *   ...
-   *
-   * }</pre>
-   */
-  public Finder(Class<T> type) {
-    this.type = type;
-    this.serverName = null;
-  }
-
-  /**
-   * Create with the type of the entity bean and specific server name.
-   */
-  public Finder(Class<T> type, String serverName) {
-    this.type = type;
-    this.serverName = serverName;
-  }
-
-  /**
-   * Return the underlying 'default' EbeanServer.
-   *
-   * <p>
-   * This provides full access to the API such as explicit transaction demarcation etc.
-   *
-   */
-  public EbeanServer db() {
-    return Ebean.getServer(serverName);
-  }
-
-  /**
-   * Return typically a different EbeanServer to the default.
-   * <p>
-   * This is equivalent to {@link Ebean#getServer(String)}
-   *
-   * @param server
-   *          The name of the EbeanServer. If this is null then the default EbeanServer is
-   *          returned.
-   */
-  public EbeanServer db(String server) {
-    return Ebean.getServer(server);
-  }
-
-  /**
-   * Creates an entity reference for this ID.
-   *
-   * <p>
-   * Equivalent to {@link EbeanServer#getReference(Class, Object)}
-   */
-  public T ref(I id) {
-    return db().getReference(type, id);
-  }
-
-  /**
-   * Retrieves an entity by ID.
-   *
-   * <p>
-   * Equivalent to {@link EbeanServer#find(Class, Object)}
-   */
-  @Nullable
-  public T byId(I id) {
-    return db().find(type, id);
-  }
-
-  /**
-   * Delete a bean by Id.
-   * <p>
-   * Equivalent to {@link EbeanServer#delete(Class, Object)}
-   */
-  public void deleteById(I id) {
-    db().delete(type, id);
-  }
-
-  /**
-   * Retrieves all entities of the given type.
-   */
-  public List<T> all() {
-    return query().findList();
-  }
-
-  /**
-   * Creates a query.
-   * <p>
-   * Equivalent to {@link EbeanServer#find(Class)}
-   */
-  public Query<T> query() {
-    return db().find(type);
-  }
-
-}
@@ -1,34 +0,0 @@
-package com.avaje.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>
- * 
- * @author rbygrave
- */
-public interface FutureIds<T> extends Future<List<Object>> {
-
-  /**
-   * Returns the original query used to fetch the Id's.
-   */
-  Query<T> getQuery();
-
-  /**
-   * Return the list of Id's which could be partially populated.
-   * <p>
-   * That is the query getting the id's could still be running and adding id's
-   * to this list.
-   * </p>
-   * <p>
-   * To get the list of Id's ensuring the query has finished use the
-   * {@link Future#get()} method instead of this one.
-   * </p>
-   */
-  List<Object> getPartialIds();
-}
@@ -1,75 +0,0 @@
-package com.avaje.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 = Ebean.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;
-
-}
@@ -1,15 +0,0 @@
-package com.avaje.ebean;
-
-import java.util.concurrent.Future;
-
-/**
- * Represents the result of a background query execution for the total row count
- * for a query.
- * <p>
- * It extends the java.util.concurrent.Future.
- * </p>
- * 
- * @author rbygrave
- */
-public interface FutureRowCount<T> extends Future<Integer> {
-}
@@ -1,147 +0,0 @@
-package com.avaje.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 =
- *     Ebean.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 =
- *     Ebean.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 =
- *  Ebean.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),
-
-    /**
-     * Text search AND group.
-     */
-    MUST("must", "", true),
-
-    /**
-     * Text search NOT group.
-     */
-    MUST_NOT("must_not", "", true),
-
-    /**
-     * Text search OR group.
-     */
-    SHOULD("should", "", true);
-
-    private String prefix;
-    private String literal;
-    private 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;
-    }
-
-  }
-
-}
@@ -1,35 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to specify the type of like matching used.
- */
-public enum LikeType {
-
-  /**
-   * You need to put in your own wildcards.
-   */
-  RAW,
-
-  /**
-   * The % wildcard is added to the end of the search word.
-   */
-  STARTS_WITH,
-
-  /**
-   * The % wildcard is added to the beginning of the search word.
-   */
-  ENDS_WITH,
-
-  /**
-   * The % wildcard is added to the beginning and end of the search word.
-   */
-  CONTAINS,
-
-  /**
-   * Uses equal to rather than a LIKE with wildcards.
-   * <p>
-   * This is mainly here to be available for use with ExampleExpression.
-   * </p>
-   */
-  EQUAL_TO
-}
@@ -1,908 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.bean.EntityBean;
-import com.avaje.ebean.util.ClassUtil;
-import org.jetbrains.annotations.Nullable;
-
-import javax.persistence.MappedSuperclass;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * A MappedSuperclass base class that provides convenience methods for inserting, updating and
- * deleting beans.
- * 
- * <p>
- * By having your entity beans extend this it provides a 'Active Record' style programming model for
- * Ebean users.
- * 
- * <p>
- * Note that there is a avaje-ebeanorm-mocker project that enables you to use Mockito or similar
- * tools to still mock out the underlying 'default EbeanServer' for testing purposes.
- * 
- * <p>
- * You may choose not use this Model mapped superclass if you don't like the 'Active Record' style
- * or if you believe it 'pollutes' your entity beans.
- *
- * <p>
- * You can use Dependency Injection like Guice or Spring to construct and wire a EbeanServer instance
- * and have that same instance used with this Model and Finder. The way that works is that when the
- * DI container creates the EbeanServer instance it can be registered with the Ebean singleton. In this
- * way the EbeanServer instance can be injected as per normal Guice / Spring dependency injection and
- * that same instance also used to support the Model and Finder active record style.
- *
- * <p>
- * If you choose to use the Model mapped superclass you will probably also chose to additionally add
- * a {@link Find} as a public static field to complete the active record pattern and provide a
- * relatively nice clean way to write queries.
- *
- * <h3>Typical common @MappedSuperclass</h3>
- * <pre>{@code
- *
- *     // Typically there is a common base model that has some
- *     // common properties like the ones below
- *
- *     @MappedSuperclass
- *     public class BaseModel extends Model {
- *
- *       @Id Long id;
- *
- *       @Version Long version;
- *
- *       @CreatedTimestamp Timestamp whenCreated;
- *
- *       @UpdatedTimestamp Timestamp whenUpdated;
- *
- *       ...
- *
- * }</pre>
- *
- * <h3>Extend the Model</h3>
- * <pre>{@code
- *
- *     // Extend the mappedSuperclass
- *
- *     @Entity @Table(name="oto_account")
- *     public class Customer extends BaseModel {
- *
- *       // Add a static Find
- *       // ... with Long being the type of our @Id property.
- *       // ... Note the {} at the end as Find is an abstract class.
- *
- *       public static final Find<Long,Account> find = new Find<Long,Account>(){};
- *
- *       String name;
- *       ...
- *     }
- *
- * }</pre>
- *
- * <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>
- *
- * <h3>Find byId</h3>
- * <pre>{@code
- *
- *     // find byId
- *     Customer customer = Customer.find.byId(42);
- *
- * }</pre>
- *
- * <h3>Find where</h3>
- * <pre>{@code
- *
- *     // find where ...
- *     List<Customer> customers =
- *         Customer.find
- *         .where().gt("startDate", lastMonth)
- *         .findList();
- *
- * }</pre>
- */
-@MappedSuperclass
-public abstract class Model {
-
-  /**
-   * Return the underlying 'default' EbeanServer.
-   * 
-   * <p>
-   * This provides full access to the API such as explicit transaction demarcation etc.
-   * 
-   * <p>
-   * Example:
-   * <pre>{@code
-   *
-   * Transaction transaction = Customer.db().beginTransaction();
-   * try {
-   * 
-   *   // turn off cascade persist for this transaction
-   *   transaction.setPersistCascade(false);
-   * 
-   *   // extra control over jdbc batching for this transaction
-   *   transaction.setBatchGetGeneratedKeys(false);
-   *   transaction.setBatchMode(true);
-   *   transaction.setBatchSize(20);
-   * 
-   *   Customer customer = new Customer();
-   *   customer.setName(&quot;Roberto&quot;);
-   *   customer.save();
-   * 
-   *   Customer otherCustomer = new Customer();
-   *   otherCustomer.setName("Franko");
-   *   otherCustomer.save();
-   * 
-   *   transaction.commit();
-   * 
-   * } finally {
-   *   transaction.end();
-   * }
-   * 
-   * }</pre>
-   */
-  public static EbeanServer db() {
-    return Ebean.getDefaultServer();
-  }
-
-  /**
-   * Return a named EbeanServer that is typically different to the default server.
-   * 
-   * <p>
-   * If you are using multiple databases then each database has a name and maps to a single
-   * EbeanServer. You can use this method to get an EbeanServer for another database.
-   * 
-   * @param server
-   *          The name of the EbeanServer. If this is null then the default EbeanServer is returned.
-   */
-  public static EbeanServer db(String server) {
-    return Ebean.getServer(server);
-  }
-
-  /**
-   * Marks the entity bean as dirty.
-   * <p>
-   * This is used so that when a bean that is otherwise unmodified is updated the version
-   * property is updated.
-   * <p>
-   * An unmodified bean that is saved or updated is normally skipped and this marks the bean as
-   * dirty so that it is not skipped.
-   * 
-   * <pre>{@code
-   * 
-   * Customer customer = Customer.find.byId(id);
-   * 
-   * // mark the bean as dirty so that a save() or update() will
-   * // increment the version property
-   * customer.markAsDirty();
-   * customer.save();
-   * 
-   * }</pre>
-   *
-   * @see EbeanServer#markAsDirty(Object)
-   */
-  public void markAsDirty() {
-    db().markAsDirty(this);
-  }
-
-  /**
-   * Mark the property as unset or 'not loaded'.
-   * <p>
-   *   This would be used to specify a property that we did not wish to include in a stateless update.
-   * </p>
-   * <pre>{@code
-   *
-   *   // populate an entity bean from JSON or whatever
-   *   User user = ...;
-   *
-   *   // mark the email property as 'unset' so that it is not
-   *   // included in a 'stateless update'
-   *   user.markPropertyUnset("email");
-   *
-   *   user.update();
-   *
-   * }</pre>
-   *
-   * @param propertyName the name of the property on the bean to be marked as 'unset'
-   */
-  public void markPropertyUnset(String propertyName) {
-    ((EntityBean)this)._ebean_getIntercept().setPropertyLoaded(propertyName, false);
-  }
-
-  /**
-   * Insert or update this entity depending on its state.
-   * 
-   * <p>
-   * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
-   * insert or an update based on that.
-   *
-   * @see EbeanServer#save(Object)
-   */
-  public void save() {
-    db().save(this);
-  }
-
-  /**
-   * Update this entity.
-   *
-   * @see EbeanServer#update(Object)
-   */
-  public void update() {
-    db().update(this);
-  }
-
-  /**
-   * Insert this entity.
-   *
-   * @see EbeanServer#insert(Object)
-   */
-  public void insert() {
-    db().insert(this);
-  }
-
-  /**
-   * Delete this bean.
-   * <p>
-   * This will return true if the bean was deleted successfully or JDBC batch is being used.
-   * </p>
-   * <p>
-   * If there is no current transaction one will be created and committed for
-   * you automatically.
-   * </p>
-   * <p>
-   * If the Bean does not have a version property (or loaded version property) and
-   * the bean does not exist then this returns false indicating that nothing was
-   * deleted. Note that, if JDBC batch mode is used then this always returns true.
-   * </p>
-   *
-   * @see EbeanServer#delete(Object)
-   */
-  public boolean delete() {
-    return db().delete(this);
-  }
-
-  /**
-   * Delete a bean permanently without soft delete.
-   * <p>
-   * This is used when the bean contains a <code>@SoftDelete</code> property and we
-   * want to perform a hard/permanent delete.
-   * </p>
-   *
-   * @see EbeanServer#deletePermanent(Object)
-   */
-  public boolean deletePermanent() {
-    return db().deletePermanent(this);
-  }
-
-  /**
-   * Perform an update using this entity against the specified server.
-   */
-  public void update(String server) {
-    db(server).update(this);
-  }
-
-  /**
-   * Perform an insert using this entity against the specified server.
-   */
-  public void insert(String server) {
-    db(server).insert(this);
-  }
-
-  /**
-   * Perform a delete using this entity against the specified server.
-   */
-  public boolean delete(String server) {
-    return db(server).delete(this);
-  }
-
-  /**
-   * Refreshes this entity from the database.
-   *
-   * @see EbeanServer#refresh(Object)
-   */
-  public void refresh() {
-    db().refresh(this);
-  }
-
-  /**
-   * A concrete implementation of Find.
-   * <p>
-   * It should be preferred to use {@link Find} instead of Finder as that can use reflection to determine the class
-   * literal type of the entity bean.
-   * </p>
-   * @param <I> type of the Id property
-   * @param <T> type of the entity bean
-   */
-  public static class Finder<I, T> extends Find<I, T> {
-
-    /**
-     * Create with the type of the entity bean.
-     *
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   public static final Finder<Long,Customer> find = new Finder<Long,Customer>(Customer.class);
-     *   ...
-     *
-     * }</pre>
-     *
-     * <p/>
-     * The preferred approach is to instead use <code>Find</code> as below. This approach is more DRY in that it does
-     * not require the class literal Customer.class to be passed into the constructor.
-     *
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-     *   ...
-     *
-     * }</pre>
-     */
-    public Finder(Class<T> type) {
-      super(null, type);
-    }
-
-    /**
-     * Create with the type of the entity bean and specific server name.
-     */
-    public Finder(String serverName, Class<T> type) {
-      super(serverName, type);
-    }
-
-  }
-
-  /**
-   * Helper object for performing queries.
-   * 
-   * <p>
-   * Typically a Find instance is defined as a public static field on an entity bean class to provide a
-   * nice way to write queries.
-   *
-   * <h3>Example use:</h3>
-   *
-   * <pre>{@code
-   *
-   * @Entity
-   * public class Customer extends BaseModel {
-   *
-   *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-   *
-   *   ...
-   *
-   * }</pre>
-   * <p/>
-   * This enables you to write code like:
-   * <pre>{@code
-   *
-   * Customer customer = Customer.find.byId(42L);
-   *
-   * List<Customer> customers =
-   *     Customer.find
-   *         .select("name, dateOfBirth")
-   *         .findList();
-   *
-   * }</pre>
-   *
-   * <h3>Kotlin</h3>
-   * In Kotlin you would typically create Find as a companion object.
-   * <pre>{@code
-   *
-   *   // kotlin
-   *   companion object : Model.Find<Long, Product>() {}
-   *
-   * }</pre>
-   * @param <I>
-   *          The Id type. This is most often a {@link Long} but is also often a {@link UUID} or
-   *          {@link String}.
-   *
-   * @param <T>
-   *          The entity bean type
-   */
-  public static abstract class Find<I, T> {
-
-    /**
-     * The entity bean type.
-     */
-    private final Class<T> type;
-
-    /**
-     * The name of the EbeanServer, null for the default server.
-     */
-    private final String serverName;
-
-    /**
-     * Creates a finder for entity of type <code>T</code> with ID of type <code>I</code>.
-     * <p/>
-     * Typically you create Find as a public static field on each entity bean as the example below.
-     *
-     * <p/>
-     * Note that Find is an abstract class and hence <code>{}</code> is required. This is done so
-     * that the type (class literal) of the entity bean can be derived from the generics parameter.
-     *
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   // Note the trailing {} as Find is an abstract class.
-     *   // We do this so that we can derive the type literal Customer.class
-     *   // via reflection
-     *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-     *   ...
-     *
-     * }</pre>
-     * <p/>
-     * This enables you to write code like:
-     * <pre>{@code
-     *
-     * Customer customer = Customer.find.byId(42L);
-     *
-     * List<Customer> customers =
-     *     Customer.find
-     *        .select("name, email, dateOfBirth")
-     *        .findList();
-     *
-     * }</pre>
-     *
-     * <h3>Kotlin</h3>
-     * In Kotlin you would typically create it as a companion object.
-     *
-     * <pre>{@code
-     *
-     *   // kotlin
-     *   companion object : Model.Find<Long, Product>() {}
-     *
-     * }</pre>
-     */
-    @SuppressWarnings("unchecked")
-    public Find() {
-      this.serverName = null;
-      this.type = (Class<T>)ClassUtil.getSecondArgumentType(getClass());
-    }
-
-    /**
-     * Construct passing the class literal type of the entity type.
-     */
-    protected Find(String serverName, Class<T> type) {
-      this.serverName = serverName;
-      this.type = type;
-    }
-
-    /**
-     * Return the underlying 'default' EbeanServer.
-     * 
-     * <p>
-     * This provides full access to the API such as explicit transaction demarcation etc.
-     * 
-     */
-    public EbeanServer db() {
-      return Ebean.getServer(serverName);
-    }
-
-    /**
-     * Return typically a different EbeanServer to the default.
-     * <p>
-     * This is equivilent to {@link Ebean#getServer(String)}
-     * 
-     * @param server
-     *          The name of the EbeanServer. If this is null then the default EbeanServer is
-     *          returned.
-     */
-    public EbeanServer db(String server) {
-      return Ebean.getServer(server);
-    }
-
-    /**
-     * Creates a Finder for the named EbeanServer.
-     *
-     * <p>
-     * Create and return a new Finder for a different server.
-     */
-    public Finder<I, T> on(String server) {
-      return new Finder<I, T>(server, type);
-    }
-
-    /**
-     * Delete a bean by Id.
-     * <p>
-     * Equivalent to {@link EbeanServer#delete(Class, Object)}
-     */
-    public void deleteById(I id) {
-      db().delete(type, id);
-    }
-
-    /**
-     * Retrieves all entities of the given type.
-     * 
-     * <p>
-     * This is the same as (synonym for) {@link #findList()}
-     */
-    public List<T> all() {
-      return findList();
-    }
-
-    /**
-     * Retrieves an entity by ID.
-     * 
-     * <p>
-     * Equivalent to {@link EbeanServer#find(Class, Object)}
-     */
-    @Nullable
-    public T byId(I id) {
-      return db().find(type, id);
-    }
-
-    /**
-     * Creates an entity reference for this ID.
-     * 
-     * <p>
-     * Equivalent to {@link EbeanServer#getReference(Class, Object)}
-     */
-    public T ref(I id) {
-      return db().getReference(type, id);
-    }
-
-    /**
-     * Creates a filter for sorting and filtering lists of entities locally without going back to
-     * the database.
-     * <p>
-     * Equivalent to {@link EbeanServer#filter(Class)}
-     */
-    public Filter<T> filter() {
-      return db().filter(type);
-    }
-
-    /**
-     * Creates a query.
-     * <p>
-     * Equivalent to {@link EbeanServer#find(Class)}
-     */
-    public Query<T> query() {
-      return db().find(type);
-    }
-
-    /**
-     * Creates a query applying the path properties to set the select and fetch clauses.
-     * <p>
-     * Equivalent to {@link Query#apply(FetchPath)}
-     */
-    public Query<T> apply(FetchPath fetchPath) {
-      return db().find(type).apply(fetchPath);
-    }
-
-    /**
-     * Returns the next identity value.
-     * 
-     * @see EbeanServer#nextId(Class)
-     */
-    @SuppressWarnings("unchecked")
-    public I nextId() {
-      return (I) db().nextId(type);
-    }
-
-    /**
-     * Executes a query and returns the results as a list of IDs.
-     * <p>
-     * Equivalent to {@link Query#findIds()}
-     */
-    public List<Object> findIds() {
-      return query().findIds();
-    }
-
-    /**
-     * Execute the query consuming each bean one at a time.
-     * <p>
-     * This is generally used to process large queries where unlike findList
-     * you do not want to hold all the results in memory at once but instead
-     * process them one at a time (requiring far less memory).
-     * </p>
-     * Equivalent to {@link Query#findEach(QueryEachConsumer)}
-     */
-    public void findEach(QueryEachConsumer<T> consumer) {
-      query().findEach(consumer);
-    }
-
-    /**
-     * Execute the query consuming each bean one at a time.
-     * <p>
-     * Equivalent to {@link Query#findEachWhile(QueryEachWhileConsumer)}
-     * <p>
-     * This is similar to #findEach except that you return boolean
-     * true to continue processing beans and return false to stop
-     * processing early.
-     * </p>
-     * <p>
-     * This is generally used to process large queries where unlike findList
-     * you do not want to hold all the results in memory at once but instead
-     * process them one at a time (requiring far less memory).
-     * </p>
-     * Equivalent to {@link Query#findEachWhile(QueryEachWhileConsumer)}
-     */
-    public void findEachWhile(QueryEachWhileConsumer<T> consumer) {
-      query().findEachWhile(consumer);
-    }
-
-    /**
-     * Retrieves all entities of the given type.
-     * <p>
-     * The same as {@link #all()}
-     * <p>
-     * Equivalent to {@link Query#findList()}
-     */
-    public List<T> findList() {
-      return query().findList();
-    }
-
-    /**
-     * Returns all the entities of the given type as a set.
-     * <p>
-     * Equivalent to {@link Query#findSet()}
-     */
-    public Set<T> findSet() {
-      return query().findSet();
-    }
-
-    /**
-     * Retrieves all entities of the given type as a map of objects.
-     * <p>
-     * Equivalent to {@link Query#findMap()}
-     */
-    public Map<?, T> findMap() {
-      return query().findMap();
-    }
-
-    /**
-     * Executes the query and returns the results as a map of the objects specifying the map key
-     * property.
-     * <p>
-     * Equivalent to {@link Query#findMap(String, Class)}
-     */
-    public <K> Map<K, T> findMap(String keyProperty, Class<K> keyType) {
-      return query().findMap(keyProperty, keyType);
-    }
-
-    /**
-     * Executes a find row count query in a background thread.
-     * <p>
-     * Equivalent to {@link Query#findFutureCount()}
-     */
-    public FutureRowCount<T> findFutureCount() {
-      return query().findFutureCount();
-    }
-
-    /**
-     * Deprecated in favor of findFutureCount().
-     * <p>
-     * Equivalent to {@link Query#findFutureCount()}
-     */
-    public FutureRowCount<T> findFutureRowCount() {
-      return query().findFutureCount();
-    }
-
-    /**
-     * Returns the total number of entities for this type. *
-     * <p>
-     * Equivalent to {@link Query#findCount()}
-     */
-    public int findCount() {
-      return query().findCount();
-    }
-
-    /**
-     * Deprecated in favor of findCount().
-     * @deprecated
-     */
-    public int findRowCount() {
-      return query().findCount();
-    }
-
-    /**
-     * Returns the <code>ExpressionFactory</code> used by this query.
-     */
-    public ExpressionFactory getExpressionFactory() {
-      return query().getExpressionFactory();
-    }
-
-    /**
-     * Explicitly sets a comma delimited list of the properties to fetch on the 'main' entity bean,
-     * to load a partial object.
-     * <p>
-     * Equivalent to {@link Query#select(String)}
-     */
-    public Query<T> select(String fetchProperties) {
-      return query().select(fetchProperties);
-    }
-
-    /**
-     * Specifies a path to load including all its properties.
-     * <p>
-     * Equivalent to {@link Query#fetch(String)}
-     */
-    public Query<T> fetch(String path) {
-      return query().fetch(path);
-    }
-
-    /**
-     * Additionally specifies a <code>FetchConfig</code> to specify a 'query join' and/or define the
-     * lazy loading query.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, FetchConfig)}
-     */
-    public Query<T> fetch(String path, FetchConfig joinConfig) {
-      return query().fetch(path, joinConfig);
-    }
-
-    /**
-     * Specifies a path to fetch with a specific list properties to include, to load a partial
-     * object.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, String)}
-     */
-    public Query<T> fetch(String path, String fetchProperties) {
-      return query().fetch(path, fetchProperties);
-    }
-
-    /**
-     * Additionally specifies a <code>FetchConfig</code> to use a separate query or lazy loading to
-     * load this path.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, String, FetchConfig)}
-     */
-    public Query<T> fetch(String assocProperty, String fetchProperties, FetchConfig fetchConfig) {
-      return query().fetch(assocProperty, fetchProperties, fetchConfig);
-    }
-
-    /**
-     * Adds expressions to the <code>where</code> clause with the ability to chain on the
-     * <code>ExpressionList</code>.
-     * <p>
-     * Equivalent to {@link Query#where()}
-     */
-    public ExpressionList<T> where() {
-      return query().where();
-    }
-
-    /**
-     * Returns the <code>order by</code> clause so that you can append an ascending or descending
-     * property to the <code>order by</code> clause.
-     * <p>
-     * This is exactly the same as {@link #orderBy}.
-     * <p>
-     * Equivalent to {@link Query#order()}
-     */
-    public OrderBy<T> order() {
-      return query().order();
-    }
-
-    /**
-     * Sets the <code>order by</code> clause, replacing the existing <code>order by</code> clause if
-     * there is one.
-     * <p>
-     * This is exactly the same as {@link #orderBy(String)}.
-     */
-    public Query<T> order(String orderByClause) {
-      return query().order(orderByClause);
-    }
-
-    /**
-     * Returns the <code>order by</code> clause so that you can append an ascending or descending
-     * property to the <code>order by</code> clause.
-     * <p>
-     * This is exactly the same as {@link #order}.
-     * <p>
-     * Equivalent to {@link Query#orderBy()}
-     */
-    public OrderBy<T> orderBy() {
-      return query().orderBy();
-    }
-
-    /**
-     * Set the <code>order by</code> clause replacing the existing <code>order by</code> clause if
-     * there is one.
-     * <p>
-     * This is exactly the same as {@link #order(String)}.
-     */
-    public Query<T> orderBy(String orderByClause) {
-      return query().orderBy(orderByClause);
-    }
-
-    /**
-     * Sets the first row to return for this query.
-     * <p>
-     * Equivalent to {@link Query#setFirstRow(int)}
-     */
-    public Query<T> setFirstRow(int firstRow) {
-      return query().setFirstRow(firstRow);
-    }
-
-    /**
-     * Sets the maximum number of rows to return in the query.
-     * <p>
-     * Equivalent to {@link Query#setMaxRows(int)}
-     */
-    public Query<T> setMaxRows(int maxRows) {
-      return query().setMaxRows(maxRows);
-    }
-
-    /**
-     * Sets the ID value to query.
-     * 
-     * <p>
-     * Use this to perform a find byId query but with additional control over the query such as
-     * using select and fetch to control what parts of the object graph are returned.
-     * <p>
-     * Equivalent to {@link Query#setId(Object)}
-     */
-    public Query<T> setId(Object id) {
-      return query().setId(id);
-    }
-
-    /**
-     * Create and return a new query based on the <code>RawSql</code>.
-     * <p>
-     * Equivalent to {@link Query#setRawSql(RawSql)}
-     */
-    public Query<T> setRawSql(RawSql rawSql) {
-      return query().setRawSql(rawSql);
-    }
-
-    /**
-     * Create a query with explicit 'AutoTune' use.
-     */
-    public Query<T> setAutoTune(boolean autoTune) {
-      return query().setAutoTune(autoTune);
-    }
-
-    /**
-     * Create a query with the select with "for update" specified.
-     * 
-     * <p>
-     * This will typically create row level database locks on the selected rows.
-     */
-    public Query<T> setForUpdate(boolean forUpdate) {
-      return query().setForUpdate(forUpdate);
-    }
-
-    /**
-     * Create a query specifying whether the returned beans will be read-only.
-     */
-    public Query<T> setReadOnly(boolean readOnly) {
-      return query().setReadOnly(readOnly);
-    }
-
-    /**
-     * Create a query specifying if the beans should be loaded into the L2 cache.
-     */
-    public Query<T> setLoadBeanCache(boolean loadBeanCache) {
-      return query().setLoadBeanCache(loadBeanCache);
-    }
-
-    /**
-     * Create a query specifying if the L2 bean cache should be used.
-     */
-    public Query<T> setUseCache(boolean useBeanCache) {
-      return query().setUseCache(useBeanCache);
-    }
-
-    /**
-     * Create a query specifying if the L2 query cache should be used.
-     */
-    public Query<T> setUseQueryCache(boolean useQueryCache) {
-      return query().setUseQueryCache(useQueryCache);
-    }
-
-  }
-}
@@ -1,413 +0,0 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * 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 final 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<Property>(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<Property>(3);
-    parse(orderByClause);
-  }
-
-  /**
-   * Reverse the ascending/descending order on all the properties.
-   */
-  public void reverse() {
-    for (int i = 0; i < list.size(); i++) {
-      list.get(i).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 descending order to this OrderBy.
-   */
-  public Query<T> desc(String propertyName) {
-
-    list.add(new Property(propertyName, false));
-    return query;
-  }
-
-  /**
-   * Return true if the property is known to be contained in the order by clause.
-   */
-  public boolean containsProperty(String propertyName) {
-
-    for (int i = 0; i < list.size(); i++) {
-      if (propertyName.equals(list.get(i).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<Property>(list.size());
-    for (int i = 0; i < list.size(); i++) {
-      newList.add(list.get(i).copyWithTrim(path));
-    }
-    return new OrderBy<T>(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<T>();
-    for (int i = 0; i < list.size(); i++) {
-      copy.add(list.get(i).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);
-  }
-
-  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.
-   */
-  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;
-  }
-
-  /**
-   * A property and its ascending descending order.
-   */
-  public static final class Property implements Serializable {
-
-    private static final long serialVersionUID = 1546009780322478077L;
-
-    private String property;
-
-    private boolean ascending;
-
-    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;
-    }
-
-    /**
-     * Return a copy of this Property with the path trimmed.
-     */
-    public Property copyWithTrim(String path) {
-      return new Property(property.substring(path.length() + 1), ascending, nulls, highLow);
-    }
-
-    @Override
-    public int hashCode() {
-      int hc = property.hashCode();
-      hc = hc * 31 + (ascending ? 0 : 1);
-      hc = hc * 31 + (nulls == null ? 0 : nulls.hashCode());
-      hc = hc * 31 + (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 (nulls != null ? !nulls.equals(e.nulls) : e.nulls != null) return false;
-      return highLow != null ? highLow.equals(e.highLow) : e.highLow == null;
-    }
-
-    public String toString() {
-      return toStringFormat();
-    }
-
-    public String toStringFormat() {
-      if (nulls == null) {
-        if (ascending) {
-          return property;
-        } else {
-          return property + " desc";
-        }
-      } else {
-        StringBuilder sb = new StringBuilder();
-        sb.append(property);
-        if (!ascending) {
-          sb.append(" ").append("desc");
-        }
-        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, 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;
-    }
-
-  }
-
-  private void parse(String orderByClause) {
-
-    if (orderByClause == null) {
-      return;
-    }
-
-    String[] chunks = orderByClause.split(",");
-    for (int i = 0; i < chunks.length; i++) {
-      String[] pairs = chunks[i].split(" ");
-      Property p = parseProperty(pairs);
-      if (p != null) {
-        list.add(p);
-      }
-    }
-  }
-
-  private Property parseProperty(String[] pairs) {
-    if (pairs.length == 0) {
-      return null;
-    }
-
-    ArrayList<String> wordList = new ArrayList<String>(pairs.length);
-    for (int i = 0; i < pairs.length; i++) {
-      if (!isEmptyString(pairs[i])) {
-        wordList.add(pairs[i]);
-      }
-    }
-    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));
-    }
-    String m = "Expecting a 1, 2 or 4 words in [" + Arrays.toString(pairs) + "] but got " + wordList;
-    throw new RuntimeException(m);
-  }
-
-  private boolean isAscending(String s) {
-    s = s.toLowerCase();
-    if (s.startsWith("asc")) {
-      return true;
-    }
-    if (s.startsWith("desc")) {
-      return false;
-    }
-    String m = "Expecting [" + s + "] to be asc or desc?";
-    throw new RuntimeException(m);
-  }
-
-  private boolean isEmptyString(String s) {
-    return s == null || s.isEmpty();
-  }
-}
@@ -1,240 +0,0 @@
-package com.avaje.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#findFutureRowCount()} 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>
- *
- *
- * <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
- *       = ebeanServer.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>
- *
- * <h4>Example: typical use including total row count</h4>
- * <pre>{@code
- *
- *     // We want to find the first 100 new orders
- *     //  ... 0 means first page
- *     //  ... page size is 100
- *
- *     PagedList<Order> pagedList
- *       = ebeanServer.find(Order.class)
- *       .where().eq("status", Order.Status.NEW)
- *       .order().asc("id")
- *       .findPagedList(0, 100);
- *
- *     // 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>
- *
- * <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> {
-
-  /**
-   * 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();
-
-  /**
-   * Deprecated in favor of loadCount().
-   *
-   * @deprecated
-   */
-  void loadRowCount();
-
-  /**
-   * 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() & getTotalRowCount() methods internally make use of this getFutureRowCount() method.
-   * Generally I expect people to prefer loadRowCount() & 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();
-
-  /**
-   * Deprecated in favor of getFutureCount().
-   *
-   * @deprecated
-   */
-  Future<Integer> getFutureRowCount();
-
-  /**
-   * 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();
-
-  /**
-   * Deprecated in favor of getTotalCount().
-   *
-   * @deprecated
-   */
-  int getTotalRowCount();
-
-  /**
-   * 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 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);
-}
@@ -1,35 +0,0 @@
-package com.avaje.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 com.avaje.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)
- * @see com.avaje.ebean.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
-}
@@ -1,18 +0,0 @@
-package com.avaje.ebean;
-
-import javax.persistence.PersistenceException;
-
-/**
- * Captures and wraps IOException's occurring during ElasticSearch processing etc.
- */
-public class PersistenceIOException extends PersistenceException {
-
-  public PersistenceIOException(String msg, Exception cause) {
-    super(msg, cause);
-  }
-
-  public PersistenceIOException(Exception cause) {
-    super(cause);
-  }
-
-}
@@ -1,83 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.config.PropertyMap;
-
-import java.util.Properties;
-
-/**
- * Provides singleton state for the default server.
- * <p/>
- * Intended for internal use as part of bootup, construction, registration of the default server.
- */
-class PrimaryServer {
-
-  private static Properties globalProperties;
-
-  private static String defaultServerName;
-
-  private static boolean skip;
-
-  /**
-   * Set whether to skip automatically creating the primary server.
-   */
-  static synchronized void setSkip(boolean skip) {
-    PrimaryServer.skip = skip;
-  }
-
-  /**
-   * Return true to skip automatically creating the primary server.
-   */
-  static synchronized boolean isSkip() {
-    return skip;
-  }
-
-  /**
-   * Return the default server name.
-   */
-  static synchronized String getDefaultServerName() {
-    getProperties();
-    return defaultServerName;
-  }
-
-  /**
-   * Return the default configuration Properties.
-   */
-  static synchronized Properties getProperties() {
-    if (globalProperties == null) {
-      globalProperties = PropertyMap.defaultProperties();
-    }
-    if (defaultServerName == null) {
-      defaultServerName = determineDefaultServerName();
-    }
-    return globalProperties;
-
-  }
-
-  /**
-   * 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");
-    if (isEmpty(defaultServerName)) {
-      defaultServerName = System.getProperty("datasource.default");
-      if (isEmpty(defaultServerName)) {
-        defaultServerName = System.getProperty("ebean.default.datasource");
-        if (isEmpty(defaultServerName)) {
-          defaultServerName = globalProperties.getProperty("datasource.default");
-          if (isEmpty(defaultServerName)) {
-            defaultServerName = globalProperties.getProperty("ebean.default.datasource");
-          }
-        }
-      }
-    }
-    return defaultServerName;
-  }
-
-  /**
-   * Return true if the string is null or empty.
-   */
-  private static boolean isEmpty(String value) {
-    return value == null || value.trim().isEmpty();
-  }
-}
@@ -1,41 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to process a query result one bean at a time via a callback to this
- * visitor.
- * <p>
- * If you wish to stop further processing return false from the accept method.
- * </p>
- * <p>
- * Unlike findList() and findSet() using a QueryResultVisitor does not require
- * all the beans in the query result to be held in memory at once. This makes
- * QueryResultVisitor useful for processing large queries.
- * </p>
- *
- * <pre>{@code
- *
- * Query<Customer> query = server.find(Customer.class)
- *     .where().eq("status", Status.NEW)
- *     .order().asc("id");
- *
- * query.findEach((Customer customer) -> {
- *
- *     // do something with customer
- *     System.out.println("-- visit " + customer);
- * });
- *
- * }</pre>
- * 
- * @param <T>
- *          the type of entity bean being queried.
- */
-public interface QueryEachConsumer<T> {
-
-  /**
-   * Process the bean.
-   * 
-   * @param bean
-   *          the entity bean to process
-   */
-  void accept(T bean);
-}
@@ -1,45 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to process a query result one bean at a time via a callback to this
- * visitor.
- * <p>
- * If you wish to stop further processing return false from the accept method.
- * </p>
- * <p>
- * Unlike findList() and findSet() using a QueryResultVisitor does not require
- * all the beans in the query result to be held in memory at once. This makes
- * QueryResultVisitor useful for processing large queries.
- * </p>
- * <p/>
- * <pre class="code">
- *
- * Query&lt;Customer&gt; query = server.find(Customer.class)
- *     .fetch(&quot;contacts&quot;, new FetchConfig().query(2))
- *     .where().gt(&quot;id&quot;, 0)
- *     .orderBy(&quot;id&quot;)
- *     .setMaxRows(2);
- *
- * query.findEachWhile((Customer customer) -> {
- *
- *     // do something with customer
- *     System.out.println(&quot;-- visit &quot; + customer);
- *
- *     // return true to continue processing or false to stop
- *     return (customer.getId() < 40);
- * });
- * </pre>
- *
- * @param <T> the type of entity bean being queried.
- */
-public interface QueryEachWhileConsumer<T> {
-
-  /**
-   * Process the bean and return true if you want to continue processing more
-   * beans. Return false if you want to stop processing further.
-   *
-   * @param bean the entity bean to process
-   * @return true to continue processing more beans or false to stop.
-   */
-  boolean accept(T bean);
-}
@@ -1,735 +0,0 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-import java.sql.ResultSet;
-import java.util.*;
-
-import com.avaje.ebean.util.CamelCaseHelper;
-
-/**
- * Used to build object graphs based on a raw SQL statement (rather than
- * generated by Ebean).
- * <p>
- * If you don't want to build object graphs you can use {@link SqlQuery} instead
- * which returns {@link SqlRow} objects rather than entity beans.
- * </p>
- * <p>
- * <b>Unparsed RawSql:</b>
- * </p>
- * <p>
- * When RawSql is created via {@link RawSqlBuilder#unparsed(String)} then Ebean can not
- * modify the SQL at all. It can't add any extra expressions into the SQL.
- * </p>
- * <p>
- * <b>Parsed RawSql:</b>
- * </p>
- * <p>
- * When RawSql is created via {@link RawSqlBuilder#parse(String)} then Ebean will parse the
- * SQL and find places in the SQL where it can add extra where expressions, add
- * extra having expressions or replace the order by clause. If you want to
- * explicitly tell Ebean where these insertion points are you can place special
- * strings into your SQL ({@code ${where}} or {@code ${andWhere}} and {@code ${having}} or
- * {@code ${andHaving})}.
- * </p>
- * <p>
- * If the SQL already includes a WHERE clause put in {@code ${andWhere}} in the location
- * you want Ebean to add any extra where expressions. If the SQL doesn't have a
- * WHERE clause put {@code ${where}} in instead. Similarly you can put in {@code ${having}} or
- * {@code ${andHaving}} where you want Ebean put add extra having expressions.
- * </p>
- * <p>
- * <b>Aggregates:</b>
- * </p>
- * <p>
- * Often RawSql will be used with Aggregate functions (sum, avg, max etc). The
- * follow example shows an example based on Total Order Amount -
- * sum(d.order_qty*d.unit_price).
- * </p>
- * <p>
- * We can use a OrderAggregate bean that has a &#064;Sql to indicate it is based
- * on RawSql and not based on a real DB Table or DB View. It has some properties
- * to hold the values for the aggregate functions (sum etc) and a &#064;OneToOne
- * to Order.
- * </p>
- *
- * <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(d.order_qty*d.unit_price) as totalAmount"
- *     + " from o_order o"
- *     + " join o_customer c on c.id = o.kcustomer_id "
- *     + " join o_order_detail d on d.order_id = o.id " + " group by order_id, o.status ";
- * 
- *   RawSql rawSql = RawSqlBuilder.parse(sql)
- *     // map the sql result columns to bean properties
- *     .columnMapping("order_id", "order.id")
- *     .columnMapping("o.status", "order.status")
- *     .columnMapping("c.id", "order.customer.id")
- *     .columnMapping("c.name", "order.customer.name")
- *     // we don't need to map this one due to the sql column alias
- *     // .columnMapping("sum(d.order_qty*d.unit_price)", "totalAmount")
- *     .create();
- * 
- *   List<OrderAggregate> list = Ebean.find(OrderAggregate.class)
- *       .setRawSql(rawSql)
- *       .where().gt("order.id", 0)
- *       .having().gt("totalAmount", 20)
- *       .findList();
- * 
- *
- * }</pre>
- * 
- * <h3>Example 2:</h3>
- * 
- * <p>
- * The following example uses a FetchConfig().query() so that after the initial
- * RawSql query is executed Ebean executes a secondary query to fetch the
- * associated order status, orderDate along with the customer name.
- * </p>
- * 
- * <pre>{@code
- *
- *  String sql = " select order_id, 'ignoreMe', sum(d.order_qty*d.unit_price) as totalAmount "
- *     + " from o_order_detail d"
- *     + " group by order_id ";
- * 
- *   RawSql rawSql = RawSqlBuilder.parse(sql)
- *     .columnMapping("order_id", "order.id")
- *     .columnMappingIgnore("'ignoreMe'")
- *     .create();
- * 
- *   List<OrderAggregate> orders = Ebean.find(OrderAggregate.class)
- *     .setRawSql(rawSql)
- *     .fetch("order", "status,orderDate", new FetchConfig().query())
- *     .fetch("order.customer", "name")
- *     .where().gt("order.id", 0)
- *     .having().gt("totalAmount", 20)
- *     .order().desc("totalAmount")
- *     .setMaxRows(10)
- *     .findList();
- * 
- * }</pre>
- *
- *
- * <h3>Example 3: tableAliasMapping</h3>
- * <p>
- *   Instead of mapping each column you can map each table alias to a path using tableAliasMapping().
- * </p>
- * <pre>{@code
- *
- *   String rs = "select o.id, o.status, c.id, c.name, "+
- *               " d.id, d.order_qty, p.id, p.name " +
- *               "from o_order o join o_customer c on c.id = o.kcustomer_id " +
- *               "join o_order_detail d on d.order_id = o.id  " +
- *               "join o_product p on p.id = d.product_id  " +
- *               "where o.id <= :maxOrderId  and p.id = :productId "+
- *               "order by o.id, d.id asc";
- *
- *  RawSql rawSql = RawSqlBuilder.parse(rs)
- *       .tableAliasMapping("c", "customer")
- *       .tableAliasMapping("d", "details")
- *       .tableAliasMapping("p", "details.product")
- *       .create();
- *
- *  List<Order> ordersFromRaw = Ebean.find(Order.class)
- *       .setRawSql(rawSql)
- *       .setParameter("maxOrderId", 2)
- *       .setParameter("productId", 1)
- *       .findList();
- *
- * }</pre>
- *
- *
- * <p>
- * Note that lazy loading also works with object graphs built with RawSql.
- * </p>
- * 
- */
-public final class RawSql implements Serializable {
-
-  private static final long serialVersionUID = 1L;
-
-  private final ResultSet resultSet;
-  
-  private final Sql sql;
-
-  private final ColumnMapping columnMapping;
-
-  /**
-   * Construct with a ResultSet and properties that the columns map to.
-   * <p>
-   * The properties listed in the propertyNames must be in the same order as the columns in the
-   * resultSet.
-   * <p>
-   * When a query executes this RawSql object then it will close the resultSet.
-   */
-  public RawSql(ResultSet resultSet, String... propertyNames) {
-    this.resultSet = resultSet;
-    this.sql = null;
-    this.columnMapping = new ColumnMapping(propertyNames);
-  }
-  
-  protected RawSql(ResultSet resultSet, Sql sql, ColumnMapping columnMapping) {
-    this.resultSet = resultSet;
-    this.sql = sql;
-    this.columnMapping = columnMapping;
-  }
-
-  /**
-   * Return the Sql either unparsed or in parsed (broken up) form.
-   */
-  public Sql getSql() {
-    return sql;
-  }
-
-  /**
-   * Return the key;
-   */
-  public Key getKey() {
-    boolean parsed = sql != null && sql.parsed;
-    String unParsedSql = (sql == null) ? "" : sql.unparsedSql;
-    return new Key(parsed, unParsedSql, columnMapping);
-  }
-  
-  /**
-   * Return the resultSet if this is a ResultSet based RawSql.
-   */
-  public ResultSet getResultSet() {
-    return resultSet;
-  }
-
-  /**
-   * Return the column mapping for the SQL columns to bean properties.
-   */
-  public ColumnMapping getColumnMapping() {
-    return columnMapping;
-  }
-
-  /**
-   * Represents the sql part of the query. For parsed RawSql the sql is broken
-   * up so that Ebean can insert extra WHERE and HAVING expressions into the
-   * SQL.
-   */
-  public static final class Sql implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
-    private final boolean parsed;
-
-    private final String unparsedSql;
-
-    private final String preFrom;
-
-    private final String preWhere;
-
-    private final boolean andWhereExpr;
-
-    private final String preHaving;
-
-    private final boolean andHavingExpr;
-
-    private final String orderByPrefix;
-
-    private final String orderBy;
-
-    private final boolean distinct;
-
-    /**
-     * Construct for unparsed SQL.
-     */
-    protected Sql(String unparsedSql) {
-      this.parsed = false;
-      this.unparsedSql = unparsedSql;
-      this.preFrom = null;
-      this.preHaving = null;
-      this.preWhere = null;
-      this.andHavingExpr = false;
-      this.andWhereExpr = false;
-      this.orderByPrefix = null;
-      this.orderBy = null;
-      this.distinct = false;
-    }
-
-    /**
-     * Construct for parsed SQL.
-     */
-    protected Sql(String unparsedSql, String preFrom, String preWhere, boolean andWhereExpr,
-        String preHaving, boolean andHavingExpr, String orderByPrefix, String orderBy, boolean distinct) {
-
-      this.unparsedSql = unparsedSql;
-      this.parsed = true;
-      this.preFrom = preFrom;
-      this.preHaving = preHaving;
-      this.preWhere = preWhere;
-      this.andHavingExpr = andHavingExpr;
-      this.andWhereExpr = andWhereExpr;
-      this.orderByPrefix = orderByPrefix;
-      this.orderBy = orderBy;
-      this.distinct = distinct;
-    }
-
-    public String toString() {
-      if (!parsed) {
-        return "unparsed[" + unparsedSql + "]";
-      }
-      return "select[" + preFrom + "] preWhere[" + preWhere + "] preHaving[" + preHaving
-          + "] orderBy[" + orderBy + "]";
-    }
-
-    public boolean isDistinct() {
-      return distinct;
-    }
-
-    /**
-     * Return true if the SQL is left completely unmodified.
-     * <p>
-     * This means Ebean can't add WHERE or HAVING expressions into the query -
-     * it will be left completely unmodified.
-     * </p>
-     */
-    public boolean isParsed() {
-      return parsed;
-    }
-
-    /**
-     * Return the SQL when it is unparsed.
-     */
-    public String getUnparsedSql() {
-      return unparsedSql;
-    }
-
-    /**
-     * Return the SQL prior to FROM clause.
-     */
-    public String getPreFrom() {
-      return preFrom;
-    }
-
-    /**
-     * Return the SQL prior to WHERE clause.
-     */
-    public String getPreWhere() {
-      return preWhere;
-    }
-
-    /**
-     * Return true if there is already a WHERE clause and any extra where
-     * expressions start with AND.
-     */
-    public boolean isAndWhereExpr() {
-      return andWhereExpr;
-    }
-
-    /**
-     * Return the SQL prior to HAVING clause.
-     */
-    public String getPreHaving() {
-      return preHaving;
-    }
-
-    /**
-     * Return true if there is already a HAVING clause and any extra having
-     * expressions start with AND.
-     */
-    public boolean isAndHavingExpr() {
-      return andHavingExpr;
-    }
-
-    /**
-     * Return the 'order by' keywords.
-     * This can contain additional keywords, for example 'order siblings by' as Oracle syntax.
-     */
-    public String getOrderByPrefix() {
-      return (orderByPrefix == null) ? "order by" : orderByPrefix;
-    }
-
-    /**
-     * Return the SQL ORDER BY clause.
-     */
-    public String getOrderBy() {
-      return orderBy;
-    }
-
-  }
-
-  /**
-   * Defines the column mapping for raw sql DB columns to bean properties.
-   */
-  public static final class ColumnMapping implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
-    private final LinkedHashMap<String, Column> dbColumnMap;
-
-    private final Map<String, String> propertyMap;
-    
-    private final Map<String, Column> propertyColumnMap;
-
-    private final boolean parsed;
-
-    private final boolean immutable;
-
-    /**
-     * Construct from parsed sql where the columns have been identified.
-     */
-    protected ColumnMapping(List<Column> columns) {
-      this.immutable = false;
-      this.parsed = true;
-      this.propertyMap = null;
-      this.propertyColumnMap = null;
-      this.dbColumnMap = new LinkedHashMap<String, Column>();
-      for (int i = 0; i < columns.size(); i++) {
-        Column c = columns.get(i);
-        dbColumnMap.put(c.getDbColumnKey(), c);
-      }
-    }
-
-    /**
-     * Construct for unparsed sql.
-     */
-    protected ColumnMapping() {
-      this.immutable = false;
-      this.parsed = false;
-      this.propertyMap = null;
-      this.propertyColumnMap = null;
-      this.dbColumnMap = new LinkedHashMap<String, Column>();
-    }
-    
-    /**
-     * Construct for ResultSet use.
-     */
-    protected ColumnMapping(String... propertyNames) {
-      this.immutable = false;
-      this.parsed = false;
-      this.propertyMap = null;
-      this.dbColumnMap = new LinkedHashMap<String, Column>();
-
-      int pos = 0;
-      for (String prop : propertyNames) {
-        dbColumnMap.put(prop, new Column(pos++, prop, null, prop));
-      }
-      propertyColumnMap = dbColumnMap;
-    }
-
-    /**
-     * Construct an immutable ColumnMapping based on collected information.
-     */
-    protected ColumnMapping(boolean parsed, LinkedHashMap<String, Column> dbColumnMap) {
-      this.immutable = true;
-      this.parsed = parsed;
-      this.dbColumnMap = dbColumnMap;
-
-      HashMap<String, Column> pcMap = new HashMap<String, Column>();
-      HashMap<String, String> pMap = new HashMap<String, String>();
-
-      for (Column c : dbColumnMap.values()) {
-        pMap.put(c.getPropertyName(), c.getDbColumn());
-        pcMap.put(c.getPropertyName(), c);
-      }
-      this.propertyMap = Collections.unmodifiableMap(pMap);
-      this.propertyColumnMap = Collections.unmodifiableMap(pcMap);
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) return true;
-      if (o == null || getClass() != o.getClass()) return false;
-      ColumnMapping that = (ColumnMapping) o;
-      return dbColumnMap.equals(that.dbColumnMap);
-    }
-
-    @Override
-    public int hashCode() {
-      return dbColumnMap.hashCode();
-    }
-
-    /**
-     * Return true if the property is mapped.
-     */
-    public boolean contains(String property) {
-      return this.propertyColumnMap.containsKey(property);
-    }
-
-    /**
-     * Creates an immutable copy of this ColumnMapping.
-     * 
-     * @throws IllegalStateException
-     *           when a propertyName has not been defined for a column.
-     */
-    protected ColumnMapping createImmutableCopy() {
-
-      for (Column c : dbColumnMap.values()) {
-        c.checkMapping();
-      }
-
-      return new ColumnMapping(parsed, dbColumnMap);
-    }
-
-    protected void columnMapping(String dbColumn, String propertyName) {
-
-      if (immutable) {
-        throw new IllegalStateException("Should never happen");
-      }
-      if (!parsed) {
-        int pos = dbColumnMap.size();
-        dbColumnMap.put(dbColumn, new Column(pos, dbColumn, null, propertyName));
-      } else {
-        Column column = dbColumnMap.get(dbColumn);
-        if (column == null) {
-          String msg = "DB Column [" + dbColumn + "] not found in mapping. Expecting one of [" + dbColumnMap.keySet() + "]";
-          throw new IllegalArgumentException(msg);
-        }
-        column.setPropertyName(propertyName);
-      }
-    }
-
-    /**
-     * Returns true if the Columns where supplied by parsing the sql select
-     * clause.
-     * <p>
-     * In the case where the columns where parsed then we can do extra checks on
-     * the column mapping such as, is the column a valid one in the sql and
-     * whether all the columns in the sql have been mapped.
-     * </p>
-     */
-    public boolean isParsed() {
-      return parsed;
-    }
-
-    /**
-     * Return the number of columns in this column mapping.
-     */
-    public int size() {
-      return dbColumnMap.size();
-    }
-
-    /**
-     * Return the column mapping.
-     */
-    protected Map<String, Column> mapping() {
-      return dbColumnMap;
-    }
-
-    /**
-     * Return the mapping by DB column.
-     */
-    public Map<String, String> getMapping() {
-      return propertyMap;
-    }
-
-    /**
-     * Return the index position by bean property name.
-     */
-    public int getIndexPosition(String property) {
-      Column c = propertyColumnMap.get(property);
-      return c == null ? -1 : c.getIndexPos();
-    }
-
-    /**
-     * Return an iterator of the Columns.
-     */
-    public Iterator<Column> getColumns() {
-      return dbColumnMap.values().iterator();
-    }
-
-    /**
-     * Modify any column mappings with the given table alias to have the path prefix.
-     * <p>
-     * For example modify all mappings with table alias "c" to have the path prefix "customer".
-     * </p>
-     * <p>
-     * For the "Root type" you don't need to specify a tableAliasMapping.
-     * </p>
-     */
-    public void tableAliasMapping(String tableAlias, String path) {
-
-      String startMatch = tableAlias+".";
-      for (Map.Entry<String, Column> entry : dbColumnMap.entrySet()) {
-        if (entry.getKey().startsWith(startMatch)) {
-          entry.getValue().tableAliasMapping(path);
-        }
-      }
-    }
-
-    /**
-     * A Column of the RawSql that is mapped to a bean property (or ignored).
-     */
-    public static class Column implements Serializable {
-
-      private static final long serialVersionUID = 1L;
-      private final int indexPos;
-      private final String dbColumn;
-
-      private final String dbAlias;
-
-      private String propertyName;
-
-      /**
-       * Construct a Column.
-       */
-      public Column(int indexPos, String dbColumn, String dbAlias) {
-        this(indexPos, dbColumn, dbAlias, derivePropertyName(dbAlias, dbColumn));
-      }
-
-      private Column(int indexPos, String dbColumn, String dbAlias, String propertyName) {
-        this.indexPos = indexPos;
-        this.dbColumn = dbColumn;
-        this.dbAlias = dbAlias;
-        if (propertyName == null && dbAlias != null) {
-          this.propertyName = dbAlias;
-        } else {
-          this.propertyName = propertyName;
-        }
-      }
-
-      protected static String derivePropertyName(String dbAlias, String dbColumn) {
-        if (dbAlias != null) {
-          return CamelCaseHelper.toCamelFromUnderscore(dbAlias);
-        }
-        int dotPos = dbColumn.indexOf('.');
-        if (dotPos > -1) {
-          dbColumn = dbColumn.substring(dotPos + 1);
-        }
-        return CamelCaseHelper.toCamelFromUnderscore(dbColumn);
-      }
-
-      private void checkMapping() {
-        if (propertyName == null) {
-          String msg = "No propertyName defined (Column mapping) for dbColumn [" + dbColumn + "]";
-          throw new IllegalStateException(msg);
-        }
-      }
-
-      @Override
-      public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        Column that = (Column) o;
-        if (indexPos != that.indexPos) return false;
-        if (!dbColumn.equals(that.dbColumn)) return false;
-        if (dbAlias != null ? !dbAlias.equals(that.dbAlias) : that.dbAlias != null) return false;
-        return propertyName != null ? propertyName.equals(that.propertyName) : that.propertyName == null;
-      }
-
-      @Override
-      public int hashCode() {
-        int result = indexPos;
-        result = 31 * result + dbColumn.hashCode();
-        result = 31 * result + (dbAlias != null ? dbAlias.hashCode() : 0);
-        result = 31 * result + (propertyName != null ? propertyName.hashCode() : 0);
-        return result;
-      }
-
-      public String toString() {
-        return dbColumn + "->" + propertyName;
-      }
-
-      /**
-       * Return the index position of this column.
-       */
-      public int getIndexPos() {
-        return indexPos;
-      }
-
-      /**
-       * Return the DB column alias if specified otherwise DB column.
-       * This is used as the key for mapping a column to a logical property.
-       */
-      public String getDbColumnKey() {
-        return (dbAlias != null) ? dbAlias : dbColumn;
-      }
-
-      /**
-       * Return the DB column name including table alias (if it has one).
-       */
-      public String getDbColumn() {
-        return dbColumn;
-      }
-
-      /**
-       * Return the bean property this column is mapped to.
-       */
-      public String getPropertyName() {
-        return propertyName;
-      }
-
-      /**
-       * Set the property name mapped to this db column.
-       */
-      private void setPropertyName(String propertyName) {
-        this.propertyName = propertyName;
-      }
-
-      /**
-       * Prepend the path to the property name.
-       * <p/>
-       * For example if path is "customer" then "name" becomes "customer.name".
-       */
-      public void tableAliasMapping(String path) {
-        if (path != null) {
-          propertyName = path + "." + propertyName;
-        }
-      }
-    }
-  }
-
-  /**
-   * A key for the RawSql object using for the query plan.
-   */
-  public static final class Key {
-
-    private final boolean parsed;
-    private final ColumnMapping columnMapping;
-    private final String unParsedSql;
-
-    Key(boolean parsed, String unParsedSql, ColumnMapping columnMapping) {
-      this.parsed = parsed;
-      this.unParsedSql = unParsedSql;
-      this.columnMapping = columnMapping;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) return true;
-      if (o == null || getClass() != o.getClass()) return false;
-
-      Key that = (Key) o;
-      return parsed == that.parsed
-          && columnMapping.equals(that.columnMapping)
-          && unParsedSql.equals(that.unParsedSql);
-    }
-
-    @Override
-    public int hashCode() {
-      int result = (parsed ? 1 : 0);
-      result = 31 * result + columnMapping.hashCode();
-      result = 31 * result + unParsedSql.hashCode();
-      return result;
-    }
-  }
-}
@@ -1,135 +0,0 @@
-package com.avaje.ebean;
-
-import java.sql.ResultSet;
-
-import com.avaje.ebean.RawSql.ColumnMapping;
-import com.avaje.ebean.RawSql.Sql;
-
-/**
- * Builds RawSql instances from a SQL string and column mappings.
- * <p>
- * Note that RawSql can also be defined in ebean-orm.xml files and be used as a
- * named query.
- * </p>
- * 
- * @see RawSql
- */
-public class RawSqlBuilder {
-
-  /**
-   * Special property name assigned to a DB column that should be ignored.
-   */
-  public static final String IGNORE_COLUMN = "$$_IGNORE_COLUMN_$$";
-
-  private final ResultSet resultSet;
-  
-  private final Sql sql;
-
-  private final ColumnMapping columnMapping;
-
-  /**
-   * Create and return a RawSql object based on the resultSet and list of properties the columns in
-   * the resultSet map to.
-   * <p>
-   * The properties listed in the propertyNames must be in the same order as the columns in the
-   * resultSet.
-   */
-  public static RawSql resultSet(ResultSet resultSet, String... propertyNames) {
-    return new RawSql(resultSet, propertyNames);
-  }
-  
-  /**
-   * Return an unparsed RawSqlBuilder. Unlike a parsed one this query can not be
-   * modified - so no additional WHERE or HAVING expressions can be added to
-   * this query.
-   */
-  public static RawSqlBuilder unparsed(String sql) {
-
-    Sql s = new Sql(sql);
-    return new RawSqlBuilder(s, new ColumnMapping());
-  }
-
-  /**
-   * Return a RawSqlBuilder parsing the sql.
-   * <p>
-   * The sql statement will be parsed so that Ebean can determine where it can
-   * insert additional WHERE or HAVING expressions.
-   * </p>
-   * <p>
-   * Additionally the selected columns are parsed to determine the column
-   * ordering. This also means additional checks can be made with the column
-   * mapping - specifically we can check that all columns are mapped and that
-   * correct column names are entered into the mapping.
-   * </p>
-   */
-  public static RawSqlBuilder parse(String sql) {
-
-    Sql sql2 = DRawSqlParser.parse(sql);
-    String select = sql2.getPreFrom();
-
-    ColumnMapping mapping = DRawSqlColumnsParser.parse(select);
-    return new RawSqlBuilder(sql2, mapping);
-  }
-  
-  private RawSqlBuilder(Sql sql, ColumnMapping columnMapping) {
-    this.sql = sql;
-    this.columnMapping = columnMapping;
-    this.resultSet = null;
-  }
-
-  /**
-   * Set the mapping of a DB Column to a bean property.
-   * <p>
-   * For Unparsed SQL the columnMapping MUST be defined in the same order that
-   * the columns appear in the SQL statement.
-   * </p>
-   * 
-   * @param dbColumn
-   *          the DB column that we are mapping to a bean property
-   * @param propertyName
-   *          the bean property that we are mapping the DB column to.
-   */
-  public RawSqlBuilder columnMapping(String dbColumn, String propertyName) {
-    columnMapping.columnMapping(dbColumn, propertyName);
-    return this;
-  }
-
-  /**
-   * Ignore this DB column. It is not mapped to any bean property.
-   */
-  public RawSqlBuilder columnMappingIgnore(String dbColumn) {
-    return columnMapping(dbColumn, IGNORE_COLUMN);
-  }
-
-  /**
-   * Modify any column mappings with the given table alias to have the path prefix.
-   * <p>
-   * For example modify all mappings with table alias "c" to have the path prefix "customer".
-   * </p>
-   * <p>
-   * For the "Root type" you don't need to specify a tableAliasMapping.
-   * </p>
-   */
-  public RawSqlBuilder tableAliasMapping(String tableAlias, String path) {
-    columnMapping.tableAliasMapping(tableAlias, path);
-    return this;
-  }
-
-  /**
-   * Create the immutable RawSql object. Do this after all the column mapping
-   * has been defined.
-   */
-  public RawSql create() {
-    return new RawSql(resultSet, sql, columnMapping.createImmutableCopy());
-  }
-
-  /**
-   * Return the internal parsed Sql object (for testing).
-   */
-  protected Sql getSql() {
-    return sql;
-  }
-
-
-
-}
@@ -1,167 +0,0 @@
-package com.avaje.ebean;
-
-class SimpleTextParser {
-
-  private final String oql;
-  private final char[] chars;
-  private final int eof;
-
-  private int pos;
-  private String word;
-  private String lowerWord;
-
-  SimpleTextParser(String oql) {
-    this.oql = oql;
-    this.chars = oql.toCharArray();
-    this.eof = oql.length();
-  }
-
-  public int getPos() {
-    return pos;
-  }
-
-  public String getWord() {
-    return word;
-  }
-
-  public String peekNextWord() {
-    int origPos = pos;
-    String nw = nextWordInternal();
-    pos = origPos;
-    return nw;
-  }
-
-  /**
-   * Match the current and the next word.
-   */
-  public boolean isMatch(String lowerMatch, String nextWordMatch) {
-
-    if (isMatch(lowerMatch)) {
-      String nw = peekNextWord();
-      if (nw != null) {
-        nw = nw.toLowerCase();
-        return nw.equals(nextWordMatch);
-      }
-    }
-    return false;
-  }
-
-  public boolean isFinished() {
-    return word == null;
-  }
-
-  public int findWordLower(String lowerMatch, int afterPos) {
-    this.pos = afterPos;
-    return findWordLower(lowerMatch);
-  }
-
-  public int findWordLower(String lowerMatch) {
-    do {
-      if (nextWord() == null) {
-        return -1;
-      }
-      if (lowerMatch.equals(lowerWord)) {
-        return pos - lowerWord.length();
-      }
-    } while (true);
-  }
-
-  /**
-   * Match the current word.
-   */
-  public boolean isMatch(String lowerMatch) {
-    return lowerMatch.equals(lowerWord);
-  }
-
-  public String nextWord() {
-    word = nextWordInternal();
-    if (word != null) {
-      lowerWord = word.toLowerCase();
-    }
-    return word;
-  }
-
-  private String nextWordInternal() {
-    trimLeadingWhitespace();
-    if (pos >= eof) {
-      return null;
-    }
-    int start = pos;
-    if (chars[pos] == '(') {
-      moveToClose();
-    } else {
-      moveToEndOfWord();
-    }
-    return oql.substring(start, pos);
-  }
-
-  private void moveToClose() {
-
-    pos++;
-    int openParenthesisCount = 0;
-
-    for (; pos < eof; pos++) {
-      char c = chars[pos];
-      if (c == '(') {
-        // count nested parenthesis
-        openParenthesisCount++;
-
-      } else if (c == ')') {
-        if (openParenthesisCount > 0) {
-          // still in nested parenthesis
-          --openParenthesisCount;
-        } else {
-          // we have found the end
-          pos++;
-          return;
-        }
-      }
-    }
-  }
-
-  private void moveToEndOfWord() {
-    char c = chars[pos];
-    boolean isOperator = isOperator(c);
-    for (; pos < eof; pos++) {
-      c = chars[pos];
-      if (isWordTerminator(c, isOperator)) {
-        return;
-      }
-    }
-  }
-
-  private boolean isWordTerminator(char c, boolean isOperator) {
-    if (Character.isWhitespace(c)) {
-      return true;
-    }
-    if (isOperator(c)) {
-      return !isOperator;
-    }
-    return c == '(' || isOperator;
-  }
-
-  private boolean isOperator(char c) {
-    switch (c) {
-    case '<':
-      return true;
-    case '>':
-      return true;
-    case '=':
-      return true;
-    case '!':
-      return true;
-
-    default:
-      return false;
-    }
-  }
-
-  private void trimLeadingWhitespace() {
-    for (; pos < eof; pos++) {
-      char c = chars[pos];
-      if (!Character.isWhitespace(c)) {
-        break;
-      }
-    }
-  }
-}
@@ -1,116 +0,0 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-import java.util.List;
-
-/**
- * Query object for performing native SQL queries that return SqlRow's.
- * <p>
- * Firstly note that you can use your own sql queries with <em>entity beans</em>
- * by using the SqlSelect annotation. This should be your first approach when
- * wanting to use your own SQL queries.
- * </p>
- * <p>
- * If ORM Mapping is too tight and constraining for your problem then SqlQuery
- * could be a good approach.
- * </p>
- * <p>
- * The returned SqlRow objects are similar to a LinkedHashMap with some type
- * conversion support added.
- * </p>
- * 
- * <pre>{@code
- *
- *   // its typically a good idea to use a named query
- *   // and put the sql in the orm.xml instead of in your code
- * 
- *   String sql = "select id, name from customer where name like :name and status_code = :status";
- * 
- *   SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
- *   sqlQuery.setParameter("name", "Acme%");
- *   sqlQuery.setParameter("status", "ACTIVE");
- * 
- *   // execute the query returning a List of MapBean objects
- *   List<SqlRow> list = sqlQuery.findList();
- *
- * }</pre>
- * 
- */
-public interface SqlQuery extends Serializable {
-
-  /**
-   * Execute the query returning a list.
-   */
-  List<SqlRow> findList();
-
-  /**
-   * Execute the SqlQuery iterating a row at a time.
-   * <p>
-   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
-   * </p>
-   */
-  void findEach(QueryEachConsumer<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(QueryEachWhileConsumer<SqlRow> consumer);
-
-  /**
-   * Execute the query returning a single row or null.
-   * <p>
-   * If this query finds 2 or more rows then it will throw a
-   * PersistenceException.
-   * </p>
-   */
-  SqlRow findUnique();
-
-  /**
-   * The same as bind for named parameters.
-   */
-  SqlQuery setParameter(String name, Object value);
-
-  /**
-   * The same as bind for positioned parameters.
-   */
-  SqlQuery setParameter(int position, Object value);
-
-  /**
-   * Set the index of the first row of the results to return.
-   */
-  SqlQuery setFirstRow(int firstRow);
-
-  /**
-   * Set the maximum number of query results to return.
-   */
-  SqlQuery setMaxRows(int maxRows);
-
-  /**
-   * Set a timeout on this query.
-   * <p>
-   * This will typically result in a call to setQueryTimeout() on a
-   * preparedStatement. If the timeout occurs an exception will be thrown - this
-   * will be a SQLException wrapped up in a PersistenceException.
-   * </p>
-   * 
-   * @param secs
-   *          the query timeout limit in seconds. Zero means there is no limit.
-   */
-  SqlQuery setTimeout(int secs);
-
-  /**
-   * A hint which for JDBC translates to the Statement.fetchSize().
-   * <p>
-   * Gives the JDBC driver a hint as to the number of rows that should be
-   * fetched from the database when more rows are needed for ResultSet.
-   * </p>
-   */
-  SqlQuery setBufferFetchSizeHint(int bufferFetchSizeHint);
-
-}
@@ -1,168 +0,0 @@
-package com.avaje.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.
-   */
-  Object remove(Object name);
-
-  /**
-   * Return a property value by its name.
-   */
-  Object get(Object name);
-
-  /**
-   * Set a value to a property.
-   */
-  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.
-   */
-  String toString();
-
-  /**
-   * Clear the map.
-   */
-  void clear();
-
-  /**
-   * Returns true if the map contains the property.
-   */
-  boolean containsKey(Object key);
-
-  /**
-   * Returns true if the map contains the value.
-   */
-  boolean containsValue(Object value);
-
-  /**
-   * Returns the entrySet of the map.
-   */
-  Set<Map.Entry<String, Object>> entrySet();
-
-  /**
-   * Returns true if the map is empty.
-   */
-  boolean isEmpty();
-
-  /**
-   * Returns the key set of the map.
-   */
-  Set<String> keySet();
-
-  /**
-   * Put all the values from t into this map.
-   */
-  void putAll(Map<? extends String, ?> t);
-
-  /**
-   * Return the size of the map.
-   */
-  int size();
-
-  /**
-   * Return the values from this map.
-   */
-  Collection<Object> values();
-
-}
@@ -1,145 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * A SqlUpdate for executing insert update or delete statements.
- * <p>
- * Provides a simple way to execute raw SQL insert update or delete statements
- * without having to resort to JDBC.
- * </p>
- * <p>
- * Supports the use of positioned or named parameters and can automatically
- * notify Ebean of the table modified so that Ebean can maintain its cache.
- * </p>
- * <p>
- * Note that {@link #setAutoTableMod(boolean)} and
- * Ebean#externalModification(String, boolean, boolean, boolean)} can be to
- * notify Ebean of external changes and enable Ebean to maintain it's "L2"
- * server cache.
- * </p>
- * 
- * <pre class="code">
- * // example that uses 'named' parameters 
- * String s = &quot;UPDATE f_topic set post_count = :count where id = :id&quot;
- * SqlUpdate update = Ebean.createSqlUpdate(s);
- * update.setParameter(&quot;id&quot;, 1);
- * update.setParameter(&quot;count&quot;, 50);
- * 
- * int modifiedCount = Ebean.execute(update);
- * 
- * String msg = &quot;There were &quot; + modifiedCount + &quot; rows updated&quot;
- * </pre>
- * 
- * @see Update
- * @see SqlQuery
- * @see CallableSql
- */
-public interface SqlUpdate {
-
-  /**
-   * Execute the update returning the number of rows modified.
-   * <p>
-   * After you have executed the SqlUpdate you can bind new variables using
-   * {@link #setParameter(String, Object)} etc and then execute the SqlUpdate
-   * again.
-   * </p>
-   * <p>
-   * For JDBC batch processing refer to
-   * {@link Transaction#setBatchMode(boolean)} and
-   * {@link Transaction#setBatchSize(int)}.
-   * </p>
-   * 
-   * @see com.avaje.ebean.Ebean#execute(SqlUpdate)
-   */
-  int execute();
-
-  /**
-   * Return true if eBean should automatically deduce the table modification
-   * information and process it.
-   * <p>
-   * If this is true then cache invalidation and text index management are aware
-   * of the modification.
-   * </p>
-   */
-  boolean isAutoTableMod();
-
-  /**
-   * Set this to false if you don't want eBean to automatically deduce the table
-   * modification information and process it.
-   * <p>
-   * Set this to false if you don't want any cache invalidation or text index
-   * management to occur. You may do this when say you update only one column
-   * and you know that it is not important for cached objects or text indexes.
-   * </p>
-   */
-  SqlUpdate setAutoTableMod(boolean isAutoTableMod);
-
-  /**
-   * Return the label that can be seen in the transaction logs.
-   */
-  String getLabel();
-
-  /**
-   * Set a descriptive text that can be put into the transaction log.
-   * <p>
-   * Useful when identifying the statement in the transaction log.
-   * </p>
-   */
-  SqlUpdate setLabel(String label);
-
-  /**
-   * Return the sql statement.
-   */
-  String getSql();
-
-  /**
-   * Return the generated sql that has named parameters converted to positioned parameters.
-   */
-  String getGeneratedSql();
-
-  /**
-   * Return the timeout used to execute this statement.
-   */
-  int getTimeout();
-
-  /**
-   * Set the timeout in seconds. Zero implies no limit.
-   * <p>
-   * This will set the query timeout on the underlying PreparedStatement. If the
-   * timeout expires a SQLException will be throw and wrapped in a
-   * PersistenceException.
-   * </p>
-   */
-  SqlUpdate setTimeout(int secs);
-
-  /**
-   * Set a parameter via its index position.
-   */
-  SqlUpdate setParameter(int position, Object value);
-
-  /**
-   * Set a null parameter via its index position.
-   */
-  SqlUpdate setNull(int position, int jdbcType);
-
-  /**
-   * Set a null valued parameter using its index position.
-   */
-  SqlUpdate setNullParameter(int position, int jdbcType);
-
-  /**
-   * Set a named parameter value.
-   */
-  SqlUpdate setParameter(String name, Object param);
-
-  /**
-   * Set a named parameter that has a null value. Exactly the same as
-   * {@link #setNullParameter(String, int)}.
-   */
-  SqlUpdate setNull(String name, int jdbcType);
-
-  /**
-   * Set a named parameter that has a null value.
-   */
-  SqlUpdate setNullParameter(String name, int jdbcType);
-
-}
@@ -1,435 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.annotation.DocStoreMode;
-import com.avaje.ebean.config.DocStoreConfig;
-import com.avaje.ebean.config.PersistBatch;
-import com.avaje.ebean.config.ServerConfig;
-
-import javax.persistence.PersistenceException;
-import javax.persistence.RollbackException;
-import java.io.Closeable;
-import java.sql.Connection;
-
-/**
- * The Transaction object. Typically representing a JDBC or JTA transaction.
- */
-public interface Transaction extends Closeable {
-
-  /**
-   * 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);
-
-  /**
-   * Return true if this transaction is read only.
-   */
-  boolean isReadOnly();
-
-  /**
-   * Set whether this transaction should be readOnly.
-   */
-  void setReadOnly(boolean readOnly);
-
-  /**
-   * Commit the transaction.
-   */
-  void commit() throws RollbackException;
-
-  /**
-   * Rollback the transaction.
-   */
-  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;
-
-  /**
-   * Mark the transaction for rollback only.
-   */
-  void setRollbackOnly();
-
-  /**
-   * If the transaction is active then perform rollback. Otherwise do nothing.
-   */
-  void end() throws PersistenceException;
-
-  /**
-   * 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 ServerConfig#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 ServerConfig#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 ...
-   *
-   *   Transaction transaction = Ebean.beginTransaction();
-   *   try {
-   *
-   *     // 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
-   *     Ebean.save(someBean);
-   *
-   *     // 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
-   *
-   *
-   *   } finally {
-   *     transaction.end();
-   *   }
-   *
-   * }</pre>
-   *
-   * @see ServerConfig#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 statement batching. Statement batching can be transparent
-   * for drivers and databases that support getGeneratedKeys. Otherwise you may
-   * wish to specifically control when batching is used via this method.
-   * <p>
-   * Refer to <code>java.sql.PreparedStatement.addBatch();</code>
-   * <p>
-   * Note that you may also wish to use the setPersistCascade method to stop
-   * save and delete cascade behaviour. You may do this to have full control
-   * over the order of execution rather than the normal cascading fashion.
-   * </p>
-   * <p>
-   * Note that the <em>execution order</em> in batch mode may be different from
-   * non batch mode execution order. Also note that <em>insert behaviour</em>
-   * may be different depending on the JDBC driver and its support for
-   * getGeneratedKeys. That is, for JDBC drivers that do not support
-   * getGeneratedKeys you may not get back the generated IDs (used for inserting
-   * associated detail beans etc).
-   * </p>
-   * <p>
-   * Calls to save(), delete(), insert() and execute() all support batch
-   * processing. This includes normal beans, MapBean, CallableSql and UpdateSql.
-   * </p>
-   * <p>
-   * The flushing of the batched statements is automatic but you can call
-   * batchFlush when you like. Note that flushing occurs when a query is
-   * executed or when you mix UpdateSql and CallableSql with save and delete of
-   * beans.
-   * </p>
-   * <p>
-   * Example: batch processing executing every 3 rows
-   * </p>
-   * 
-   * <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);
-   * 
-   * Transaction txn = ebeanServer.beginTransaction();
-   * txn.setBatchMode(true);
-   * txn.setBatchSize(3);
-   * try {
-   *   for (int i = 0; i < da.length;) {
-   *     cs.setParameter(1, da[i]);
-   *     ebeanServer.execute(cs);
-   *   }
-   * 
-   *   // NB: commit implicitly flushes
-   *   txn.commit();
-   * 
-   * } finally {
-   *   txn.end();
-   * }
-   *
-   * }</pre>
-   * 
-   */
-  void setBatchMode(boolean useBatch);
-
-  /**
-   * The JDBC batch mode to use for this transaction.
-   * <p>
-   * If this is NONE then JDBC batch can still be used for each request - save(), insert(), update() or delete()
-   * and this would be useful if the request cascades to detail beans.
-   * </p>
-   *
-   * @param persistBatchMode the batch mode to use for this transaction
-   *
-   * @see com.avaje.ebean.config.ServerConfig#setPersistBatch(com.avaje.ebean.config.PersistBatch)
-   */
-  void setBatch(PersistBatch persistBatchMode);
-
-  /**
-   * Return the batch mode at the transaction level.
-   */
-  PersistBatch getBatch();
-
-  /**
-   * Set the JDBC batch mode to use for a save() or delete() request.
-   * <p>
-   * This only takes effect when batch mode on the transaction has not already meant that
-   * JDBC batch mode is being used.
-   * </p>
-   * <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>
-   *
-   * @param batchOnCascadeMode the batch mode to use per save(), insert(), update() or delete()
-   *
-   * @see com.avaje.ebean.config.ServerConfig#setPersistBatchOnCascade(com.avaje.ebean.config.PersistBatch)
-   */
-  void setBatchOnCascade(PersistBatch batchOnCascadeMode);
-
-  /**
-   * Return the batch mode at the request level (for each save(), insert(), update() or delete()).
-   */
-  PersistBatch getBatchOnCascade();
-
-  /**
-   * Specify the number of statements before a batch is flushed automatically.
-   */
-  void setBatchSize(int batchSize);
-
-  /**
-   * Return the current batch size.
-   */
-  int getBatchSize();
-
-  /**
-   * Specify if you 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>
-   * <p>
-   * You may want to turn getGeneratedKeys off when you are inserting a large
-   * number of objects and you don't care about getting back the ids.
-   * </p>
-   */
-  void setBatchGetGeneratedKeys(boolean 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>
-   * <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).
-   * </p>
-   */
-  void setBatchFlushOnMixed(boolean 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.
-   * </p>
-   */
-  void setBatchFlushOnQuery(boolean 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.
-   * </p>
-   */
-  boolean isBatchFlushOnQuery();
-
-  /**
-   * The batch will be flushing automatically but you can use this to explicitly
-   * flush the batch if you like.
-   * <p>
-   * Flushing occurs automatically when:
-   * </p>
-   * <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>
-   * </ul>
-   */
-  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>
-   * <p>
-   * Examples of when a developer may wish to use the connection directly are:
-   * Savepoints, advanced CLOB BLOB use and advanced stored procedure calls.
-   * </p>
-   */
-  Connection getConnection();
-
-  /**
-   * Add table modification information to the TransactionEvent.
-   * <p>
-   * Use this in conjunction with getConnection() and raw JDBC.
-   * </p>
-   * <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>
-   * <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.
-   * </p>
-   */
-  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 ebena and are solely meant as a convenient
-   * method push user information to e.g. the
-   * {@link com.avaje.ebean.event.TransactionEventListener}.
-   */
-  void putUserObject(String name, Object value);
-
-  /**
-   * Get an object added with {@link #putUserObject(String, Object)}.
-   */
-  Object getUserObject(String name);
-}
@@ -1,34 +0,0 @@
-package com.avaje.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();
-
-}
@@ -1,42 +0,0 @@
-package com.avaje.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
-  }
-}
@@ -1,45 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Execute a TxCallable in a Transaction scope.
- * <p>
- * Use this with the {@link Ebean#execute(TxCallable)} method.
- * </p>
- * <p>
- * Note that this is basically the same as TxRunnable except that it returns an
- * Object (and you specify the return type via generics).
- * </p>
- * <p>
- * See also {@link TxRunnable}.
- * </p>
- * 
- * <pre class="code">
- * Ebean.execute(new TxCallable&lt;String&gt;() {
- *   public String call() {
- *     User u1 = Ebean.find(User.class, 1);
- *     User u2 = Ebean.find(User.class, 2);
- * 
- *     u1.setName(&quot;u1 mod&quot;);
- *     u2.setName(&quot;u2 mod&quot;);
- * 
- *     Ebean.save(u1);
- *     Ebean.save(u2);
- * 
- *     return u1.getEmail();
- *   }
- * });
- * </pre>
- * 
- * @see TxRunnable
- */
-public interface TxCallable<T> {
-
-  /**
-   * Execute the method within a transaction scope returning the result.
-   * <p>
-   * If you do not want to return a result you should look to use TxRunnable
-   * instead.
-   * </p>
-   */
-  T call();
-}
@@ -1,100 +0,0 @@
-package com.avaje.ebean;
-
-import java.sql.Connection;
-
-/**
- * The Transaction Isolation levels.
- * <p>
- * These match those of java.sql.Connection with the addition of DEFAULT which
- * implies the configured default of the DataSource.
- * </p>
- * <p>
- * This can be used with TxScope to define transactional scopes to execute
- * method within.
- * </p>
- * 
- * @see TxScope
- */
-public enum TxIsolation {
-
-  /**
-   * Read Committed Isolation level. This is typically the default for most
-   * configurations.
-   */
-  READ_COMMITED(Connection.TRANSACTION_READ_COMMITTED),
-
-  /**
-   * Read uncommitted Isolation level.
-   */
-  READ_UNCOMMITTED(Connection.TRANSACTION_READ_UNCOMMITTED),
-
-  /**
-   * Repeatable Read Isolation level.
-   */
-  REPEATABLE_READ(Connection.TRANSACTION_REPEATABLE_READ),
-
-  /**
-   * Serializable Isolation level.
-   */
-  SERIALIZABLE(Connection.TRANSACTION_SERIALIZABLE),
-
-  /**
-   * No Isolation level.
-   */
-  NONE(Connection.TRANSACTION_NONE),
-
-  /**
-   * The default isolation level. This typically means the default that the
-   * DataSource is using or configured to use.
-   */
-  DEFAULT(-1);
-
-  final int level;
-
-  TxIsolation(int level) {
-    this.level = level;
-  }
-
-  /**
-   * Return the level as per java.sql.Connection.
-   * <p>
-   * Note that -1 denotes the default isolation level.
-   * </p>
-   */
-  public int getLevel() {
-    return level;
-  }
-
-  /**
-   * Return the TxIsolation given the java.sql.Connection isolation level.
-   * <p>
-   * Note that -1 denotes the default isolation level.
-   * </p>
-   */
-  public static TxIsolation fromLevel(int connectionIsolationLevel) {
-
-    switch (connectionIsolationLevel) {
-    case Connection.TRANSACTION_READ_UNCOMMITTED:
-      return TxIsolation.READ_UNCOMMITTED;
-
-    case Connection.TRANSACTION_READ_COMMITTED:
-      return TxIsolation.READ_COMMITED;
-
-    case Connection.TRANSACTION_REPEATABLE_READ:
-      return TxIsolation.REPEATABLE_READ;
-
-    case Connection.TRANSACTION_SERIALIZABLE:
-      return TxIsolation.SERIALIZABLE;
-
-    case Connection.TRANSACTION_NONE:
-      return TxIsolation.NONE;
-
-    case -1:
-      return TxIsolation.DEFAULT;
-
-    default:
-      throw new RuntimeException("Unknown isolation level " + connectionIsolationLevel);
-    }
-
-  }
-}
@@ -1,39 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Execute a TxRunnable in a Transaction scope.
- * <p>
- * Use this with the {@link Ebean#execute(TxRunnable)} method.
- * </p>
- * <p>
- * See also {@link TxCallable}.
- * </p>
- * 
- * <pre class="code">
- * 
- * // this run method runs in a transaction scope
- * // which by default is TxScope.REQUIRED
- * 
- * Ebean.execute(new TxRunnable() {
- *   public void run() {
- *     User u1 = Ebean.find(User.class, 1);
- *     User u2 = Ebean.find(User.class, 2);
- * 
- *     u1.setName(&quot;u1 mod&quot;);
- *     u2.setName(&quot;u2 mod&quot;);
- * 
- *     Ebean.save(u1);
- *     Ebean.save(u2);
- *   }
- * });
- * </pre>
- * 
- * @see TxCallable
- */
-public interface TxRunnable {
-
-  /**
-   * Run the method in a transaction sope.
-   */
-  void run();
-}
@@ -1,339 +0,0 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.config.PersistBatch;
-
-import java.util.ArrayList;
-
-/**
- * Holds the definition of how a transactional method should run.
- * <p>
- * This information matches the features of the Transactional annotation. You
- * can use it directly with TxRunnable or TxCallable via
- * {@link Ebean#execute(TxScope, TxCallable)} or
- * {@link Ebean#execute(TxScope, TxRunnable)}.
- * </p>
- * <p>
- * This object is used internally with the enhancement of a method with
- * Transactional annotation.
- * </p>
- *
- * @see TxCallable
- * @see TxRunnable
- * @see Ebean#execute(TxScope, TxCallable)
- * @see Ebean#execute(TxScope, TxRunnable)
- */
-public final class TxScope {
-
-  TxType type;
-
-  String serverName;
-
-  TxIsolation isolation;
-
-  PersistBatch batch;
-
-  PersistBatch batchOnCascade;
-
-  int batchSize;
-
-  boolean skipGeneratedKeys;
-
-  boolean readOnly;
-
-  ArrayList<Class<? extends Throwable>> rollbackFor;
-
-  ArrayList<Class<? extends Throwable>> noRollbackFor;
-
-  /**
-   * Helper method to create a TxScope with REQUIRES.
-   */
-  public static TxScope required() {
-    return new TxScope(TxType.REQUIRED);
-  }
-
-  /**
-   * Helper method to create a TxScope with REQUIRES_NEW.
-   */
-  public static TxScope requiresNew() {
-    return new TxScope(TxType.REQUIRES_NEW);
-  }
-
-  /**
-   * Helper method to create a TxScope with MANDATORY.
-   */
-  public static TxScope mandatory() {
-    return new TxScope(TxType.MANDATORY);
-  }
-
-  /**
-   * Helper method to create a TxScope with SUPPORTS.
-   */
-  public static TxScope supports() {
-    return new TxScope(TxType.SUPPORTS);
-  }
-
-  /**
-   * Helper method to create a TxScope with NOT_SUPPORTED.
-   */
-  public static TxScope notSupported() {
-    return new TxScope(TxType.NOT_SUPPORTED);
-  }
-
-  /**
-   * Helper method to create a TxScope with NEVER.
-   */
-  public static TxScope never() {
-    return new TxScope(TxType.NEVER);
-  }
-
-  /**
-   * Create a REQUIRED transaction scope.
-   */
-  public TxScope() {
-    this.type = TxType.REQUIRED;
-  }
-
-  /**
-   * Create with a given transaction scope type.
-   */
-  public TxScope(TxType type) {
-    this.type = type;
-  }
-
-  /**
-   * Describes this TxScope instance.
-   */
-  public String toString() {
-    return "TxScope[" + type + "] readOnly[" + readOnly + "] isolation[" + isolation
-        + "] serverName[" + serverName
-        + "] rollbackFor[" + rollbackFor + "] noRollbackFor[" + noRollbackFor + "]";
-  }
-
-  /**
-   * Return true if PersistBatch has been set.
-   */
-  public boolean isBatchSet() {
-    return batch != null && batch != PersistBatch.INHERIT;
-  }
-
-  /**
-   * Return true if batch on cascade has been set.
-   */
-  public boolean isBatchOnCascadeSet() {
-    return batchOnCascade != null && batchOnCascade != PersistBatch.INHERIT;
-  }
-
-  /**
-   * Return true if batch size has been set.
-   */
-  public boolean isBatchSizeSet() {
-    return batchSize > 0;
-  }
-
-  /**
-   * Check for batchSize being set without batch mode and use this to imply PersistBatch.ALL.
-   */
-  public void checkBatchMode() {
-    if (batchSize > 0 && notSet(batch) && notSet(batchOnCascade)) {
-      // Use setting the batchSize as implying PersistBatch.ALL for @Transactional
-      batch = PersistBatch.ALL;
-    }
-  }
-
-  /**
-   * Return true if the mode is considered not set.
-   */
-  private boolean notSet(PersistBatch batchMode) {
-    return batchMode == null || batchMode == PersistBatch.INHERIT;
-  }
-
-  /**
-   * Return the transaction type.
-   */
-  public TxType getType() {
-    return type;
-  }
-
-  /**
-   * Set the transaction type.
-   */
-  public TxScope setType(TxType type) {
-    this.type = type;
-    return this;
-  }
-
-  /**
-   * Return the batch mode.
-   */
-  public PersistBatch getBatch() {
-    return batch;
-  }
-
-  /**
-   * Set the batch mode to use.
-   */
-  public TxScope setBatch(PersistBatch batch) {
-    this.batch = batch;
-    return this;
-  }
-
-  /**
-   * Return the batch on cascade mode.
-   */
-  public PersistBatch getBatchOnCascade() {
-    return batchOnCascade;
-  }
-
-  /**
-   * Set the batch on cascade mode.
-   */
-  public TxScope setBatchOnCascade(PersistBatch batchOnCascade) {
-    this.batchOnCascade = batchOnCascade;
-    return this;
-  }
-
-  /**
-   * Return the batch size. 0 means use the default value.
-   */
-  public int getBatchSize() {
-    return batchSize;
-  }
-
-  /**
-   * Set the batch size to use.
-   */
-  public TxScope setBatchSize(int batchSize) {
-    this.batchSize = batchSize;
-    return this;
-  }
-
-  /**
-   * Set if the transaction should skip reading generated keys for inserts.
-   */
-  public TxScope setSkipGeneratedKeys() {
-    this.skipGeneratedKeys = true;
-    return this;
-  }
-
-  /**
-   * Return true if getGeneratedKeys should be skipped for this transaction.
-   */
-  public boolean isSkipGeneratedKeys() {
-    return skipGeneratedKeys;
-  }
-
-  /**
-   * Return if the transaction should be treated as read only.
-   */
-  public boolean isReadonly() {
-    return readOnly;
-  }
-
-  /**
-   * Set if the transaction should be treated as read only.
-   */
-  public TxScope setReadOnly(boolean readOnly) {
-    this.readOnly = readOnly;
-    return this;
-  }
-
-  /**
-   * Return the Isolation level this transaction should run with.
-   */
-  public TxIsolation getIsolation() {
-    return isolation;
-  }
-
-  /**
-   * Set the transaction isolation level this transaction should run with.
-   */
-  public TxScope setIsolation(TxIsolation isolation) {
-    this.isolation = isolation;
-    return this;
-  }
-
-  /**
-   * Return the serverName for this transaction. If this is null then the
-   * default server (default DataSource) will be used.
-   */
-  public String getServerName() {
-    return serverName;
-  }
-
-  /**
-   * Set the serverName (DataSource name) for which this transaction will be. If
-   * the serverName is not specified (left null) then the default server will be
-   * used.
-   */
-  public TxScope setServerName(String serverName) {
-    this.serverName = serverName;
-    return this;
-  }
-
-  /**
-   * Return the throwable's that should cause a rollback.
-   */
-  public ArrayList<Class<? extends Throwable>> getRollbackFor() {
-    return rollbackFor;
-  }
-
-  /**
-   * Set a Throwable that should explicitly cause a rollback.
-   */
-  public TxScope setRollbackFor(Class<? extends Throwable> rollbackThrowable) {
-    if (rollbackFor == null) {
-      rollbackFor = new ArrayList<Class<? extends Throwable>>(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<Class<? extends Throwable>>(rollbackThrowables.length);
-    }
-    for (int i = 0; i < rollbackThrowables.length; i++) {
-      rollbackFor.add((Class<? extends Throwable>) rollbackThrowables[i]);
-    }
-    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<Class<? extends Throwable>>(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<Class<? extends Throwable>>(noRollbacks.length);
-    }
-    for (int i = 0; i < noRollbacks.length; i++) {
-      noRollbackFor.add((Class<? extends Throwable>) noRollbacks[i]);
-    }
-    return this;
-  }
-
-}
@@ -1,50 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to define the transactional scope for executing a method. Matches the
- * types defined in the EJB TransactionAttributeType.
- * <p>
- * Used with the Transactional annotation and the {@link TxScope} with
- * {@link Ebean#execute(TxScope, TxCallable)} and
- * {@link Ebean#execute(TxScope, TxRunnable)}.
- * </p>
- * 
- * @see TxScope
- */
-public enum TxType {
-
-  /**
-   * Uses an existing transaction and if none exists will starts a new
-   * Transaction. This is the default.
-   */
-  REQUIRED,
-
-  /**
-   * A transaction MUST already have been started. Throws
-   * TransactionRequiredException.
-   */
-  MANDATORY,
-
-  /**
-   * Uses the existing transaction if one exists, otherwise the method does not
-   * run with a transaction. Used this with caution.
-   */
-  SUPPORTS,
-
-  /**
-   * Always start a new transaction. Suspend an existing once if required.
-   */
-  REQUIRES_NEW,
-
-  /**
-   * Suspends an existing transaction if required. Method runs without a
-   * transaction.
-   */
-  NOT_SUPPORTED,
-
-  /**
-   * If there is an existing transaction throws an Exception. Method runs
-   * without a transaction.
-   */
-  NEVER
-}
@@ -1,169 +0,0 @@
-package com.avaje.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 type="class">
- *  ...
- * &#064;NamedUpdates(value = {
- *   &#064;NamedUpdate(
- *      name = &quot;setTitle&quot;, 
- *      notifyCache = false, 
- *      update = &quot;update topic set title = :title, postCount = :count where id = :id&quot;),
- *  &#064;NamedUpdate(
- *      name = &quot;setPostCount&quot;, 
- *      notifyCache = false, 
- *      update = &quot;update f_topic set post_count = :postCount where id = :id&quot;),
- *  &#064;NamedUpdate(
- *      name = &quot;incrementPostCount&quot;, 
- *      notifyCache = false, 
- *      update = &quot;update Topic set postCount = postCount + 1 where id = :id&quot;) 
- *      //update = &quot;update f_topic set post_count = post_count + 1 where id = :id&quot;) 
- *  })
- * &#064;Entity
- * &#064;Table(name = &quot;f_topic&quot;)
- * public class Topic {
- *  ...
- * </pre>
- * 
- * <p>
- * The following show code that would use a named update on the Topic entity
- * bean.
- * </p>
- * 
- * <pre class="code">
- * Update&lt;Topic&gt; update = Ebean.createUpdate(Topic.class, &quot;incrementPostCount&quot;);
- * update.setParameter(&quot;id&quot;, 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);
-
-  /**
-   * Return the sql that is actually executed.
-   */
-  String getGeneratedSql();
-
-}
@@ -1,160 +0,0 @@
-package com.avaje.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>
- *
- * <h4>Example: Simple update</h4>
- *
- * <pre>{@code
- *
- *  int rows = ebeanServer
- *      .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>
- *
- * <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>
- *
- * <pre>{@code
- *
- *   int rows = ebeanServer
- *       .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>
- *
- * <pre>{@code sql
- *
- *   update o_customer set status=?, updtime=?
- *   where id in (
- *     select t0.id c0
- *     from o_customer t0
- *     left outer 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.
-   *
-   *
-   * <pre>{@code
-   *
-   *   int rows = ebeanServer
-   *      .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.
-   *
-   * <pre>{@code
-   *
-   *   int rows = ebeanServer
-   *      .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>
-   *
-   * <pre>{@code
-   *
-   *   int rows = ebeanServer
-   *      .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 = ebeanServer
-   *      .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);
-
-  /**
-   * Return the query expression list to add predicates to.
-   */
-  ExpressionList<T> where();
-
-}
@@ -1,57 +0,0 @@
-package com.avaje.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;
-  }
-
-  public String toString() {
-    return newValue + "," + oldValue;
-  }
-}
@@ -1,101 +0,0 @@
-package com.avaje.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;
-  }
-}
@@ -1,61 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify the default cache use specific entity type.
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Cache {
-
-  /**
-   * Set this to true to enable the use of query cache.
-   * <p>
-   * By default query caching is disabled as the query cache invalidates
-   * frequently and so it is typically used for specific bean types and cases.
-   * </p>
-   */
-  boolean enableQueryCache() default false;
-
-  /**
-   * Set this to false to disable the use of bean cache.
-   * <p>
-   * By default bean caching is expected so this defaults to true.  We might
-   * set this to false on a bean type that we want to use query caching but no
-   * bean caching (and this is expected to be a rare case).
-   * </p>
-   * <p>
-   * When bean caching is enabled by default "find by id" and "find by unique natural key"
-   * queries will try to use the bean cache. We use {@link com.avaje.ebean.Query#setUseCache(boolean)}
-   * with <code>false</code> for the case when we do NOT want to use the bean cache.
-   * </p>
-   */
-  boolean enableBeanCache() default true;
-
-  /**
-   * Specify the property that is a natural unique identifier for the bean.
-   * <p>
-   * When a findUnique() query is used with this property as the sole expression
-   * then there will be a lookup into the L2 natural key cache.
-   * </p>
-   */
-  String naturalKey() default "";
-
-  /**
-   * When set to true the beans returned from a query will default to be
-   * readOnly.
-   * <p>
-   * If the bean is readOnly and has no relationships then it may be sharable.
-   * </p>
-   * <p>
-   * If you try to modify a readOnly bean it will throw an
-   * IllegalStateException.
-   * </p>
-   */
-  boolean readOnly() default false;
-
-}
@@ -1,56 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Cache tuning hints for the L2 bean cache of a specific entity type.
- * <p>
- * Note that this is not useful when distributed L2 bean caches are used like
- * ElasticSearch, Hazelcast, Ignite etc.
- * </p>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface CacheBeanTuning {
-
-  /**
-   * The maximum size for the cache.
-   * <p>
-   * This defaults to 0 which means unlimited.
-   * </p>
-   */
-  int maxSize() default 0;
-
-  /**
-   * The maximum time (in seconds) that a cache entry is allowed to stay in the
-   * cache when it has not been accessed.
-   * <p>
-   * This defaults to 0 which means unlimited.
-   * </p>
-   */
-  int maxIdleSecs() default 0;
-
-  /**
-   * The maximum time (in seconds) a cache entry is allowed to stay in the
-   * cache.
-   * <p>
-   * This is not generally required as the cache entries are automatically
-   * evicted when related data changes are committed.
-   * </p>
-   * <p>
-   * This defaults to 0 which means unlimited.
-   * </p>
-   */
-  int maxSecsToLive() default 0;
-
-  /**
-   * The frequency (in seconds) that cache trimming should occur.
-   * <p>
-   * This is a hint for cache implementations that use background cache trimming.
-   * </p>
-   */
-  int trimFrequency() default 0;
-}
@@ -1,55 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify cache tuning for query caching on a specific entity type.
- * <p>
- * If this is not specified then the system default settings are used.
- * </p>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface CacheQueryTuning {
-
-  /**
-   * The maximum size for the cache.
-   * <p>
-   * This defaults to 0 which means unlimited.
-   * </p>
-   */
-  int maxSize() default 0;
-
-  /**
-   * The maximum time (in seconds) that a cache entry is allowed to stay in the
-   * cache when it has not been accessed.
-   * <p>
-   * This defaults to 0 which means unlimited.
-   * </p>
-   */
-  int maxIdleSecs() default 0;
-
-  /**
-   * The maximum time (in seconds) a cache entry is allowed to stay in the
-   * cache.
-   * <p>
-   * This is not generally required as the cache entries are automatically
-   * evicted when related data changes are committed.
-   * </p>
-   * <p>
-   * This defaults to 0 which means unlimited.
-   * </p>
-   */
-  int maxSecsToLive() default 0;
-
-  /**
-   * The frequency (in seconds) that cache trimming should occur.
-   * <p>
-   * This is a hint for cache implementations that use background cache trimming.
-   * </p>
-   */
-  int trimFrequency() default 0;
-}
@@ -1,34 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks an entity bean as being included in the change logging.
- */
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface ChangeLog {
-
-  /**
-   * Specify if inserts should be explicitly Included or Excluded.
-   * <p>
-   * If not defined explicitly then the server default behaviour defined
-   * on ServerConfig is used.
-   * </p>
-   */
-  ChangeLogInsertMode inserts() default ChangeLogInsertMode.DEFAULT;
-
-  /**
-   * When specified only include update requests that have at least one
-   * of the given properties as a dirty property.
-   * <p>
-   * This provides a way to filter requests to include in the change log such that
-   * only updates that include at least one of the given properties is included
-   * in the change log.
-   * </p>
-   */
-  String[] updatesThatInclude() default {};
-}
@@ -1,22 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * The mode used to determine if inserts should be included or not for a given bean type.
- */
-public enum ChangeLogInsertMode {
-
-  /**
-   * Use the default behaviour as defined on ServerConfig.
-   */
-  DEFAULT,
-
-  /**
-   * Include inserts in the change log.
-   */
-  INCLUDE,
-
-  /**
-   * Exclude inserts in the change log.
-   */
-  EXCLUDE
-}
@@ -1,38 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * For a timestamp property that is set to the datetime when the entity is
- * created/inserted.
- * <p>
- * This is effectively an alias for @WhenCreated which was added as it hints
- * towards a better naming convention (WhenCreated, WhenModified).
- * </p>
- * <p>
- * An alternative to using this annotation would be to use insertable=false,
- * updateable=false with @Column and have the DB insert the current time
- * (default value on the DB column is SYSTIME etc).
- * </p>
- * <p>
- * The downside to this approach is that the inserted entity does not have the
- * timestamp value after the insert has occurred. You need to fetch the entity
- * back to get the inserted timestamp if you want to used it.
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @CreatedTimestamp
- *   Timestamp whenCreated;
- *
- * }</pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface CreatedTimestamp {
-
-}
@@ -1,40 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify a collection property that will be stored into a DB ARRAY type.
- * <p>
- * If the target database does not support ARRAY type (so not Postgres)
- * then the collection will be stored in JSON format into a VARCHAR column.
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- * // Store as ARRAY of UUID on Postgres
- * @DbArray
- * List<UUID> uids = new ArrayList<>();
- *
- * // Store as ARRAY on Postgres
- * @DbArray
- * List<String> phoneNumbers = new ArrayList<>();
- *
- * // Store as ARRAY of INTEGER on Postgres
- * @DbArray
- * List<Long> someLongs = new ArrayList<>();
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DbArray {
-
-  /**
-   * For VARCHAR storage specify the column length (defaults to 1000).
-   */
-  int length() default 0;
-}
@@ -1,19 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * A database table or column comment.
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
-public @interface DbComment {
-
-  /**
-   * The database table or column comment.
-   */
-  String value();
-}
@@ -1,17 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * Specify the DB storage type used to with <code>@DbEnumValue</code>.
- */
-public enum DbEnumType {
-
-  /**
-   * Store values as database INTEGER.
-   */
-  INTEGER,
-
-  /**
-   * Store values as database VARCHAR.
-   */
-  VARCHAR
-}
@@ -1,44 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify a method on an Enum that returns the value that should be stored in the DB.
- * <p>
- * This is the preferred option for mapping Enum's to DB values (preferred over the JPA
- * standard @Enumerated and Ebean's @EnumValue annotations).
- * </p>
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   public enum Status {
- *     NEW("N"),
- *     ACTIVE("A"),
- *     INACTIVE("I");
- *
- *     String dbValue;
- *     Status(String dbValue) {
- *       this.dbValue = dbValue;
- *     }
- *
- *     @DbEnumValue
- *     public String getValue() {
- *       return dbValue;
- *     }
- *   }
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.METHOD)
-public @interface DbEnumValue {
-
-  /**
-   * Specify the database type used to store the values (VARCHAR or INTEGER).
-   */
-  DbEnumType storage() default DbEnumType.VARCHAR;
-
-}
@@ -1,30 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Used for mapping a Map<String,String> type property to Postgres HSTORE data type.
- * <p>
- * The Map property should have keys and values of type String.
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @DbHstore
- *   Map<String, String> tags;
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DbHstore {
-
-  /**
-   * For VARCHAR storage specify the column length (defaults to 1000).
-   */
-  int length() default 0;
-}
@@ -1,44 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify a property holding JSON content.
- * <p>
- * By default the content will be stored in a DB Clob except on Postgres where DB JSON type is used.
- * </p>
- * <h3>Example:</h3>
- * <pre>{@code
- *
- * // Store as JSON on Postgres or Clob on other databases
- * @DbJson
- * Map<String,Object> content;
- *
- * }</pre>
- *
- * <h3>Example with JSONB storage</h3>
- * <pre>{@code
- *
- * // Store as JSONB on Postgres or Clob on other databases
- * @DbJson(storage = DbJsonType.JSONB)
- * Map<String,Object> content;
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DbJson {
-
-  /**
-   * Specify the database type used to store the JSON content.
-   */
-  DbJsonType storage() default DbJsonType.JSON;
-
-  /**
-   * For VARCHAR storage specify the column length (defaults to 3000).
-   */
-  int length() default 0;
-}
@@ -1,43 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify a property holding JSON content.
- * <p>
- * The content will be stored on Postgres using it's JSONB type and as Clob for other databases.
- * </p>
- * <p>
- *   This is equivalent to using <code>@DbJson(storage = DbJsonType.JSONB)</code>
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- * // Store as JSONB on Postgres or Clob on other databases
- * @DbJsonB
- * Map<String,Object> content;
- *
- * }</pre>
- *
- * <h3>Equivalent to:</h3>
- * <pre>{@code
- *
- * // Store as JSONB on Postgres or Clob on other databases
- * @DbJson(storage = DbJsonType.JSONB)
- * Map<String,Object> content;
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DbJsonB {
-
-  /**
-   * For VARCHAR storage specify the column length.
-   */
-  int length() default 0;
-}
@@ -1,32 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * Specify the DB storage type used to store JSON content.
- */
-public enum DbJsonType {
-
-  /**
-   * Store as JSON on Postgres and for other databases store as CLOB.
-   */
-  JSON,
-
-  /**
-   * Store as JSONB on Postgres and for other databases store as CLOB.
-   */
-  JSONB,
-
-  /**
-   * Store as database VARCHAR.
-   */
-  VARCHAR,
-
-  /**
-   * Store as database CLOB.
-   */
-  CLOB,
-
-  /**
-   * Store as database BLOB.
-   */
-  BLOB
-}
@@ -1,32 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Used to indicate that a particular string property should be treated as a 'code' and not analysed for text searching.
- * <p>
- * By default all Id properties and all Enum properties are treated as 'code' and not analysed.
- * </p>
- */
-@Target({ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface DocCode {
-
-  /**
-   * Set to true to have the property additionally stored separately from _source.
-   */
-  boolean store() default false;
-
-  /**
-   * Set a boost value specific to this property.
-   */
-  float boost() default 1;
-
-  /**
-   * Set a value to use instead of null.
-   */
-  String nullValue() default "";
-}
@@ -1,37 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify the property is included in the parent document store index.
- *
- * <pre>{@code
- *
- *
- * @DocStore
- * @Entity @Table(name = "o_order")
- * public class Order {
- *
- *   ...
- *   // include some customer details including
- *   // nested billingAddress
- *   @DocEmbedded(doc = "id,status,name,billingAddress(*,country(*)")
- *   @ManyToOne
- *   Customer customer;
- *
- *
- * }</pre>
- */
-@Target({ ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface DocEmbedded {
-
-  /**
-   * The properties on the embedded bean to include in the index.
-   */
-  String doc() default "";
-
-}
@@ -1,24 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify the entity type maps to a document store (like ElasticSearch).
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface DocMapping {
-
-  /**
-   * The property name the mapping applies to.
-   */
-  String name();
-
-  /**
-   * Mapping options.
-   */
-  DocProperty options();
-}
@@ -1,110 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify the entity type maps to a document store (like ElasticSearch).
- */
-@Target({ ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface DocProperty {
-
-  /**
-   * Set this to true to indicate that this property should be un-analysed.
-   */
-  boolean code() default false;
-
-  /**
-   * Set this to true to get an additional un-analysed 'raw' field to use for sorting etc.
-   */
-  boolean sortable() default false;
-
-  /**
-   * Set to true to have the property additionally stored separately from _source.
-   */
-  boolean store() default false;
-
-  /**
-   * Set a boost value specific to this property.
-   */
-  float boost() default 1;
-
-  /**
-   * Set a value to use instead of null.
-   */
-  String nullValue() default "";
-
-  /**
-   * Set this to false to exclude this from the _all property.
-   */
-  boolean includeInAll() default true;
-
-  /**
-   * The analyzer to use.
-   */
-  String analyzer() default "";
-
-  /**
-   * The analyzer to use for searches.
-   */
-  String searchAnalyzer() default "";
-
-  /**
-   * The index options for this property.
-   */
-  Option options() default Option.DEFAULT;
-
-  /**
-   * Set this to false such that doc values are not stored separately for this property.
-   */
-  boolean docValues() default true;
-
-  /**
-   * Set a copyTo field.
-   */
-  String copyTo() default "";
-
-  /**
-   * Set to false to disable the field from indexing, it will only be get/set in _source.
-   */
-  boolean enabled() default true;
-
-  /**
-   * Set to false such that norms are not stored.
-   */
-  boolean norms() default true;
-
-  /**
-   * Index options for a property.
-   */
-  enum Option {
-
-    /**
-     * Only index the doc number.
-     */
-    DOCS,
-
-    /**
-     * Doc number and term frequencies are indexed.
-     */
-    FREQS,
-
-    /**
-     * Doc number, term frequencies and term positions are indexed.
-     */
-    POSITIONS,
-
-    /**
-     * Doc number, term frequencies, term positions and start/end offsets are indexed.
-     */
-    OFFSETS,
-
-    /**
-     * Use the default which means analysed string properties use POSITIONS as the default and all other types use DOCS.
-     */
-    DEFAULT
-  }
-}
@@ -1,34 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Used to indicate that a particular string property should support sorting. What this typically means is that
- * for ElasticSearch an additional 'raw' field is added that stores the un-analysed value. This un-analysed value
- * can be used for sorting etc and the original field used for text searching.
- * <p>
- * For example, customer name and product name are good candidates for marking with @DocSortable.
- * </p>
- */
-@Target({ ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface DocSortable {
-
-  /**
-   * Set to true to have the property additionally stored separately from _source.
-   */
-  boolean store() default false;
-
-  /**
-   * Set a boost value specific to this property.
-   */
-  float boost() default 1;
-
-  /**
-   * Set a value to use instead of null.
-   */
-  String nullValue() default "";
-}
@@ -1,88 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify the entity type maps to a document store (like ElasticSearch).
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface DocStore {
-
-  /**
-   * A unique Id used when queuing reindex events.
-   */
-  String queueId() default "";
-
-  /**
-   * The ElasticSearch index name. If left unspecified the short name of the bean type is used.
-   */
-  String indexName() default "";
-
-  /**
-   * The ElasticSearch index type. If left unspecified the short name of the bean type is used.
-   */
-  String indexType() default "";
-
-  /**
-   * The number of shards this index should use.
-   */
-  int shards() default 0;
-
-  /**
-   * The number of replicas this index should use.
-   */
-  int replicas() default 0;
-
-  /**
-   * Additional mapping that can be defined on the properties.
-   */
-  DocMapping[] mapping() default {};
-
-  /**
-   * Specify the behavior when bean Insert, Update, Delete events occur.
-   */
-  DocStoreMode persist() default DocStoreMode.DEFAULT;
-
-  /**
-   * Specify the behavior when bean Insert occurs.
-   */
-  DocStoreMode insert() default DocStoreMode.DEFAULT;
-
-  /**
-   * Specify the behavior when bean Update occurs.
-   */
-  DocStoreMode update() default DocStoreMode.DEFAULT;
-
-  /**
-   * Specify the behavior when bean Delete occurs.
-   */
-  DocStoreMode delete() default DocStoreMode.DEFAULT;
-
-  /**
-   * Specify to include only some properties in the doc store document.
-   * <p>
-   * If this is left as default then all scalar properties are included,
-   * all @ManyToOne properties are included with just the nested id property
-   * and no @OneToMany properties are included.
-   * </p>
-   * <p>
-   * Note that typically DocStoreEmbedded is used on @ManyToOne and @OneToMany
-   * properties to indicate what part of the nested document should be included.
-   * </p>
-   *
-   * <h3>Example:</h3>
-   * <pre>{@code
-   *
-   * // only include the customer id and name
-   * @DocStore(doc = "id,name")
-   * @Entity @Table(name = "o_order")
-   * public class Customer {
-   *
-   * }</pre>
-   */
-  String doc() default "";
-}
@@ -1,38 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * Defines the behavior options when a Insert, Update or Delete event occurs
- * on a bean with an associated ElasticSearch index.
- * <p>
- * For some indexes or some transactions it can be beneficial to queue the event
- * for later processing rather than look to update ElasticSearch at that time.
- * </p>
- */
-public enum DocStoreMode {
-
-  /**
-   * Add the event to the queue for processing later (delaying the update to the document store).
-   */
-  QUEUE,
-
-  /**
-   * Update the document store when transaction succeeds.
-   */
-  UPDATE,
-
-  /**
-   * Ignore the event and not update the document store.
-   * <p>
-   *   This can be used on a index or for a transaction where you want to have more
-   *   manual programmatic control over the updating of the document store.  Say you want to
-   *   IGNORE on a particular transaction and instead manually queue a bulk update.
-   * </p>
-   */
-  IGNORE,
-
-  /**
-   * The actual mode of QUEUE, UPDATE or IGNORE is set from the default configuration.
-   */
-  DEFAULT
-
-}
@@ -1,19 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks a boolean property on a @Draftable bean that indicates if the bean instance is a 'draft' or 'live' bean.
- * The property is transient and has no underlying DB column.
- * <p>
- * For beans returned from an <code>asDraft()</code> query this property will be set to true.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface Draft {
-
-}
@@ -1,20 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks a boolean property on a @Draftable bean that only exists on the 'draft' table
- * and is used to detect when a draft has unpublished changes.
- * <p>
- * This property will automatically have it's value set to true when a draft is saved and
- * automatically have it's value set to false when the bean is published.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DraftDirty {
-
-}
@@ -1,19 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks a property on a @Draftable bean that only exists on the 'draft' and not the 'live' table.
- * <p>
- * Typically this would be used on a property that is used as part of application 'workflow' such as
- * a publish workflow status or when publish timestamp.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DraftOnly {
-
-}
@@ -1,19 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks a property on a @Draftable bean that is set to null on the 'draft bean' on publish.
- * <p>
- * This is expected to be put on properties that get 'reset' or 'cleared' after a publish.
- * These properties might represent a publish comment or publish timestamp.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DraftReset {
-
-}
@@ -1,29 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Used to indicate an entity bean that has 'draftable' support.
- * <p>
- * This means that a second set of tables is created to hold draft versions of
- * the rows and that these can then be published which effectively copies/transfers
- * the values from the 'draft' table to the 'live' table.
- * </p>
- * <p>
- * Ebean Query supports 'find as draft' which builds the resulting object graph using
- * the draft tables. This object graph is typically edited, approved in some application
- * specific manor and then published.
- * </p>
- * <p>
- * EbeanServer has a publish method which transfers/copies the draft object graph to
- * the 'live' tables.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-public @interface Draftable {
-
-}
@@ -1,20 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Used to indicate an entity bean that has 'draftable' support but it not a 'top level'
- * (or root level) bean but instead child related to another @Draftable entity bean.
- * <p>
- * Relationships to @DraftableElements (@OneToMany, @ManyToMany etc) are automatically
- * deemed to have Cascade.ALL for save and delete (as well as orphan removal mode).
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-public @interface DraftableElement {
-
-}
@@ -1,31 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify property name to db column mapping for Embedded beans.
- * <p>
- * This is designed to be easier to use than the AttributeOverride annotation in
- * standard JPA.
- * </p>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface EmbeddedColumns {
-
-  /**
-   * A list of property names mapped to DB columns.
-   * <p>
-   * For example <code>currency=IN_CURR, amount=IN_AMOUNT</code>
-   * </p>
-   * <p>
-   * Where currency and amount are properties and IN_CURR and IN_AMOUNT are the
-   * respective DB columns these properties will be mapped to.
-   * </p>
-   */
-  String columns() default "";
-
-}
@@ -1,24 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify that the property is stored in encrypted form.
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Encrypted {
-
-  /**
-   * When true try to use DB encryption rather than local java encryption.
-   */
-  boolean dbEncryption() default true;
-
-  /**
-   * Used to specify the DB column length.
-   */
-  int dbLength() default 0;
-}
@@ -1,48 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Enables you to specify a value to use to persist for an enum value.
- * 
- * <pre>{@code
- *
- * public enum Status {
- *
- *   @EnumValue("N")
- *   NEW,
- * 
- *   @EnumValue("A")
- *   ACTIVE,
- * 
- *   @EnumValue("I")
- *   INACTIVE,
- * }
- * 
- * }</pre>
- * <p>
- * This is an alternative to using the JPA standard approach or Ebean's
- * {@link DbEnumValue} annotation.
- * </p>
- * <p>
- * Note that if all the EnumValue values are parsable as Integers then Ebean
- * will persist and fetch them as integers - otherwise they will be persisted
- * and fetched as strings.
- * </p>
- */
-@Target({ ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface EnumValue {
-
-  /**
-   * Specify the value to persist for a specific enum value.
-   * <p>
-   * If all the values are parsable as Integers then Ebean will persist and
-   * fetch them as integers rather than strings.
-   * </p>
-   */
-  String value();
-}
@@ -1,28 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/*
-    Copied from gson!!!
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface Expose {
-
-  /**
-   * If {@code true}, the field marked with this annotation is written out in the JSON while
-   * serializing. If {@code false}, the field marked with this annotation is skipped from the
-   * serialized output. Defaults to {@code true}.
-   */
-  boolean serialize() default true;
-
-  /**
-   * If {@code true}, the field marked with this annotation is deserialized from the JSON.
-   * If {@code false}, the field marked with this annotation is skipped during deserialization.
-   * Defaults to {@code true}.
-   */
-  boolean deserialize() default true;
-}
@@ -1,106 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import com.avaje.ebean.Query;
-
-/**
- * Assign to a property to be based on a SQL formula.
- * <p>
- * This is typically a SQL Literal value, SQL case statement, SQL function or
- * similar.
- * </p>
- * <p>
- * Any property based on a formula becomes a read only property.
- * </p>
- * <p>
- * You may also put use the Transient annotation with the Formula annotation.
- * The effect of the Transient annotation in this case is that the formula will
- * <b>NOT</b> be included in queries by default - you have to explicitly include
- * it via {@link Query#select(String)} or {@link Query#fetch(String, String, com.avaje.ebean.FetchConfig)}.
- * You may want to do this if the Formula is relatively expensive and only want
- * it included in the query when you explicitly state it.
- * </p>
- * 
- * <pre class="code">
- * // On the Order &quot;master&quot; bean
- * // ... a formula using the Order details
- * // ... sum(order_qty*unit_price)
- * &#064;Transient
- * &#064;Formula(select = &quot;_b${ta}.total_amount&quot;, join = &quot;join (select order_id, sum(order_qty*unit_price) as total_amount from o_order_detail group by order_id) as _b${ta} on _b${ta}.order_id = ${ta}.id&quot;)
- * Double totalAmount;
- * 
- * </pre>
- * <p>
- * As the totalAmount formula is also Transient it is not included by default in
- * queries - it needs to be explicitly included.
- * </p>
- * 
- * <pre>{@code
- *
- * // find by Id
- * Order o1 = Ebean.find(Order.class)
- *     .select("id, totalAmount")
- *     .setId(1).findUnique();
- * 
- * // find list ... using totalAmount in the where clause
- * List<Order> list = Ebean.find(Order.class)
- *     .select("id, totalAmount")
- *     .where()
- *     .eq("status", Order.Status.NEW)
- *     .gt("totalAmount", 10)
- *     .findList();
- * 
- * // as a join from customer
- * List<Customer> l0 = Ebean.find(Customer.class)
- *     .select("id, name")
- *     .fetch("orders", "status, totalAmount")
- *     .where()
- *     .gt("id", 0)
- *     .gt("orders.totalAmount", 10)
- *     .findList();
- * 
- * }</pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Formula {
-
-  /**
-   * The SQL to be used in the SELECT part of the SQL to populate a property.
-   */
-  String select();
-
-  /**
-   * OPTIONAL - the SQL to be used in the JOIN part of the SQL to support the
-   * formula.
-   * <p>
-   * This is commonly used to join a 'dynamic view' to support aggregation such
-   * as count, sum etc.
-   * </p>
-   * <p>
-   * The join string should start with either "left outer join" or "join".
-   * </p>
-   * 
-   * <p>
-   * You will almost certainly use the "${ta}" as a place holder for the table
-   * alias of the table you are joining back to (the "base table" of the entity
-   * bean).
-   * </p>
-   * <p>
-   * The example below is used to support a total count of topics created by a
-   * user.
-   * </p>
-   * 
-   * <pre>{@code
-   *
-   * join (select user_id, count(*) as topic_count from f_topic group by user_id) as _tc on _tc.user_id = ${ta}.id
-   *
-   * }</pre>
-   */
-  String join() default "";
-
-}
@@ -1,19 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks an entity bean as having history support.
- * <p>
- * In Postgres for example this means there is an associated history table which is
- * typically automatically populated via database triggers.
- * </p>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface History {
-
-}
@@ -1,25 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks a property as being excluded from history.
- * <p>
- * This means the property values are not maintained in the history table. Typically this
- * would be placed on relatively large properties (Clobs, Blobs, large varchar columns etc)
- * that are considered not interesting enough to maintain history on excluding them reduces
- * underlying database costs.
- * </p>
- * <p>
- * When placed on a ManyToMany this means that the intersection table does not have history
- * support.
- * </p>
- */
-@Target({ ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface HistoryExclude {
-
-}
@@ -1,33 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * An annotation for declaring an index on a single column.
- *
- * @author rvbiljouw
- */
-@Target({ElementType.TYPE, ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Index {
-
-  /**
-   * Name of the index. If left blank a name is derived using the built in naming convention.
-   */
-  String name() default "";
-
-  /**
-   * If set true indicates this is a unique index.
-   */
-  boolean unique() default false;
-
-  /**
-   * When placed on the class (rather than field) you can specify the columns
-   * to include in the index in order.
-   */
-  String[] columnNames() default {};
-
-}
@@ -1,32 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Similar to Jackson JsonIgnore but provides the option to just ignore serialize or deserialize.
- * <p>
- *   This provides the same features as Expose but from the opposite perspective which is probably
- *   more common and more familiar to Jackson users.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface JsonIgnore {
-
-  /**
-   * If {@code true}, the field marked with this annotation is written out in the JSON while
-   * serializing. If {@code false}, the field marked with this annotation is skipped from the
-   * serialized output. Defaults to {@code false}.
-   */
-  boolean serialize() default false;
-
-  /**
-   * If {@code true}, the field marked with this annotation is deserialized from the JSON.
-   * If {@code false}, the field marked with this annotation is skipped during deserialization.
-   * Defaults to {@code false}.
-   */
-  boolean deserialize() default false;
-}
@@ -1,34 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Specify that the elements of a OneToMany are private owned.
- * <p>
- * This means that if they are removed from the List/Set/Map they will be
- * deleted when their parent object is saved.
- * </p>
- * <p>
- * This could also be described as deleting orphans - in that beans removed from
- * the List/Set/Map will be deleted automatically when the parent bean is saved.
- * They are considered 'orphans' when they have been removed from the collection
- * in that they are no longer associated/linked to their parent bean.
- * </p>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface PrivateOwned {
-
-  /**
-   * Set this to false if you don't want cascade REMOVE on this relationship.
-   * <p>
-   * That is, by default PrivateOwned implicitly adds a cascade REMOVE to the
-   * relationship and if you don't want that you need to set this to false.
-   * </p>
-   */
-  boolean cascadeRemove() default true;
-
-}
@@ -1,15 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks an entity bean as being included in read auditing.
- */
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface ReadAudit {
-
-}
@@ -1,25 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Used to indicate a property on an entity bean used to control 'soft delete'
- * (also known as 'logical delete').
- * <p>
- * The property should be of type boolean.
- * </p>
- * <pre>{@code
- *
- * @SoftDelete
- * boolean deleted;
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface SoftDelete {
-
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Robin Bygrave	7480904792	[maven-release-plugin] prepare release ebean-spring-7.1.2	2016-08-03 17:46:18 +12:00
Robin Bygrave	b12cfafc21	Change groupId to ... org.avaje.ebean, and artifactId to ... ebean-spring	2016-08-03 17:45:51 +12:00
Robin Bygrave	f07727651e	[maven-release-plugin] prepare for next development iteration	2016-05-18 08:33:54 +12:00
Robin Bygrave	6090eaa167	[maven-release-plugin] prepare release avaje-ebeanorm-spring-7.1.1	2016-05-18 08:33:34 +12:00
Robin Bygrave	40eada4e80	#6 - Modify POM dependencies, change to provided scope for Ebean and Spring context	2016-05-18 08:33:04 +12:00
Robin Bygrave	2d375b3596	[maven-release-plugin] prepare for next development iteration	2015-11-04 08:34:33 +13:00
Robin Bygrave	d864e2c723	[maven-release-plugin] prepare release avaje-ebeanorm-spring-6.1.1	2015-11-04 08:34:08 +13:00
Robin Bygrave	e50c372562	Bump pom to 6.1.1-SNAPSHOT	2015-11-04 08:33:37 +13:00
Robin Bygrave	e2cb033119	#5 - Error creating bean with name 'serverConfig' defined in class path resource [init-database.xml]: Cannot create inner bean 'com.avaje.ebean.config.AutofetchConfig#2e385cce' of type [com.avaje.ebean.config.AutofetchConfig] while setting bean property 'autofetchConfig'	2015-11-04 08:33:16 +13:00
Robin Bygrave	9620c57f19	[maven-release-plugin] prepare for next development iteration	2015-07-30 05:03:49 +12:00
Robin Bygrave	07cc0fcbb6	[maven-release-plugin] prepare release avaje-ebeanorm-spring-4.5.3	2015-07-30 05:03:28 +12:00
Robin Bygrave	6d1beb5c03	Add javadoc-plugin to pom	2015-07-30 05:03:05 +12:00
Robin Bygrave	1667107422	Update spring xsd to spring-beans-4.1.xsd	2015-07-30 04:57:03 +12:00
Robin Bygrave	de5cf1df2c	No effective change - format	2015-07-30 04:54:25 +12:00
Robin Bygrave	a83114ced2	Update tests and dependencies	2015-07-30 04:53:25 +12:00
Rob Bygrave	d6983422bf	Merge pull request #3 from abguorui0928/master Create AgentLoaderSupport.java	2015-05-14 22:45:43 +12:00
guor	6d4b3ad84e	Create AgentLoaderSupport.java add support for setup enhancement in spring	2015-05-11 21:01:58 +08:00
Eddie Mc Greal	a3df7919b5	Updated to correct ebeanorm dependency range	2015-01-20 09:54:21 +01:00
Rob Bygrave	6f1aa39cc9	Merge pull request #2 from nedge/master Update Version to 4.1.9 and edited MANIFEST for OSGi	2014-10-15 19:56:11 +13:00
Eddie Mc Greal	f18c24c1d1	Update Version to 4.1.9 and edited MANIFEST for OSGi	2014-10-14 08:11:32 +02:00
Rob Bygrave	068401c29c	[maven-release-plugin] prepare for next development iteration	2014-04-02 22:15:51 +13:00
Rob Bygrave	6fbbd8b107	[maven-release-plugin] prepare release avaje-ebeanorm-spring-3.3.1	2014-04-02 22:15:25 +13:00
Rob Bygrave	6379bd9e5d	Set pom to 3.3.1-SNAPSHOT, ready for release	2014-04-02 22:12:31 +13:00
Rob Bygrave	94d58dfa7c	Merge pull request #1 from nedge/develop Changed to correct version and removed old logging config stuff	2014-04-02 22:08:21 +13:00
Eddie Mc Greal	035fb80959	Changed to correct version and removed old logging config stuff	2014-03-06 22:17:55 +01:00
Robin Bygrave	3b97f77083	[maven-release-plugin] prepare for next development iteration	2013-04-29 21:27:36 +12:00
Robin Bygrave	a7d47202e6	[maven-release-plugin] prepare release avaje-ebeanorm-spring-3.2.1	2013-04-29 21:27:19 +12:00
Robin Bygrave	199a9d3118	Opps, fixed scm location	2013-04-29 21:26:37 +12:00
Robin Bygrave	5df3ac4b04	Change package of test beans etc for enhancement	2013-04-29 21:13:37 +12:00
Robin Bygrave	782f77b688	[maven-release-plugin] prepare for next development iteration	2012-09-15 01:32:05 +12:00
Robin Bygrave	1d570a233e	[maven-release-plugin] prepare release avaje-ebeanorm-spring-3.1.1	2012-09-15 01:31:49 +12:00
Robin Bygrave	4a6b58bd9b	Remove commons logging from dependency	2012-09-15 01:30:21 +12:00
rbygrave	d64073bef0	Change license to Apache2, clean up dependencies	2012-09-15 01:15:37 +12:00
rbygrave	6d8a9236f8	initial add of EbeanORM spring from v2.8.1	2012-09-14 01:06:56 +12:00
Rob Bygrave	1665b4f2fa	Initial commit	2012-09-13 05:59:29 -07:00