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

The issue was due to the loaded status not being recursively set on embedded
beans after inserts. The test case invoked lazy loading due to that which
lead to the issue.

.editorconfig

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

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,19 @@
+
+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
+```

.travis.yml

@@ -1,3 +1,4 @@
+dist: trusty
 sudo: required
 language: java
 jdk:
@@ -7,7 +8,7 @@ git:
   depth: 3
 
 addons:
-  postgresql: "9.4"
+  postgresql: "9.6"
 
 services:
   - postgresql

README.md

@@ -1,14 +1,17 @@
-* [![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
+# 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")
 
 
-Ebean ORM
-==============
-[https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Website")
+## Maven cental links:
+[Maven central - ebean](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22io.ebean%22%20AND%20a%3A%22ebean%22 "maven central ebean")
 
+[Maven central - all related projects](http://search.maven.org/#search%7Cga%7C1%7Cebean "maven central all related projects")
 
-[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 : ebean](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean) - ebean
+* [![Maven Central : ebean-agent](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-agent) - ebean-agent
+* [![Maven Central : ebean-maven-plugin](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-maven-plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-maven-plugin) - ebean-maven-plugin
 

howto-test.md

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

pom.xml

@@ -3,44 +3,73 @@
 
   <parent>
     <groupId>org.avaje</groupId>
-    <artifactId>avaje-javaparent</artifactId>
-    <version>1.2</version>
+    <artifactId>java8-parent</artifactId>
+    <version>1.3</version>
   </parent>
 
-  <groupId>org.avaje.ebeanorm</groupId>
-  <artifactId>avaje-ebeanorm</artifactId>
-  <version>7.4.1</version>
+  <groupId>io.ebean</groupId>
+  <artifactId>ebean</artifactId>
+  <version>11.1.1</version>
   <packaging>jar</packaging>
 
-  <name>avaje-ebeanorm</name>
+  <name>ebean</name>
   <url>http://ebean-orm.github.io/</url>
 
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-  </properties>
-
-  <licenses>
-    <license>
-      <name>The Apache Software License, Version 2.0</name>
-      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <developers>
-    <developer>
-      <id>rbygrave</id>
-      <name>Rob Bygrave</name>
-      <email>robin.bygrave@gmail.com</email>
-    </developer>
-  </developers>
-
   <scm>
-    <connection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm.git</connection>
-    <developerConnection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm.git</developerConnection>
-    <url>https://github.com/ebean-orm/avaje-ebeanorm.git</url>
+    <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
+    <tag>ebean-11.1.1</tag>
   </scm>
 
+  <profiles>
+    <profile>
+      <!-- Note: to use this profile, you need credentials for the oracle repository in your
+        settings.xml as described here:
+        http://docs.oracle.com/middleware/1213/core/MAVEN/config_maven_repo.htm#MAVEN9010 -->
+      <id>oracle</id>
+      <dependencies>
+        <dependency>
+          <groupId>com.oracle.jdbc</groupId>
+          <artifactId>ojdbc8</artifactId>
+          <version>12.2.0.1</version>
+          <scope>test</scope>
+        </dependency>
+      </dependencies>
+      <repositories>
+        <repository>
+          <id>maven.oracle.com</id>
+          <releases>
+            <enabled>true</enabled>
+          </releases>
+          <snapshots>
+            <enabled>false</enabled>
+          </snapshots>
+          <url>https://maven.oracle.com</url>
+          <layout>default</layout>
+        </repository>
+      </repositories>
+    </profile>
+    <profile>
+      <!-- Note: to use this profile, you need to download manually the db2jcc4 driver.
+        After that, install it into your local maven repository:
+
+        mvn install:install-file \
+          -Dfile=db2jcc4.jar \
+          -DgroupId=com.ibm.jdbc \
+          -DartifactId=db2jcc4 \
+          -Dversion=4.23.42 \
+          -Dpackaging=jar
+      -->
+      <id>db2</id>
+      <dependencies>
+        <dependency>
+          <groupId>com.ibm.jdbc</groupId>
+          <artifactId>db2jcc4</artifactId>
+          <version>4.23.42</version>
+          <scope>test</scope>
+        </dependency>
+      </dependencies>
+    </profile>
+  </profiles>
   <dependencies>
 
     <dependency>
@@ -50,9 +79,15 @@
     </dependency>
 
     <dependency>
-      <groupId>javax.persistence</groupId>
+      <groupId>io.ebean</groupId>
       <artifactId>persistence-api</artifactId>
-      <version>1.0</version>
+      <version>2.2.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-annotation</artifactId>
+      <version>3.1</version>
     </dependency>
 
     <dependency>
@@ -64,42 +99,52 @@
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-datasource</artifactId>
-      <version>1.1.1</version>
+      <version>2.1.2</version>
     </dependency>
 
-    <!--<dependency>-->
-      <!--<groupId>org.avaje</groupId>-->
-      <!--<artifactId>avaje-datasource-alert</artifactId>-->
-      <!--<version>1.1.1</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.4</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-migration</artifactId>
+      <version>10.3.1</version>
+    </dependency>
 
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
-      <version>1.7.7</version>
+      <version>[1.7.1,1.7.99)</version>
     </dependency>
 
-    <!-- provided scope for Spring boot loader classpath scanning support -->
     <dependency>
-      <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-loader</artifactId>
-      <version>1.2.7.RELEASE</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <!-- provided scope for JsonNode support -->
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-databind</artifactId>
-      <version>2.6.5</version>
-      <scope>provided</scope>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime</artifactId>
+      <version>4.6</version>
     </dependency>
 
     <!-- Jackson core used internally by Ebean -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
-      <version>2.6.5</version>
+      <version>2.9.0</version>
+    </dependency>
+
+    <!-- provided scope for JsonNode support -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.9.0</version>
+      <scope>provided</scope>
     </dependency>
 
     <dependency>
@@ -113,21 +158,21 @@
     <dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
-      <version>1.0.0.GA</version>
+      <version>1.1.0.Final</version>
       <scope>provided</scope>
     </dependency>
 
     <dependency>
       <groupId>javax.servlet</groupId>
-      <artifactId>servlet-api</artifactId>
-      <version>2.4</version>
+      <artifactId>javax.servlet-api</artifactId>
+      <version>3.1.0</version>
       <scope>provided</scope>
     </dependency>
 
     <dependency>
       <groupId>joda-time</groupId>
       <artifactId>joda-time</artifactId>
-      <version>1.6</version>
+      <version>2.9.7</version>
       <scope>provided</scope>
     </dependency>
 
@@ -135,10 +180,12 @@
     <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
-      <version>9.4-1202-jdbc41</version>
+      <version>9.4.1212</version>
       <scope>provided</scope>
     </dependency>
 
+    <!-- Test scope -->
+
     <!--<dependency>-->
       <!--<groupId>oracle</groupId>-->
       <!--<artifactId>oracle-jdbc</artifactId>-->
@@ -153,24 +200,17 @@
       <!--<scope>test</scope>-->
     <!--</dependency>-->
 
-    <dependency>
-      <groupId>com.squareup.okhttp</groupId>
-      <artifactId>okhttp</artifactId>
-      <version>2.4.0</version>
-      <scope>provided</scope>
-    </dependency>
-
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-agentloader</artifactId>
-      <version>1.1.1</version>
+      <version>2.1.2</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.ebeanorm</groupId>
-      <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.9.2</version>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-agent</artifactId>
+      <version>11.1.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -179,28 +219,36 @@
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.4.189</version>
+      <version>1.4.193</version>
       <scope>provided</scope>
     </dependency>
-    
+
     <dependency>
       <groupId>org.xerial</groupId>
       <artifactId>sqlite-jdbc</artifactId>
-      <version>3.8.11.2</version>
+      <version>3.15.1</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>org.hsqldb</groupId>
       <artifactId>hsqldb</artifactId>
-      <version>2.0.0</version>
+      <version>2.3.4</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>com.microsoft.sqlserver</groupId>
+      <artifactId>mssql-jdbc</artifactId>
+      <version>6.1.3.jre8-preview</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
-      <version>5.1.36</version>
+      <!-- Do not upgrade to 6.0.6: https://bugs.mysql.com/bug.php?id=82896 -->
+      <version>5.1.43</version>
       <scope>test</scope>
     </dependency>
 
@@ -215,41 +263,36 @@
     <dependency>
       <groupId>commons-io</groupId>
       <artifactId>commons-io</artifactId>
-      <version>2.4</version>
+      <version>2.5</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje.moduuid</groupId>
+      <artifactId>avaje-moduuid</artifactId>
+      <version>2.1</version>
       <scope>test</scope>
     </dependency>
 
   </dependencies>
 
 
-  <!-- Enhance the meta beans -->
   <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.ebeanorm</groupId>
-        <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.9.2</version>
+        <groupId>io.ebean</groupId>
+        <artifactId>ebean-maven-plugin</artifactId>
+        <version>11.1.1</version>
         <executions>
-          <!--   Not going to enhance Model bean -->
           <execution>
             <id>test</id>
             <phase>process-test-classes</phase>
             <configuration>
-              <classSource>target/test-classes</classSource>
-              <packages>com.avaje.tests.**</packages>
               <transformArgs>debug=1</transformArgs>
             </configuration>
             <goals>
-              <goal>enhance</goal>
+              <goal>testEnhance</goal>
             </goals>
           </execution>
         </executions>
@@ -276,7 +319,8 @@
           </systemProperties>
         </configuration>
       </plugin>
- 	 <plugin>
+
+      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-jar-plugin</artifactId>
         <version>2.5</version>
@@ -286,16 +330,17 @@
           </archive>
         </configuration>
       </plugin>
+
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>2.9.1</version>
         <configuration>
-          <doctitle>Ebean 7</doctitle>
-          <overview>src/main/java/com/avaje/ebean/overview.html</overview>
+          <doctitle>Ebean 10</doctitle>
+          <overview>src/main/java/io/ebean/overview.html</overview>
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
-          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util:com.avaje.ebean.dbmigration.ddlgeneration:com.avaje.ebean.dbmigration.migration:com.avaje.ebean.dbmigration.migrationreader:com.avaje.ebean.dbmigration.model</excludePackageNames>
+          <excludePackageNames>io.ebeaninternal.*:com.avaje.ebean.util:io.ebean.dbmigration.ddlgeneration:io.ebean.dbmigration.migration:io.ebean.dbmigration.migrationreader:io.ebean.dbmigration.model</excludePackageNames>
           <docletArtifact>
             <groupId>org.avaje</groupId>
             <artifactId>pygments-doclet</artifactId>
@@ -311,7 +356,6 @@
           <linksource>true</linksource>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
         </configuration>
-
         <executions>
           <execution>
             <id>attach-javadocs</id>
@@ -321,8 +365,9 @@
           </execution>
         </executions>
       </plugin>
+
     </plugins>
 
   </build>
- 
+
 </project>

src/main/java/com/avaje/ebean/CallableSql.java

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

src/main/java/com/avaje/ebean/FutureIds.java

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

src/main/java/com/avaje/ebean/LikeType.java

@@ -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
-}

src/main/java/com/avaje/ebean/Model.java

@@ -1,933 +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);
-    }
-
-    /**
-     * Please migrate to use {@link Find} or constructor <code>Finder(Class)</code> that
-     * does not have the idType parameter.
-     * <p/>
-     * Create with the type of the ID property and entity bean and specific server name.
-     *
-     * @deprecated
-     */
-    public Finder(Class<I> idType, Class<T> type) {
-      super(null, type);
-    }
-
-    /**
-     * Please migrate to use the constructor <code>Finder(String, Class)</code> that
-     * does not have the idType parameter.
-     * <p/>
-     * Create with the type of the ID property and entity bean and specific server name.
-     *
-     * @deprecated
-     */
-    public Finder(String serverName, Class<I> idType, 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);
-    }
-
-    /**
-     * Return a PagedList of all entities of the given type (use where() to specify predicates as
-     * needed).
-     * <p>
-     * Equivalent to {@link Query#findPagedList(int, int)}
-     */
-    public PagedList<T> findPagedList(int pageIndex, int pageSize) {
-      return query().findPagedList(pageIndex, pageSize);
-    }
-
-    /**
-     * Executes a find row count query in a background thread.
-     * <p>
-     * Equivalent to {@link Query#findFutureRowCount()}
-     */
-    public FutureRowCount<T> findFutureRowCount() {
-      return query().findFutureRowCount();
-    }
-
-    /**
-     * Returns the total number of entities for this type. *
-     * <p>
-     * Equivalent to {@link Query#findRowCount()}
-     */
-    public int findRowCount() {
-      return query().findRowCount();
-    }
-
-    /**
-     * 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 using the OQL.
-     * <p>
-     * Equivalent to {@link EbeanServer#createQuery(Class, String)}
-     */
-    public Query<T> setQuery(String oql) {
-      return db().createQuery(type, oql);
-    }
-
-    /**
-     * 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);
-    }
-
-  }
-}

src/main/java/com/avaje/ebean/OrderBy.java

@@ -1,376 +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 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 void clear() {
-    list.clear();
-  }
-
-  /**
-   * 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;
-
-    public Property(String property, boolean ascending) {
-      this.property = property;
-      this.ascending = ascending;
-    }
-
-    /**
-     * Return a copy of this Property with the path trimmed.
-     */
-    public Property copyWithTrim(String path) {
-      return new Property(property.substring(path.length() + 1), ascending);
-    }
-
-    public int hashCode() {
-      int hc = property.hashCode();
-      hc = hc * 31 + (ascending ? 0 : 1);
-      return hc;
-    }
-    
-    public boolean equals(Object obj) {
-      if (obj == this) {
-        return true;
-      }
-      if (!(obj instanceof Property)) {
-        return false;
-      }
-      
-      Property e = (Property) obj;
-      return e.ascending == ascending 
-          && e.property.equals(property);
-    }
-
-    public String toString() {
-      return toStringFormat();
-    }
-
-    public String toStringFormat() {
-      if (ascending) {
-        return property;
-      } else {
-        return property + " desc";
-      }
-    }
-
-    /**
-     * 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);
-    }
-
-    /**
-     * 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);
-    }
-    String m = "Expecting a max of 2 words in [" + Arrays.toString(pairs)
-        + "] but got " + wordList.size();
-    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.length() == 0;
-  }
-}

src/main/java/com/avaje/ebean/QueryEachConsumer.java

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

src/main/java/com/avaje/ebean/QueryEachWhileConsumer.java

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

src/main/java/com/avaje/ebean/QueryIterator.java

@@ -1,60 +0,0 @@
-package com.avaje.ebean;
-
-import java.util.Iterator;
-
-/**
- * Used to provide iteration over query results.
- * <p>
- * This can be used when you want to process a very large number of results and
- * means that you don't have to hold all the results in memory at once (unlike
- * findList(), findSet() etc where all the beans are held in the List or Set
- * etc).
- * </p>
- * 
- * <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);
- * 
- * QueryIterator&lt;Customer&gt; it = query.findIterate();
- * try {
- *   while (it.hasNext()) {
- *     Customer customer = it.next();
- *     // do something with customer...
- *   }
- * } finally {
- *   // close the associated resources
- *   it.close();
- * }
- * </pre>
- * 
- * @author rbygrave
- * 
- * @param <T>
- *          the type of entity bean in the iteration
- */
-public interface QueryIterator<T> extends Iterator<T>, java.io.Closeable {
-
-  /**
-   * Returns <tt>true</tt> if the iteration has more elements.
-   */
-  boolean hasNext();
-
-  /**
-   * Returns the next element in the iteration.
-   */
-  T next();
-
-  /**
-   * Remove is not allowed.
-   */
-  void remove();
-
-  /**
-   * Close the underlying resources held by this iterator.
-   */
-  void close();
-}

src/main/java/com/avaje/ebean/SimpleTextParser.java

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

src/main/java/com/avaje/ebean/SqlFutureList.java

@@ -1,47 +0,0 @@
-package com.avaje.ebean;
-
-import java.util.List;
-import java.util.concurrent.Future;
-
-/**
- * The SqlFutureList represents the result of a background SQL query execution.
- * 
- * <p>
- * It extends the java.util.concurrent.Future.
- * </p>
- * 
- * <pre class="code">
- *  // create a query
- * String sql = ... ;
- * SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
- * 
- *  // execute the query in a background thread
- * SqlFutureList sqlFuture = sqlQuery.findFutureList();
- * 
- *  // do something else ... we will sleep
- * Thread.sleep(3000);
- * System.out.println("end of sleep");
- * 
- * if (!futureList.isDone()){
- * 	// we can cancel the query execution
- * 	futureList.cancel(true);
- * }
- * 
- * System.out.println("and... done:"+futureList.isDone());
- * 
- * if (!futureList.isCancelled()){
- * 	// wait for the query to finish and return the list
- * 	List&lt;SqlRow&gt; list = futureList.get();
- * 	System.out.println("list:"+list);
- * }
- * 
- * </pre>
- * 
- * @author rob
- * 
- */
-public interface SqlFutureList extends Future<List<SqlRow>> {
-
-  SqlQuery getQuery();
-
-}

src/main/java/com/avaje/ebean/SqlQuery.java

@@ -1,151 +0,0 @@
-package com.avaje.ebean;
-
-import java.io.Serializable;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * 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 class="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 = &quot;select id, name from customer where name like :name and status_code = :status&quot;;
- * 
- * SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
- * sqlQuery.setParameter(&quot;name&quot;, &quot;Acme%&quot;);
- * sqlQuery.setParameter(&quot;status&quot;, &quot;ACTIVE&quot;);
- * 
- * // execute the query returning a List of MapBean objects
- * List&lt;SqlRow&gt; list = sqlQuery.findList();
- * </pre>
- * 
- */
-public interface SqlQuery extends Serializable {
-
-  /**
-   * Cancel the query if support by the underlying database and driver.
-   * <p>
-   * This must be called from a different thread to the one executing the query.
-   * </p>
-   */
-  void cancel();
-
-  /**
-   * Execute the query returning a list.
-   */
-  List<SqlRow> findList();
-
-  /**
-   * Execute the query returning a set.
-   */
-  Set<SqlRow> findSet();
-
-  /**
-   * Execute the query returning a map.
-   */
-  Map<?, SqlRow> findMap();
-
-  /**
-   * 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();
-
-  /**
-   * Execute find list SQL query in a background thread.
-   * <p>
-   * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a
-   * timeout).
-   * </p>
-   * 
-   * @return a Future object for the list result of the query
-   * @deprecated
-   */
-  SqlFutureList findFutureList();
-
-  /**
-   * 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 a listener to process the query on a row by row basis.
-   * <p>
-   * It this case the rows are not loaded into the persistence context and
-   * instead can be processed by the query listener.
-   * </p>
-   * <p>
-   * Use this when you want to process a large query and do not want to hold the
-   * entire query result in memory.
-   * </p>
-   */
-  SqlQuery setListener(SqlQueryListener queryListener);
-
-  /**
-   * 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 the index after which fetching continues in a background thread.
-   */
-  SqlQuery setBackgroundFetchAfter(int backgroundFetchAfter);
-
-  /**
-   * Set the column to use to determine the keys for a Map.
-   */
-  SqlQuery setMapKey(String mapKey);
-
-  /**
-   * 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);
-
-}

src/main/java/com/avaje/ebean/SqlQueryListener.java

@@ -1,33 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Provides a mechanism for processing a SqlQuery one SqlRow at a time.
- * <p>
- * This is useful when the query will return a large number of results and you
- * want to process the beans one at a time rather than have all of the beans in
- * memory at once.
- * </p>
- * 
- * <pre class="code">
- * SqlQueryListener listener = ...;
- *    
- * SqlQuery query  = Ebean.createSqlQuery(&quot;my.large.query&quot;);
- *    
- * // set the listener that will process each row one at a time
- * query.setListener(listener);
- *    
- * // execute the query. Note that the returned
- * // list will be empty ... so don't bother assigning it...
- * query.findList();
- * </pre>
- */
-public interface SqlQueryListener {
-
-  /**
-   * Process the bean that has just been read.
-   * <p>
-   * Note this bean will not be added to the List Set or Map.
-   * </p>
-   */
-  void process(SqlRow bean);
-}

src/main/java/com/avaje/ebean/Transaction.java

@@ -1,364 +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 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;
-
-  /**
-   * 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);
-
-  /**
-   * 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);
-}

src/main/java/com/avaje/ebean/TxCallable.java

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

src/main/java/com/avaje/ebean/TxIsolation.java

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

src/main/java/com/avaje/ebean/TxRunnable.java

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

src/main/java/com/avaje/ebean/TxScope.java

@@ -1,305 +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 readOnly;
-
-  ArrayList<Class<? extends Throwable>> rollbackFor;
-
-  ArrayList<Class<? extends Throwable>> 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;
-  }
-
-  /**
-   * 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 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;
-  }
-
-  /**
-   * 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;
-  }
-
-}

src/main/java/com/avaje/ebean/TxType.java

@@ -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
-}

src/main/java/com/avaje/ebean/Update.java

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

src/main/java/com/avaje/ebean/annotation/CacheStrategy.java

@@ -1,58 +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;
-
-/**
- * Specify the default cache use specific entity type.
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface CacheStrategy {
-
-  /**
-   * When set to true the bean cache will be used unless explicitly stated not
-   * to in a query via {@link Query#setUseCache(boolean)}.
-   */
-  boolean useBeanCache() default true;
-
-  /**
-   * A single 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;
-
-  /**
-   * Specify a query that can be used to warm the cache.
-   * <p>
-   * All the beans fetched by this query will be loaded into the bean cache and
-   * the query itself will be loaded into the query cache.
-   * </p>
-   * <p>
-   * The warming query will typically be executed at startup time after a short
-   * delay (defaults to a 30 seconds delay).
-   * </p>
-   */
-  String warmingQuery() default "";
-
-}

src/main/java/com/avaje/ebean/annotation/CacheTuning.java

@@ -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 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 CacheTuning {
-
-  /**
-   * 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;
-}

src/main/java/com/avaje/ebean/annotation/ChangeLog.java

@@ -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 {};
-}

src/main/java/com/avaje/ebean/annotation/ChangeLogInsertMode.java

@@ -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
-}

src/main/java/com/avaje/ebean/annotation/ConcurrencyMode.java

@@ -1,17 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * Optimistic concurrency mode used for updates and deletes.
- */
-public enum ConcurrencyMode {
-
-	/**
-	 * No concurrency checking.
-	 */
-	NONE,
-	
-	/**
-	 * Use a version column.
-	 */
-	VERSION
-}

src/main/java/com/avaje/ebean/annotation/CreatedTimestamp.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/DbComment.java

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

src/main/java/com/avaje/ebean/annotation/DbEnumType.java

@@ -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
-}

src/main/java/com/avaje/ebean/annotation/DbEnumValue.java

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

src/main/java/com/avaje/ebean/annotation/DbHstore.java

@@ -1,26 +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 {
-
-}

src/main/java/com/avaje/ebean/annotation/DbJson.java

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

src/main/java/com/avaje/ebean/annotation/DbJsonB.java

@@ -1,39 +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 {
-
-}

src/main/java/com/avaje/ebean/annotation/DbJsonType.java

@@ -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
-}

src/main/java/com/avaje/ebean/annotation/DocCode.java

@@ -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 "";
-}

src/main/java/com/avaje/ebean/annotation/DocEmbedded.java

@@ -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 "";
-
-}

src/main/java/com/avaje/ebean/annotation/DocMapping.java

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

src/main/java/com/avaje/ebean/annotation/DocProperty.java

@@ -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
-  }
-}

src/main/java/com/avaje/ebean/annotation/DocSortable.java

@@ -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 "";
-}

src/main/java/com/avaje/ebean/annotation/DocStore.java

@@ -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 "";
-}

src/main/java/com/avaje/ebean/annotation/DocStoreEmbedded.java

@@ -1,21 +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;
-
-/**
- * Deprecated in favor of @DocEmbedded (i.e. renamed to @DocEmbedded)
- */
-@Target({ ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-@Deprecated
-public @interface DocStoreEmbedded {
-
-  /**
-   * The properties on the embedded bean to include in the index.
-   */
-  String doc() default "";
-
-}

src/main/java/com/avaje/ebean/annotation/DocStoreMode.java

@@ -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
-
-}

src/main/java/com/avaje/ebean/annotation/Draft.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/DraftDirty.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/DraftOnly.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/DraftReset.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/Draftable.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/DraftableElement.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/EmbeddedColumns.java

@@ -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 "";
-
-}

src/main/java/com/avaje/ebean/annotation/Encrypted.java

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

src/main/java/com/avaje/ebean/annotation/EntityConcurrencyMode.java

@@ -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;
-
-/**
- * Specify explicit ConcurrencyMode for entity bean.
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface EntityConcurrencyMode {
-  
-  /**
-   * The ConcurrencyMode value.
-   */
-  ConcurrencyMode value();
-}

src/main/java/com/avaje/ebean/annotation/EnumMapping.java

@@ -1,90 +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 mapping the values of an Enum to and from Database values.
- * <p>
- * Also refer to the {@link EnumValue} approach which probably the preferred now
- * (preferred over using this EnumMapping annotation).
- * </p>
- * <p>
- * Both of the approaches defined in the JPA have significant problems!!!
- * </p>
- * <p>
- * Using the ordinal value is VERY RISKY because that depends on the compile
- * order of the enum values. Aka if you change the order of the enum values you
- * have changed their ordinal values and now your DB values are WRONG - a HUGE
- * disaster!!!.
- * </p>
- * <p>
- * Using the String values of enums is fairly restrictive because in a Database
- * these values are usually truncated into short codes (e.g. "A" short for
- * "ACTIVE") so space used in the database is minimised. Making your enum names
- * match the database values would give them very short less meaningful names -
- * not a great solution.
- * </p>
- * <p>
- * You can use this annotation to control the mapping of your enums to database
- * values.
- * </p>
- * <p>
- * The design of this using nameValuePairs is not optimal for safety or
- * refactoring so if you have a better solution I'm all ears. The other
- * solutions would probably involve modifying each enumeration with a method
- * which may be ok.
- * </p>
- * <p>
- * An example mapping the UserState enum.
- * </p>
- * 
- * <pre class="code">
- * ...
- * &#064;EnumMapping(nameValuePairs=&quot;NEW=N, ACTIVE=A, INACTIVE=I&quot;)
- *  public enum UserState {
- *  NEW,
- *  ACTIVE,
- *  INACTIVE;
- *  }
- * </pre>
- * 
- * @see EnumValue
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface EnumMapping {
-
-  /**
-   * A comma delimited list of name=value pairs.
-   * <p>
-   * e.g. "ACTIVE=A, INACTIVE=I, NEW=N".
-   * </p>
-   * <p>
-   * Where ACTIVE, INACTIVE and NEW are the enumeration values and "A", "I" and
-   * "N" are the database values.
-   * </p>
-   * <p>
-   * This is not really an optimal approach so if you have a better one I'm all
-   * ears - thanks.
-   * </p>
-   */
-  String nameValuePairs();
-
-  /**
-   * Defaults to mapping values to database VARCHAR type. If this is set to true
-   * then the values will be converted to INTEGER and mapped to the database
-   * integer type.
-   * <p>
-   * e.g. "ACTIVE=1, INACTIVE=0, NEW=2".
-   * </p>
-   */
-  boolean integerType() default false;
-
-  /**
-   * The length of DB column if mapping to string values.
-   */
-  int length() default 0;
-}

src/main/java/com/avaje/ebean/annotation/EnumValue.java

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

src/main/java/com/avaje/ebean/annotation/Expose.java

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

src/main/java/com/avaje/ebean/annotation/Formula.java

@@ -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 "";
-
-}

src/main/java/com/avaje/ebean/annotation/History.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/HistoryExclude.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/Index.java

@@ -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 {};
-
-}

src/main/java/com/avaje/ebean/annotation/JsonIgnore.java

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

src/main/java/com/avaje/ebean/annotation/NamedUpdate.java

@@ -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;
-
-/**
- * An Update statement for a particular entity bean type.
- * <p>
- * The update can either be a sql insert,update or delete statement with tables
- * and columns etc or the equivalent statement but with table names and columns
- * expressed as bean types and bean properties.
- * </p>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface NamedUpdate {
-
-  /**
-   * The name of the update.
-   */
-  String name();
-
-  /**
-   * The insert, update or delete statement.
-   */
-  String update();
-
-  /**
-   * Set this to false if you do not want the cache to be notified. If true the
-   * cache will invalidate appropriate objects from the cache (after a
-   * successful transaction commit).
-   */
-  boolean notifyCache() default true;
-
-}

src/main/java/com/avaje/ebean/annotation/NamedUpdates.java

@@ -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;
-
-/**
- * Holds an array of named Update statements for a particular entity bean type.
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface NamedUpdates {
-
-  /**
-   * An array of named updates.
-   */
-  NamedUpdate[] value();
-
-}

src/main/java/com/avaje/ebean/annotation/PrivateOwned.java

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

src/main/java/com/avaje/ebean/annotation/ReadAudit.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/SoftDelete.java

@@ -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 {
-
-}

src/main/java/com/avaje/ebean/annotation/Sql.java

@@ -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 explicit sql for multiple select statements. Need to use this if you
- * have more than one SqlSelect for a given bean.
- * <p>
- * FUTURE: Support explicit sql for SqlInsert, SqlUpdate and SqlDelete.
- * </p>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Sql {
-
-  /**
-   * The sql select statements.
-   */
-  SqlSelect[] select() default { @SqlSelect };
-
-}

src/main/java/com/avaje/ebean/annotation/SqlSelect.java

@@ -1,298 +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;
-
-/**
- * Specify an explicit sql select statement to use for querying an entity bean.
- * <p>
- * The reason for using explicit sql is that you want better control over the
- * exact sql or sql that Ebean does not generate for you (such as group by,
- * union, intersection, window functions, recursive queries).
- * </p>
- * <p>
- * An example of two sql select queries deployed on the ReportTopic entity bean.
- * The first one has no name specified so it becomes the default query. The
- * second query extends the first adding a where clause with a named parameter.
- * </p>
- * 
- * <pre class="code">
- * ...
- * &#064;Entity
- *   &#064;Sql(select = {
- *     &#064;SqlSelect(query = 
- *       &quot;select t.id, t.title, count(p.id) as score &quot;+
- *       &quot;from f_topic t &quot;+
- *       &quot;join f_topic_post p on p.topic_id = t.id &quot;+
- *       &quot;group by t.id, t.title&quot;),
- *     &#064;SqlSelect(
- *       name = &quot;with.title&quot;,
- *       extend = &quot;default&quot;,
- *       debug = true,
- *       where = &quot;title like :likeTitle&quot;)
- *  })
- *  public class ReportTopic
- *    &#064;Id Integer id;
- *    String title;
- *    Double score;
- *    ...
- * </pre>
- * 
- * <p>
- * An example using the first "default" query.
- * </p>
- * 
- * <pre class="code">
- * 
- * List&lt;ReportTopic&gt; list =
- *     Ebean.find(ReportTopic.class)
- *         .having().gt(&quot;score&quot;, 0)
- *         .findList();
- * 
- * </pre>
- * 
- * <p>
- * The resulting sql, note the having clause has been added.
- * </p>
- * 
- * <pre class="code">
- * select t.id, t.title, count(p.id) as score 
- * from f_topic t join f_topic_post p on p.topic_id = t.id 
- * group by t.id, t.title  
- * having count(p.id) &gt; ?
- * </pre>
- * 
- * <p>
- * An example using the second query. Note the named parameter "likeTitle" must
- * be set.
- * </p>
- * 
- * <pre class="code">
- * List&lt;ReportTopic&gt; list =
- *     Ebean.find(ReportTopic.class, &quot;with.title&quot;)
- *         .set(&quot;likeTitle&quot;, &quot;a%&quot;)
- *         .findList();
- * </pre>
- * 
- * <p>
- * Ebean tries to parse the sql in the query to determine 4 things
- * <li>Location for inserting WHERE expressions (if required)</li>
- * <li>Location for inserting HAVING expressions (if required)</li>
- * <li>Mapping of columns to bean properties</li>
- * <li>The order by clause</li>
- * </p>
- * <p>
- * If Ebean is unable to parse out this information (perhaps because the sql
- * contains multiple select from keywords etc) then you need to manually specify
- * it.
- * </p>
- * <p>
- * Insert ${where} or ${andWhere} into the location where Ebean can insert any
- * expressions added to the where clause. Use ${andWhere} if the sql already has
- * the WHERE keyword and Ebean will instead start with a AND keyword.
- * </p>
- * <p>
- * Insert ${having} or ${andHaving} into the location where Ebean can insert any
- * expressions added to the having clause. Use ${andHaving} if the sql already
- * has a HAVING keyword and Ebean will instead start with a AND keyword.
- * </p>
- * <p>
- * Use the columnMapping property if Ebean is unable to determine the columns
- * and map them to bean properties.
- * </p>
- * <p>
- * Example with ${andWhere} & ${having}.
- * </p>
- * 
- * <pre class="code">
- *    &#064;SqlSelect(
- *          name = &quot;explicit.where&quot;,
- *          query = 
- *              &quot;select t.id, t.title, count(p.id) as score &quot;+
- *              &quot;from f_topic t, f_topic_post p &quot;+
- *              &quot;where p.topic_id = t.id ${andWhere} &quot;+
- *              &quot;group by t.id, t.title ${having}&quot;),
- * </pre>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-@Deprecated
-public @interface SqlSelect {
-
-  /**
-   * The name of the query. If left blank this is assumed to be the default
-   * query for this bean type.
-   * <p>
-   * This will default to "default" and in that case becomes the default query
-   * used for the bean.
-   * </p>
-   */
-  String name() default "default";
-
-  /**
-   * The tableAlias used when adding where expressions to the query.
-   */
-  String tableAlias() default "";
-
-  /**
-   * The sql select statement.
-   * <p>
-   * If this query <em>extends</em> another then this string is appended to the
-   * parent query string. Often when using <em>extend</em> you will leave the
-   * query part blank and just specify a where and/or having clauses.
-   * </p>
-   * <p>
-   * This sql <em>CAN NOT</em> contain named parameters. You have to put these
-   * in the separate where and/or having sections.
-   * </p>
-   * <p>
-   * Ebean automatically tries to determine the location in the sql string for
-   * putting in additional where or having clauses. If Ebean is unable to
-   * successfully determine this then you have to explicitly specify these
-   * locations by including
-   * <em>${where} or ${andWhere} and  ${having} or ${andHaving}</em> in the sql.
-   * </p>
-   * <p>
-   * <b>${where}</b> location of where clause (and will add WHERE ... ) <br/>
-   * Use this when there is no where clause in the sql. If expressions are added
-   * to the where clause Ebean will put them in at this location starting with
-   * the WHERE keyword.
-   * <p>
-   * <p>
-   * <b>${andWhere}</b> <br/>
-   * Use this instead of ${where} if there IS an existing where clause in the
-   * sql. Ebean will add the expressions starting with the AND keyword.
-   * <p>
-   * <b>${having}</b> location of having clause (and will add HAVING... ) <br/>
-   * </p>
-   * <p>
-   * <b>${andHaving}</b> <br/>
-   * Use this instead of ${having} when there IS an existing HAVING clause.
-   * Ebean will add the expressions starting with the AND keyword.
-   * </p>
-   * <p>
-   * You can include one of ${where} OR ${andWhere} but not both.
-   * </p>
-   * <p>
-   * You can include one of ${having} OR ${andHaving} but not both.
-   * </p>
-   */
-  String query() default "";
-
-  /**
-   * Specify the name of a sql-select query that this one 'extends'.
-   * <p>
-   * When a query is extended the sql query contents are appended together. The
-   * where and having clauses are NOT appended but overridden.
-   * </p>
-   */
-  String extend() default "";
-
-  /**
-   * Specify a where clause typically containing named parameters.
-   * <p>
-   * If a where clause is specified with named parameters then they will need to
-   * be set on the query via {@link Query#setParameter(String, Object)}.
-   * </p>
-   * <p>
-   * In the example below the query specifies a where clause that includes a
-   * named parameter "likeTitle".
-   * </p>
-   * 
-   * <pre class="code">
-   * ...
-   * &#064;Entity
-   * &#064;Sql(select = {
-   *  ...
-   *  &#064;SqlSelect(
-   *  name = &quot;with.title&quot;,
-   *  extend = &quot;default&quot;,
-   *  debug = true,
-   *  where = &quot;title like :likeTitle&quot;)
-   *  })
-   *  public class ReportTopic
-   *  ...
-   * </pre>
-   * 
-   * <p>
-   * Example use of the above named query.
-   * </p>
-   * 
-   * <pre class="code">
-   * 
-   * Query&lt;ReportTopic&gt; query0 = Ebean.createQuery(ReportTopic.class, &quot;with.title&quot;);
-   * 
-   * query0.set(&quot;likeTitle&quot;, &quot;Bana%&quot;);
-   * 
-   * List&lt;ReportTopic&gt; list0 = query0.findList();
-   * </pre>
-   * 
-   */
-  String where() default "";
-
-  /**
-   * Specify a having clause typically containing named parameters.
-   * <p>
-   * If a having clause is specified with named parameters then they will need
-   * to be set on the query via {@link Query#setParameter(String, Object)}.
-   * </p>
-   */
-  String having() default "";
-
-  /**
-   * (Optional) Explicitly specify column to property mapping.
-   * <p>
-   * This is required when Ebean is unable to parse the sql. This could occur if
-   * the sql contains multiple select keywords etc.
-   * </p>
-   * <p>
-   * Specify the columns and property names they map to in the format.
-   * </p>
-   * 
-   * <pre class="code">
-   *  column1 propertyName1, column2 propertyName2, ...
-   * </pre>
-   * 
-   * <p>
-   * Optionally put a AS keyword between the column and property.
-   * </p>
-   * 
-   * <pre class="code">
-   *   // the AS keyword is optional
-   *  column1 AS propertyName1, column2 propertyName2, ...
-   * </pre>
-   * 
-   * <p>
-   * <b>column</b> should contain the table alias if there is one
-   * </p>
-   * <p>
-   * <b>propertyName</b> should match the property name.
-   * </p>
-   * 
-   * <p>
-   * Example mapping 5 columns to properties.
-   * </p>
-   * 
-   * <pre class="code">
-   * columnMapping=&quot;t.id, t.bug_body description, t.bug_title as title, count(p.id) as scoreValue&quot;,
-   * </pre>
-   * 
-   * <p>
-   * Without this set Ebean will parse the sql looking for the select clause and
-   * try to map the columns to property names. It is expected that Ebean will
-   * not be able to successfully parse some sql and for those cases you should
-   * specify the column to property mapping explicitly.
-   * </p>
-   * 
-   */
-  String columnMapping() default "";
-
-  /**
-   * Set this to true to have debug output when Ebean parses the sql-select.
-   */
-  boolean debug() default false;
-}

src/main/java/com/avaje/ebean/annotation/Transactional.java

@@ -1,128 +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.TxIsolation;
-import com.avaje.ebean.TxType;
-import com.avaje.ebean.config.PersistBatch;
-
-/**
- * Specify transaction scoping for a method.
- * <p>
- * <b><i> This is only supported if "Enhancement" is used via javaagent, ANT
- * task or IDE enhancement plugin etc. </i></b>
- * </p>
- * <p>
- * Note: Currently there are 3 known annotations that perform this role.
- * <ul>
- * <li>EJB's javax.ejb.TransactionAttribute</li>
- * <li>Spring's org.springframework.transaction.annotation.Transactional</li>
- * <li>and this one, Ebean's own com.avaje.ebean.annotation.Transactional</li>
- * </ul>
- * Spring created their one because the EJB annotation does not support features
- * such as isolation level and specifying rollbackOn, noRollbackOn exceptions.
- * This one exists for Ebean because I agree that the standard one is
- * insufficient and don't want to include a dependency on Spring.
- * </p>
- * <p>
- * The default behaviour of EJB (and hence Spring) is to NOT ROLLBACK on checked
- * exceptions. I find this very counter-intuitive. Ebean will provide a property
- * to set the default behaviour to rollback on any exception and optionally
- * change the setting to be consistent with EJB/Spring if people wish to do so.
- * </p>
- * 
- * <pre>{@code
- *
- *  // a normal class
- *  public class MySimpleUserService {
- * 
- *    // this method is transactional automatically handling
- *    // transaction begin, commit and rollback etc
- *    @Transactional
- *    public void runInTrans() throws IOException {
- * 
- *      // tasks performed within the transaction
- *      ...
- *      // find some objects
- *      Customer cust = ebeanServer.find(Customer.class, 42);
- *    
- *      Order order = ...;
- *      ...
- *      // save some objects
- *      ebeanServer.save(customer);
- *      ebeanServer.save(order);
- *    }
- *
- * }</pre>
- */
-@Target({ ElementType.METHOD, ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Transactional {
-
-  /**
-   * The type of transaction scoping. Defaults to REQUIRED.
-   */
-  TxType type() default TxType.REQUIRED;
-
-  /**
-   * Persist batch mode for the transaction.
-   */
-  PersistBatch batch() default PersistBatch.INHERIT;
-
-  /**
-   * Persist batch mode for the request if not set on the transaction.
-   * <p>
-   * If batch is set to NONE then batchOnCascade can be set to INSERT or ALL
-   * and then each save(), delete(), insert(), update() request that cascades
-   * to child beans can use JDBC batch.
-   * </p>
-   */
-  PersistBatch batchOnCascade() default PersistBatch.INHERIT;
-
-  /**
-   * The batch size to use when using JDBC batch mode.
-   * <p>
-   * If unset this defaults to the value set in ServerConfig.
-   * </p>
-   */
-  int batchSize() default 0;
-
-  /**
-   * The transaction isolation level this transaction should have.
-   * <p>
-   * This will only be used if this scope creates the transaction. If the
-   * transaction has already started then this will currently be ignored (you
-   * could argue that it should throw an exception).
-   * </p>
-   */
-  TxIsolation isolation() default TxIsolation.DEFAULT;
-
-  /**
-   * Set this to true if the transaction should be only contain queries.
-   */
-  boolean readOnly() default false;
-
-  /**
-   * The name of the server that you want the transaction to be created from.
-   * <p>
-   * If left blank the 'default' server is used.
-   * </p>
-   */
-  String serverName() default "";
-
-  // int timeout() default 0;
-
-  /**
-   * The Throwable's that will explicitly cause a rollback to occur.
-   */
-  Class<? extends Throwable>[] rollbackFor() default {};
-
-  /**
-   * The Throwable's that will explicitly NOT cause a rollback to occur.
-   */
-  Class<? extends Throwable>[] noRollbackFor() default {};
-
-}

src/main/java/com/avaje/ebean/annotation/UpdateMode.java

@@ -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 the update mode for the specific entity type.
- * <p>
- * Control whether all 'loaded' properties are included in an Update or whether
- * just properties that have changed will be included in the update.
- * </p>
- * <p>
- * Note that the default can be set via ebean.properties.
- * </p>
- * 
- * <pre>
- * ## Set to update all loaded properties
- * ebean.updateChangesOnly=false
- * </pre>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface UpdateMode {
-
-  /**
-   * Set to false if you want to include all the 'loaded' properties in the
-   * update. Otherwise, just the properties that have changed will be included
-   * in the update.
-   */
-  boolean updateChangesOnly() default true;
-
-}

src/main/java/com/avaje/ebean/annotation/UpdatedTimestamp.java

@@ -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;
-
-/**
- * For a timestamp property that is set to the datetime when the entity was last
- * updated.
- * <p>
- * This is effectively an alias for @WhenModified which was added as it hints
- * towards a better naming convention (WhenCreated, WhenModified).
- * </p>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface UpdatedTimestamp {
-
-}

src/main/java/com/avaje/ebean/annotation/WhenCreated.java

@@ -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 @CreatedTimestamp and added to hint
- * 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
- *
- *   @WhenCreated
- *   Timestamp whenCreated;
- *
- * }</pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface WhenCreated {
-
-}

src/main/java/com/avaje/ebean/annotation/WhenModified.java

@@ -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;
-
-/**
- * For a timestamp property that is set to the datetime when the entity was last modified.
- * <p>
- * This is effectively an alias for @UpdatedTimestamp and added to hint
- * towards a better naming convention (WhenCreated, WhenModified).
- * </p>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface WhenModified {
-
-}

src/main/java/com/avaje/ebean/annotation/Where.java

@@ -1,54 +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;
-
-/**
- * Add an Literal to add to the where clause when a many property (List, Set or
- * Map) is loaded or refreshed.
- * 
- * <pre>{@code
- *
- * // on a OneToMany property...
- * 
- * @OneToMany
- * @Where(clause = "deleted='y'")
- * List<Topic> topics;
- *
- * }</pre>
- * 
- * <p>
- * Note that you can include "${ta}" as a place holder for the table alias if
- * you need to include the table alias in the clause.
- * </p>
- * 
- * <pre>{@code
- * // ... including the ${ta} table alias placeholder...
- * 
- * @OneToMany
- * @Where(clause = "${ta}.deleted='y'")
- * List<Topic> topics;
- *
- * }</pre>
- * 
- * <p>
- * This will be added to the where clause when lazy loading the OneToMany
- * property or when there is a join to that OneToMany property.
- * </p>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Where {
-
-  /**
-   * The clause added to the lazy load query.
-   * <p>
-   * Note that you can include "${ta}" as a place holder for the table alias if
-   * you need to include the table alias in the clause.
-   * </p>
-   */
-  String clause();
-
-}

src/main/java/com/avaje/ebean/annotation/WhoCreated.java

@@ -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;
-
-/**
- * Mapped onto a entity bean property that represents the user id of
- * who created the entity>
- * <p>
- * To use this annotation you need to implement CurrentUserProvider.
- * The type of the bean property should match the type returned by
- * CurrentUserProvider.
- *</p>
-
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @WhoCreated
- *   String whoCreated;
- *
- * }</pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface WhoCreated {
-
-}

src/main/java/com/avaje/ebean/annotation/WhoModified.java

@@ -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;
-
-/**
- * Mapped onto a entity bean property that represents the user id of
- * who last modified the entity>
- * <p>
- * To use this annotation you need to implement CurrentUserProvider.
- * The type of the bean property should match the type returned by
- * CurrentUserProvider.
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @WhoModified
- *   String whoModified;
- *
- * }</pre>
- */
-@Target({ElementType.FIELD, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface WhoModified {
-
-}

src/main/java/com/avaje/ebean/annotation/package.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
-	<TITLE>Extra deployment annotations</TITLE>
-</HEAD>
-<Body BGCOLOR="#ffffff">
-Extra deployment annotations
-
-<p>
-Extra deployment annotations for entity beans.
-</p>
-
-</Body>
-</HTML>

src/main/java/com/avaje/ebean/bean/BeanCollectionTouched.java

@@ -1,20 +0,0 @@
-package com.avaje.ebean.bean;
-
-/**
- * Used to specify a listener to be notified when a BeanCollection is first
- * used.
- * <p>
- * To use this you can set a BeanCollectionTouched onto a BeanCollection before
- * it has been used. When the BeanCollection is first used by the client code
- * then the BeanCollectionTouched is notified. It can only be notified once.
- * </p>
- * 
- * @author rbygrave
- */
-public interface BeanCollectionTouched {
-
-  /**
-   * Notify the listener that the bean collection has been used.
-   */
-  void notifyTouched(BeanCollection<?> c);
-}

src/main/java/com/avaje/ebean/bean/package.html

@@ -1,12 +0,0 @@
-<HTML>
-<HEAD>
-	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
-	<TITLE>Enhanced beans API and Support objects</TITLE>
-</HEAD>
-<Body BGCOLOR="#ffffff">
-Enhanced beans API and Support objects
-
-
-
-</Body>
-</HTML>

src/main/java/com/avaje/ebean/cache/ServerCache.java

@@ -1,83 +0,0 @@
-package com.avaje.ebean.cache;
-
-import com.avaje.ebean.EbeanServer;
-
-/**
- * Represents part of the "L2" server side cache.
- * <p>
- * This is used to cache beans or query results (bean collections).
- * </p>
- * <p>
- * There are 2 ServerCache's for each bean type. One is used as the 'bean cache'
- * which holds beans of a given type. The other is the 'query cache' holding
- * query results for a given type.
- * </p>
- * 
- * @author rbygrave
- */
-public interface ServerCache {
-
-  /**
-   * Just after a cache is created this init method is called. This is so that a
-   * cache implementation can make use of the BackgroundExecutor service to
-   * trim/cleanup itself or use the EbeanServer to populate itself.
-   * <p>
-   * This method is called after the cache is constructed but before the cache
-   * is made available for use.
-   * </p>
-   */
-  void init(EbeanServer ebeanServer);
-
-  /**
-   * Return the configuration options for this cache.
-   */
-  ServerCacheOptions getOptions();
-
-  /**
-   * Update the configuration options for this cache.
-   */
-  void setOptions(ServerCacheOptions options);
-
-  /**
-   * Return the value given the key.
-   */
-  Object get(Object id);
-
-  /**
-   * Put the value in the cache with a given id.
-   */
-  Object put(Object id, Object value);
-
-  /**
-   * Remove a entry from the cache given its id.
-   */
-  Object remove(Object id);
-
-  /**
-   * Clear all entries from the cache.
-   * <p>
-   * NOTE: Be careful using this method in that most of the time application
-   * code should clear BOTH the bean and query caches at the same time. This can
-   * be done via {@link ServerCacheManager#clear(Class)}.
-   * </p>
-   */
-  void clear();
-
-  /**
-   * Return the number of entries in the cache.
-   */
-  int size();
-
-  /**
-   * Return the hit ratio the cache is currently getting.
-   */
-  int getHitRatio();
-
-  /**
-   * Return statistics for the cache.
-   * 
-   * @param reset
-   *          if true the statistics are reset.
-   */
-  ServerCacheStatistics getStatistics(boolean reset);
-}

src/main/java/com/avaje/ebean/cache/ServerCacheFactory.java

@@ -1,26 +0,0 @@
-package com.avaje.ebean.cache;
-
-import com.avaje.ebean.EbeanServer;
-
-/**
- * Defines method for constructing caches for beans and queries.
- */
-public interface ServerCacheFactory {
-
-  /**
-   * Just after the ServerCacheFactory is constructed this method is called
-   * passing the EbeanServer.
-   * <p>
-   * This is so that a cache implementation can utilise the EbeanServer to
-   * populate itself or use the BackgroundExecutor service to schedule periodic
-   * cache trimming/cleanup.
-   * </p>
-   */
-  void init(EbeanServer ebeanServer);
-
-  /**
-   * Create the cache for the given type with options.
-   */
-  ServerCache createCache(String cacheKey, ServerCacheOptions cacheOptions);
-
-}

src/main/java/com/avaje/ebean/cache/ServerCacheManager.java

@@ -1,55 +0,0 @@
-package com.avaje.ebean.cache;
-
-import com.avaje.ebean.EbeanServer;
-
-/**
- * The cache service for server side caching of beans and query results.
- */
-public interface ServerCacheManager {
-
-  /**
-   * This method is called just after the construction of the
-   * ServerCacheManager.
-   * <p>
-   * The EbeanServer is provided so that cache implementations can make use of
-   * EbeanServer and BackgroundExecutor for automatically populating and
-   * background trimming of the cache.
-   * </p>
-   */
-  void init(EbeanServer server);
-
-  void setCaching(Class<?> beanType, boolean useCache);
-
-  /**
-   * Return true if there is an active bean cache for this type of bean.
-   */
-  boolean isBeanCaching(Class<?> beanType);
-
-  /**
-   * Return the cache for mapping natural keys to id values.
-   */
-  ServerCache getNaturalKeyCache(Class<?> beanType);
-
-  /**
-   * Return the cache for beans of a particular type.
-   */
-  ServerCache getBeanCache(Class<?> beanType);
-
-  ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName);
-
-  /**
-   * Return the cache for query results of a particular type of bean.
-   */
-  ServerCache getQueryCache(Class<?> beanType);
-
-  /**
-   * This clears both the bean and query cache for a given type.
-   */
-  void clear(Class<?> beanType);
-
-  /**
-   * Clear all the caches.
-   */
-  void clearAll();
-
-}

src/main/java/com/avaje/ebean/cache/package.html

@@ -1,10 +0,0 @@
-<HTML>
-<HEAD>
-	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
-	<TITLE>Server Cache Service</TITLE>
-</HEAD>
-<Body BGCOLOR="#ffffff">
-Server Cache Service
-
-</Body>
-</HTML>

src/main/java/com/avaje/ebean/common/AbstractBeanCollection.java

@@ -1,222 +0,0 @@
-package com.avaje.ebean.common;
-
-import java.util.Set;
-
-import javax.persistence.PersistenceException;
-
-import com.avaje.ebean.Ebean;
-import com.avaje.ebean.ExpressionList;
-import com.avaje.ebean.bean.BeanCollection;
-import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.BeanCollectionTouched;
-import com.avaje.ebean.bean.EntityBean;
-
-/**
- * Base class for List Set and Map implementations of BeanCollection.
- * 
- * @author rbygrave
- */
-public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
-
-  private static final long serialVersionUID = 3365725236140187588L;
-
-  protected boolean readOnly;
-
-  /**
-   * The EbeanServer this is associated with. (used for lazy fetch).
-   */
-  protected transient BeanCollectionLoader loader;
-
-  protected transient ExpressionList<?> filterMany;
-
-  /**
-   * Flag set when registered with the batch loading context.
-   */
-  protected boolean registeredWithLoadContext;
-
-  protected String ebeanServerName;
-
-  protected transient BeanCollectionTouched beanCollectionTouched;
-
-  /**
-   * The owning bean (used for lazy fetch).
-   */
-  protected EntityBean ownerBean;
-
-  /**
-   * The name of this property in the owning bean (used for lazy fetch).
-   */
-  protected String propertyName;
-
-  protected ModifyHolder<E> modifyHolder;
-
-  protected ModifyListenMode modifyListenMode;
-  protected boolean modifyAddListening;
-  protected boolean modifyRemoveListening;
-  protected boolean modifyListening;
-
-  /**
-   * Flag used to tell if empty collections have been cleared etc or just
-   * uninitialised.
-   */
-  protected boolean touched;
-
-  /**
-   * Constructor not non-lazy loading collection.
-   */
-  public AbstractBeanCollection() {
-  }
-
-  /**
-   * Used to create deferred fetch proxy.
-   */
-  public AbstractBeanCollection(BeanCollectionLoader loader, EntityBean ownerBean, String propertyName) {
-    this.loader = loader;
-    this.ebeanServerName = loader.getName();
-    this.ownerBean = ownerBean;
-    this.propertyName = propertyName;
-    this.readOnly = ownerBean._ebean_getIntercept().isReadOnly();
-  }
-
-  public EntityBean getOwnerBean() {
-    return ownerBean;
-  }
-
-  public String getPropertyName() {
-    return propertyName;
-  }
-
-  public ExpressionList<?> getFilterMany() {
-    return filterMany;
-  }
-
-  public void setFilterMany(ExpressionList<?> filterMany) {
-    this.filterMany = filterMany;
-  }
-
-  protected void lazyLoadCollection(boolean onlyIds) {
-    if (loader == null) {
-      loader = (BeanCollectionLoader) Ebean.getServer(ebeanServerName);
-    }
-    if (loader == null) {
-      String msg = "Lazy loading but LazyLoadEbeanServer is null?"
-          + " The LazyLoadEbeanServer needs to be set after deserialization"
-          + " to support lazy loading.";
-      throw new PersistenceException(msg);
-    }
-
-    loader.loadMany(this, onlyIds);
-    checkEmptyLazyLoad();
-  }
-
-  /**
-   * Set touched. If setFlag is false then typically an isEmpty() call and still
-   * considering that to be untouched.
-   */
-  protected void touched(boolean setFlag) {
-    if (setFlag) {
-      touched = true;
-    }
-    if (beanCollectionTouched != null) {
-      // only call this once
-      beanCollectionTouched.notifyTouched(this);
-      beanCollectionTouched = null;
-    }
-  }
-
-  public void setBeanCollectionTouched(BeanCollectionTouched notify) {
-    this.beanCollectionTouched = notify;
-  }
-
-  public boolean isRegisteredWithLoadContext() {
-    return registeredWithLoadContext;
-  }
-
-  public void setLoader(BeanCollectionLoader loader) {
-    this.registeredWithLoadContext = true;
-    this.loader = loader;
-    this.ebeanServerName = loader.getName();
-  }
-
-  public boolean isReadOnly() {
-    return readOnly;
-  }
-
-  public void setReadOnly(boolean readOnly) {
-    this.readOnly = readOnly;
-  }
-
-  protected void checkReadOnly() {
-    if (readOnly) {
-      String msg = "This collection is in ReadOnly mode";
-      throw new IllegalStateException(msg);
-    }
-  }
-
-  // ---------------------------------------------------------
-  // Support for modify additions deletions etc - ManyToMany
-  // ---------------------------------------------------------
-
-  /**
-   * set modifyListening to be on or off.
-   */
-  public void setModifyListening(ModifyListenMode mode) {
-
-    this.modifyListenMode = mode;
-    this.modifyAddListening = ModifyListenMode.ALL.equals(mode);
-    this.modifyRemoveListening = modifyAddListening || ModifyListenMode.REMOVALS.equals(mode);
-    this.modifyListening = modifyRemoveListening || modifyAddListening;
-    if (modifyListening) {
-      // lose any existing modifications
-      modifyHolder = null;
-    }
-  }
-
-  /**
-   * Return the modify listening mode this collection is using.
-   */
-  public ModifyListenMode getModifyListenMode() {
-    return modifyListenMode;
-  }
-
-  protected ModifyHolder<E> getModifyHolder() {
-    if (modifyHolder == null) {
-      modifyHolder = new ModifyHolder<E>();
-    }
-    return modifyHolder;
-  }
-
-  public void modifyAddition(E bean) {
-    if (modifyAddListening) {
-      getModifyHolder().modifyAddition(bean);
-    }
-  }
-
-  public void modifyRemoval(Object bean) {
-    if (modifyRemoveListening) {
-      getModifyHolder().modifyRemoval(bean);
-    }
-  }
-
-  public void modifyReset() {
-    if (modifyHolder != null) {
-      modifyHolder.reset();
-    }
-  }
-
-  public Set<E> getModifyAdditions() {
-    if (modifyHolder == null) {
-      return null;
-    } else {
-      return modifyHolder.getModifyAdditions();
-    }
-  }
-
-  public Set<E> getModifyRemovals() {
-    if (modifyHolder == null) {
-      return null;
-    } else {
-      return modifyHolder.getModifyRemovals();
-    }
-  }
-}

src/main/java/com/avaje/ebean/common/ModifyHolder.java

@@ -1,74 +0,0 @@
-package com.avaje.ebean.common;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.Set;
-
-/**
- * Holds sets of additions and deletions from a 'owner' List Set or Map.
- * <p>
- * These sets of additions and deletions are used to support persisting
- * ManyToMany relationships. The additions becoming inserts into the
- * intersection table and the removals becoming deletes from the intersection
- * table.
- * </p>
- */
-class ModifyHolder<E> implements Serializable {
-
-  private static final long serialVersionUID = 2572572897923801083L;
-
-  /**
-   * Deletions list for manyToMany persistence.
-   */
-  private Set<E> modifyDeletions = new LinkedHashSet<E>();
-
-  /**
-   * Additions list for manyToMany persistence.
-   */
-  private Set<E> modifyAdditions = new LinkedHashSet<E>();
-
-  void reset() {
-    modifyDeletions = new LinkedHashSet<E>();
-    modifyAdditions = new LinkedHashSet<E>();
-  }
-
-  /**
-   * Used by BeanList.addAll() methods.
-   */
-  void modifyAdditionAll(Collection<? extends E> c) {
-    if (c != null) {
-      for (E e : c) {
-        modifyAddition(e);
-      }
-    }
-  }
-
-  void modifyAddition(E bean) {
-    if (bean != null) {
-      // If it is to delete then just remove the deletion
-      if (!modifyDeletions.remove(bean)) {
-        // Insert
-        modifyAdditions.add(bean);
-      }
-    }
-  }
-
-  @SuppressWarnings("unchecked")
-  void modifyRemoval(Object bean) {
-    if (bean != null) {
-      // If it is to be added then just remove the addition
-      if (!modifyAdditions.remove(bean)) {
-        modifyDeletions.add((E) bean);
-      }
-    }
-  }
-
-  Set<E> getModifyAdditions() {
-    return modifyAdditions;
-  }
-
-  Set<E> getModifyRemovals() {
-    return modifyDeletions;
-  }
-}

src/main/java/com/avaje/ebean/common/package.html

@@ -1,11 +0,0 @@
-<HTML>
-<HEAD>
-	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
-	<TITLE>Common non-public interfaces and implementation</TITLE>
-</HEAD>
-<Body BGCOLOR="#ffffff">
-Common non-public interfaces and implementation.
-
-
-</Body>
-</HTML>

src/main/java/com/avaje/ebean/config/CompoundType.java

@@ -1,46 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * API from creating and getting property values from an Immutable Compound
- * Value Object.
- * 
- * <p>
- * A Compound Value object should contain multiple properties that are stored
- * separately. If you only have a single scalar value you should instead look to
- * use {@link ScalarTypeConverter}.
- * </p>
- * <p>
- * For each property in the compound type you need to implement the
- * {@link CompoundTypeProperty} interface. These must be returned from
- * {@link #getProperties()} in the same order that the properties appear in the
- * constructor.
- * </p>
- * <p>
- * If your compound type is mutable then you should look to use the JPA Embedded
- * annotation instead of implementing this interface.
- * </p>
- * <p>
- * When using classpath search Ebean will detect and automatically register any
- * implementations of this interface (along with detecting the entity classes
- * etc).
- * </p>
- * 
- * @author rbygrave
- * 
- * @param <V>
- *          The type of the Value Object
- * 
- * @see ScalarTypeConverter
- */
-public interface CompoundType<V> {
-
-  /**
-   * Create an instance of the compound type given its property values.
-   */
-  V create(Object[] propertyValues);
-
-  /**
-   * Return the properties in the order they appear in the constructor.
-   */
-  CompoundTypeProperty<V, ?>[] getProperties();
-}

src/main/java/com/avaje/ebean/config/CompoundTypeProperty.java

@@ -1,51 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Represents a Property of a Compound Value Object.
- * <p>
- * For each property in a {@link CompoundType} you need an implementation of
- * this CompoundTypeProperty interface.
- * 
- * </p>
- * 
- * @author rbygrave
- * 
- * @param <V>
- *          The type of the Compound value object
- * @param <P>
- *          The type of the property
- * 
- * @see CompoundType
- * @see ScalarTypeConverter
- */
-public interface CompoundTypeProperty<V, P> {
-
-  /**
-   * The name of this property.
-   */
-  String getName();
-
-  /**
-   * Return the property value from the containing compound value object.
-   * 
-   * @param valueObject
-   *          the compound value object
-   * @return the property value.
-   */
-  P getValue(V valueObject);
-
-  /**
-   * This should <b>ONLY</b> be used when the persistence type is different from
-   * the logical type returned. It most cases just return 0 and Ebean will
-   * persist the logical type.
-   * <p>
-   * Typically this should be used when the logical type is long but the
-   * persistence type is java.sql.Timestamp. In this case return
-   * java.sql.Types.TIMESTAMP (rather than 0).
-   * </p>
-   * 
-   * @return Return the java.sql.Type that you want to use to persist this
-   *         property or 0 and Ebean will use the logical type.
-   */
-  int getDbType();
-}

src/main/java/com/avaje/ebean/config/ContainerConfig.java

@@ -1,464 +0,0 @@
-package com.avaje.ebean.config;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Properties;
-
-/**
- * Configuration for the container that holds the EbeanServer instances.
- * <p>
- * Provides configuration for cluster communication (if clustering is used). The cluster communication is
- * used to invalidate appropriate parts of the L2 cache across the cluster.
- */
-public class ContainerConfig {
-
-  /**
-   * Communication mode used for clustering.
-   */
-  public enum ClusterMode {
-
-    /**
-     * No clustering.
-     */
-    NONE,
-
-    /**
-     * Use Multicast networking for cluster wide communication.
-     */
-    MULTICAST,
-
-    /**
-     * Use TCP Sockets for cluster wide communication.
-     */
-    SOCKET
-  }
-
-  /**
-   * The cluster mode to use.
-   */
-  ClusterMode mode = ClusterMode.NONE;
-
-  /**
-   * Configuration if using TCP sockets for clustering communication.
-   */
-  SocketConfig socketConfig = new SocketConfig();
-
-  /**
-   * Configuration if using Multicast for clustering communication.
-   */
-  MulticastConfig multicastConfig = new MulticastConfig();
-
-
-  // -------------------------------------------------------------------------------------------
-  // MulticastConfig
-
-  /**
-   * The configuration for clustering using Multicast networking.
-   */
-  public static class MulticastConfig {
-
-    int managerSleepMillis = 80;
-    int lastSendTimeFreqSecs = 300;//5mins
-    int lastStatusTimeFreqSecs = 600;//10mins
-    int maxResendOutgoingAttempts = 200;
-    int maxResendIncomingRequests = 50;
-
-    int listenPort;
-    String listenAddress;
-    int sendPort;
-    String sendAddress;
-
-    // Note 1500 is Ethernet MTU and this must be less than UDP max packet size of 65507
-    int maxSendPacketSize = 1500;
-
-    // Whether to send packets even when there are no other members online
-    boolean sendWithNoMembers = true;
-
-    // When multiple instances are on same box you need to broadcast back locally
-    boolean disableLoopback;
-    int listenTimeToLive = -1;
-    int listenTimeout = 1000;
-    int listenBufferSize = 65500;
-    // For multihomed environment the address the listener should bind to
-    String listenBindAddress;
-
-    /**
-     * Return the manager sleep millis.
-     */
-    public int getManagerSleepMillis() {
-      return managerSleepMillis;
-    }
-
-    /**
-     * Set the manager sleep millis.
-     */
-    public void setManagerSleepMillis(int managerSleepMillis) {
-      this.managerSleepMillis = managerSleepMillis;
-    }
-
-    /**
-     * Return the last send time frequency.
-     */
-    public int getLastSendTimeFreqSecs() {
-      return lastSendTimeFreqSecs;
-    }
-
-    /**
-     * Set the last send time frequency.
-     */
-    public void setLastSendTimeFreqSecs(int lastSendTimeFreqSecs) {
-      this.lastSendTimeFreqSecs = lastSendTimeFreqSecs;
-    }
-
-    /**
-     * Return the last status time frequency.
-     */
-    public int getLastStatusTimeFreqSecs() {
-      return lastStatusTimeFreqSecs;
-    }
-
-    /**
-     * Set the last status time frequency.
-     */
-    public void setLastStatusTimeFreqSecs(int lastStatusTimeFreqSecs) {
-      this.lastStatusTimeFreqSecs = lastStatusTimeFreqSecs;
-    }
-
-    /**
-     * Return the maximum number of times we will try to re-send a given packet before giving up sending
-     */
-    public int getMaxResendOutgoingAttempts() {
-      return maxResendOutgoingAttempts;
-    }
-
-    /**
-     * Set the maximum retry attempts for outgoing messages.
-     */
-    public void setMaxResendOutgoingAttempts(int maxResendOutgoingAttempts) {
-      this.maxResendOutgoingAttempts = maxResendOutgoingAttempts;
-    }
-
-    /**
-     * Return the maximum number of times we will ask for a packet to be resent to us before giving up asking.
-     */
-    public int getMaxResendIncomingRequests() {
-      return maxResendIncomingRequests;
-    }
-
-    /**
-     * Set the maximum retry attempts for incoming messages.
-     */
-    public void setMaxResendIncomingRequests(int maxResendIncomingRequests) {
-      this.maxResendIncomingRequests = maxResendIncomingRequests;
-    }
-
-    /**
-     * Return the listen port.
-     */
-    public int getListenPort() {
-      return listenPort;
-    }
-
-    /**
-     * Set the listen port.
-     */
-    public void setListenPort(int port) {
-      this.listenPort = port;
-    }
-
-    /**
-     * Return the listen address.
-     */
-    public String getListenAddress() {
-      return listenAddress;
-    }
-
-    /**
-     * Set the listen address.
-     */
-    public void setListenAddress(String listenAddress) {
-      this.listenAddress = listenAddress;
-    }
-
-    /**
-     * Return the send port.
-     */
-    public int getSendPort() {
-      return sendPort;
-    }
-
-    /**
-     * Set the send port.
-     */
-    public void setSendPort(int sendPort) {
-      this.sendPort = sendPort;
-    }
-
-    /**
-     * Return the send address.
-     */
-    public String getSendAddress() {
-      return sendAddress;
-    }
-
-    /**
-     * Set the send address.
-     */
-    public void setSendAddress(String sendAddress) {
-      this.sendAddress = sendAddress;
-    }
-
-    /**
-     * Return the maximum send packet size.
-     */
-    public int getMaxSendPacketSize() {
-      return maxSendPacketSize;
-    }
-
-    /**
-     * Set the maximum send packet size.  Note 1500 is Ethernet MTU and this must be less than UDP max packet size of 65507.
-     */
-    public void setMaxSendPacketSize(int maxSendPacketSize) {
-      this.maxSendPacketSize = maxSendPacketSize;
-    }
-
-    /**
-     * Return true if send messages when no other members in the cluster are up.
-     */
-    public boolean isSendWithNoMembers() {
-      return sendWithNoMembers;
-    }
-
-    /**
-     * Set true if send messages when no other members in the cluster are up.
-     */
-    public void setSendWithNoMembers(boolean sendWithNoMembers) {
-      this.sendWithNoMembers = sendWithNoMembers;
-    }
-
-    /**
-     * Return true if loopback is disabled. When multiple instances are on same box you need to broadcast back locally.
-     */
-    public boolean isDisableLoopback() {
-      return disableLoopback;
-    }
-
-    /**
-     * Set if loopback is disabled. When multiple instances are on same box you need to broadcast back locally.
-     */
-    public void setDisableLoopback(boolean disableLoopback) {
-      this.disableLoopback = disableLoopback;
-    }
-
-    /**
-     * Return the listen time to live.
-     */
-    public int getListenTimeToLive() {
-      return listenTimeToLive;
-    }
-
-    /**
-     * Set the listen time to live.
-     */
-    public void setListenTimeToLive(int listenTimeToLive) {
-      this.listenTimeToLive = listenTimeToLive;
-    }
-
-    /**
-     * Return the listen timeout.
-     */
-    public int getListenTimeout() {
-      return listenTimeout;
-    }
-
-    /**
-     * set the listen timeout.
-     */
-    public void setListenTimeout(int listenTimeout) {
-      this.listenTimeout = listenTimeout;
-    }
-
-    /**
-     * Return the listen buffer size.
-     */
-    public int getListenBufferSize() {
-      return listenBufferSize;
-    }
-
-    /**
-     * Set the listen buffer size.
-     */
-    public void setListenBufferSize(int listenBufferSize) {
-      this.listenBufferSize = listenBufferSize;
-    }
-
-    /**
-     * Return the listener bind address (optional). For multihomed environment the address the listener should bind to.
-     */
-    public String getListenBindAddress() {
-      return listenBindAddress;
-    }
-
-    /**
-     * Set the listener bind address (optional). For multihomed environment the address the listener should bind to.
-     */
-    public void setListenBindAddress(String listenBindAddress) {
-      this.listenBindAddress = listenBindAddress;
-    }
-  }
-
-  // -------------------------------------------------------------------------------------------
-  // SocketConfig
-
-  /**
-   * Configuration for clustering using TCP sockets.
-   * <p>
-   * This is good for when there are relatively small number of cluster members.
-   */
-  public static class SocketConfig {
-
-    /**
-     * This local server in host:port format.
-     */
-    String localHostPort;
-
-    /**
-     * All the cluster members in host:port format.
-     */
-    List<String> members = new ArrayList<String>();
-
-    /**
-     * core threads for the associated thread pool.
-     */
-    int coreThreads = 2;
-
-    /**
-     * Max threads for the associated thread pool.
-     */
-    int maxThreads = 16;
-
-    String threadPoolName = "EbeanCluster";
-
-    /**
-     * Return the host and port for this server instance.
-     */
-    public String getLocalHostPort() {
-      return localHostPort;
-    }
-
-    /**
-     * Set the host and port for this server instance.
-     */
-    public void setLocalHostPort(String localHostPort) {
-      this.localHostPort = localHostPort;
-    }
-
-    /**
-     * Return all the host and port for all the members of the cluster.
-     */
-    public List<String> getMembers() {
-      return members;
-    }
-
-    /**
-     * Set all the host and port for all the members of the cluster.
-     */
-    public void setMembers(List<String> members) {
-      this.members = members;
-    }
-
-    /**
-     * Return the number of core threads to use.
-     */
-    public int getCoreThreads() {
-      return coreThreads;
-    }
-
-    /**
-     * Set the number of core threads to use.
-     */
-    public void setCoreThreads(int coreThreads) {
-      this.coreThreads = coreThreads;
-    }
-
-    /**
-     * Return the number of max threads to use.
-     */
-    public int getMaxThreads() {
-      return maxThreads;
-    }
-
-    /**
-     * Set the number of max threads to use.
-     */
-    public void setMaxThreads(int maxThreads) {
-      this.maxThreads = maxThreads;
-    }
-
-    /**
-     * Return the thread pool name.
-     */
-    public String getThreadPoolName() {
-      return threadPoolName;
-    }
-
-    /**
-     * Set the thread pool name.
-     */
-    public void setThreadPoolName(String threadPoolName) {
-      this.threadPoolName = threadPoolName;
-    }
-  }
-
-  // -------------------------------------------------------------------------------------------
-  // Members
-
-  /**
-   * Load the settings from properties.
-   */
-  public void loadFromProperties(Properties properties) {
-    //TODO
-  }
-
-  /**
-   * Return the cluster mode.
-   */
-  public ClusterMode getMode() {
-    return mode;
-  }
-
-  /**
-   * Set the cluster mode.
-   */
-  public void setMode(ClusterMode mode) {
-    this.mode = mode;
-  }
-
-  /**
-   * Return the socket communication configuration.
-   */
-  public SocketConfig getSocketConfig() {
-    return socketConfig;
-  }
-
-  /**
-   * Set the socket communication configuration.
-   */
-  public void setSocketConfig(SocketConfig socketConfig) {
-    this.socketConfig = socketConfig;
-  }
-
-  /**
-   * Return the multicast communication configuration.
-   */
-  public MulticastConfig getMulticastConfig() {
-    return multicastConfig;
-  }
-
-  /**
-   * Set the multicast communication configuration.
-   */
-  public void setMulticastConfig(MulticastConfig multicastConfig) {
-    this.multicastConfig = multicastConfig;
-  }
-}

src/main/java/com/avaje/ebean/config/CurrentUserProvider.java

@@ -1,16 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Provides the current user in order to support 'Who created', 'Who modified' and other audit features.
- */
-public interface CurrentUserProvider {
-
-  /**
-   * Return the current user id.
-   * <p>
-   *   The type returned should match the type of the properties annotated
-   *   with @WhoCreated and @WhoModified. These are typically String, Long or UUID.
-   * </p>
-   */
-  Object currentUser();
-}

src/main/java/com/avaje/ebean/config/DbMigrationConfig.java

@@ -1,324 +0,0 @@
-package com.avaje.ebean.config;
-
-import com.avaje.ebean.EbeanServer;
-import com.avaje.ebean.config.dbplatform.DbPlatformName;
-import com.avaje.ebean.dbmigration.DbMigration;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Configuration for the DB migration processing.
- */
-public class DbMigrationConfig {
-
-  protected static final Logger logger = LoggerFactory.getLogger(DbMigrationConfig.class);
-
-  /**
-   * The database platform to generate migration DDL for.
-   */
-  protected DbPlatformName platform;
-
-  /**
-   * Set to true if the DB migration should be generated on server start.
-   */
-  protected boolean generate;
-
-  /**
-   * The migration version name (typically FlywayDb compatible).
-   * <p>
-   * Example: 1.1.1_2
-   * <p>
-   * The version is expected to be the combination of the current pom version plus
-   * a 'feature' id. The combined version must be unique and ordered to work with
-   * FlywayDb so each developer sets a unique version so that the migration script
-   * generated is unique (typically just prior to being submitted as a merge request).
-   */
-  protected String version;
-
-  /**
-   * Description text that can be appended to the version to become the ddl script file name.
-   * <p>
-   * So if the name is "a foo table" then the ddl script file could be:
-   * "1.1.1_2__a-foo-table.sql"
-   * <p>
-   * When the DB migration relates to a git feature (merge request) then this description text
-   * is a short description of the feature.
-   */
-  protected String name;
-
-  /**
-   * Resource path for the migration xml and sql.
-   */
-  protected String migrationPath = "dbmigration";
-
-  /**
-   * Subdirectory the model xml files go into.
-   */
-  protected String modelPath = "model";
-
-  protected String applySuffix = ".sql";
-
-  protected String modelSuffix = ".model.xml";
-
-  protected boolean includeGeneratedFileComment;
-
-  /**
-   * The version of a pending drop that should be generated as the next migration.
-   */
-  protected String generatePendingDrop;
-
-  /**
-   * Return the DB platform to generate migration DDL for.
-   *
-   * We typically need to explicitly specify this as migration can often be generated
-   * when running against H2.
-   */
-  public DbPlatformName getPlatform() {
-    return platform;
-  }
-
-  /**
-   * Set the DB platform to generate migration DDL for.
-   */
-  public void setPlatform(DbPlatformName platform) {
-    this.platform = platform;
-  }
-
-  /**
-   * Return the resource path for db migrations.
-   */
-  public String getMigrationPath() {
-    return migrationPath;
-  }
-
-  /**
-   * Set the resource path for db migrations.
-   * <p>
-   * The default of "dbmigration" is reasonable in most cases. You may look to set this
-   * to be something like "dbmigration/myapp" where myapp gives it a unique resource path
-   * in the case there are multiple EbeanServer applications in the single classpath.
-   * </p>
-   */
-  public void setMigrationPath(String migrationPath) {
-    this.migrationPath = migrationPath;
-  }
-
-  /**
-   * Return the relative path for the model files (defaults to model).
-   */
-  public String getModelPath() {
-    return modelPath;
-  }
-
-  /**
-   * Set the relative path for the model files.
-   */
-  public void setModelPath(String modelPath) {
-    this.modelPath = modelPath;
-  }
-
-  /**
-   * Return the model suffix (defaults to model.xml)
-   */
-  public String getModelSuffix() {
-    return modelSuffix;
-  }
-
-  /**
-   * Set the model suffix.
-   */
-  public void setModelSuffix(String modelSuffix) {
-    this.modelSuffix = modelSuffix;
-  }
-
-  /**
-   * Return the apply script suffix (defaults to sql).
-   */
-  public String getApplySuffix() {
-    return applySuffix;
-  }
-
-  /**
-   * Set the apply script suffix (defaults to sql).
-   */
-  public void setApplySuffix(String applySuffix) {
-    this.applySuffix = applySuffix;
-  }
-
-  /**
-   * Return true if the generated file comment should be included.
-   */
-  public boolean isIncludeGeneratedFileComment() {
-    return includeGeneratedFileComment;
-  }
-
-  /**
-   * Set to true if the generated file comment should be included.
-   */
-  public void setIncludeGeneratedFileComment(boolean includeGeneratedFileComment) {
-    this.includeGeneratedFileComment = includeGeneratedFileComment;
-  }
-
-  /**
-   * Return the migration version (or "next") to generate pending drops for.
-   */
-  public String getGeneratePendingDrop() {
-    return generatePendingDrop;
-  }
-
-  /**
-   * Set the migration version (or "next") to generate pending drops for.
-   */
-  public void setGeneratePendingDrop(String generatePendingDrop) {
-    this.generatePendingDrop = generatePendingDrop;
-  }
-
-  /**
-   * Set the migration version.
-   * <p>
-   * Note that version set via System property or environment variable <code>ddl.migration.version</code> takes precedence.
-   */
-  public void setVersion(String version) {
-    this.version = version;
-  }
-
-  /**
-   * Set the migration name.
-   * <p>
-   * Note that name set via System property or environment variable <code>ddl.migration.name</code> takes precedence.
-   */
-  public void setName(String name) {
-    this.name = name;
-  }
-
-  /**
-   * Set the model, rollback and drop paths to be empty such that all the migration files are generated
-   * into a single directory.
-   */
-  public void singleDirectory() {
-    this.modelPath = "";
-  }
-
-  /**
-   * Load the settings from the PropertiesWrapper.
-   */
-  public void loadSettings(PropertiesWrapper properties) {
-
-    migrationPath = properties.get("migration.migrationPath", migrationPath);
-    if (properties.getBoolean("migration.singleDirectory", false)) {
-      singleDirectory();
-    } else {
-      modelPath = properties.get("migration.modelPath", modelPath);
-    }
-    applySuffix = properties.get("migration.applySuffix", applySuffix);
-    modelSuffix = properties.get("migration.modelSuffix", modelSuffix);
-    includeGeneratedFileComment = properties.getBoolean("migration.includeGeneratedFileComment", includeGeneratedFileComment);
-    generatePendingDrop = properties.get("migration.generatePendingDrop", generatePendingDrop);
-
-    platform = properties.getEnum(DbPlatformName.class, "migration.platform", platform);
-
-    generate = properties.getBoolean("migration.generate", generate);
-    version = properties.get("migration.version", version);
-    name = properties.get("migration.name", name);
-  }
-
-  /**
-   * Return true if the migration should be generated.
-   * <p>
-   * It is expected that when an environment variable <code>ddl.migration.enabled</code>
-   * is set to <code>true</code> then the DB migration will generate the migration DDL.
-   * </p>
-   */
-  public boolean isGenerateOnStart() {
-
-    // environment properties take precedence
-    String envGenerate = readEnvironment("ddl.migration.generate");
-    if (envGenerate != null) {
-      return "true".equalsIgnoreCase(envGenerate.trim());
-    }
-    return generate;
-  }
-
-  /**
-   * Called by EbeanServer on start.
-   *
-   * <p>
-   * If enabled this generates the migration xml and DDL scripts.
-   * </p>
-   */
-  public void generateOnStart(EbeanServer server) {
-
-    if (isGenerateOnStart()) {
-      if (platform == null) {
-        logger.warn("No platform set for migration DDL generation");
-      } else {
-        // generate the migration xml and platform specific DDL
-        DbMigration migration = new DbMigration(server);
-        migration.setPlatform(platform);
-        try {
-          migration.generateMigration();
-        } catch (Exception e) {
-          throw new RuntimeException("Error generating DB migration", e);
-        }
-      }
-    }
-  }
-
-  /**
-   * Return the migration version (typically FlywayDb compatible).
-   * <p>
-   * Example: 1.1.1_2
-   * <p>
-   * The version is expected to be the combination of the current pom version plus
-   * a 'feature' id. The combined version must be unique and ordered to work with
-   * FlywayDb so each developer sets a unique version so that the migration script
-   * generated is unique (typically just prior to being submitted as a merge request).
-   */
-  public String getVersion() {
-    String envVersion = readEnvironment("ddl.migration.version");
-    if (!isEmpty(envVersion)) {
-      return envVersion.trim();
-    }
-    return version;
-  }
-
-  /**
-   * Return the migration name which is short description text that can be appended to
-   * the migration version to become the ddl script file name.
-   * <p>
-   * So if the name is "a foo table" then the ddl script file could be:
-   * "1.1.1_2__a-foo-table.sql"
-   * </p>
-   * <p>
-   * When the DB migration relates to a git feature (merge request) then this description text
-   * is a short description of the feature.
-   * </p>
-   */
-  public String getName() {
-    String envName = readEnvironment("ddl.migration.name");
-    if (!isEmpty(envName)) {
-      return envName.trim();
-    }
-    return name;
-  }
-
-  /**
-   * Return the system or environment property.
-   */
-  protected String readEnvironment(String key) {
-
-    String val = System.getProperty(key);
-    if (val == null) {
-      val = System.getenv(key);
-    }
-    return val;
-  }
-
-  /**
-   * Return true if the string is null or empty.
-   */
-  protected boolean isEmpty(String val) {
-    return val == null || val.trim().isEmpty();
-  }
-
-}

src/main/java/com/avaje/ebean/config/DocStoreConfig.java

@@ -1,248 +0,0 @@
-package com.avaje.ebean.config;
-
-import com.avaje.ebean.annotation.DocStoreMode;
-
-/**
- * Configuration for the Document store integration (e.g. ElasticSearch).
- */
-public class DocStoreConfig {
-
-  /**
-   * True when the Document store integration is active/on.
-   */
-  protected boolean active;
-
-  /**
-   * Set to true means Ebean will generate mapping files on startup.
-   */
-  protected boolean generateMapping;
-
-  /**
-   * When true the Document store should drop and re-create document indexes.
-   */
-  protected boolean dropCreate;
-
-  /**
-   * When true the Document store should create any document indexes that don't already exist.
-   */
-  protected boolean create;
-
-  /**
-   * The URL of the Document store server. For example: http://localhost:9200.
-   */
-  protected String url;
-
-  /**
-   * The default mode used by indexes.
-   */
-  protected DocStoreMode persist = DocStoreMode.UPDATE;
-
-  /**
-   * The default batch size to use for the Bulk API calls.
-   */
-  protected int bulkBatchSize = 1000;
-
-  /**
-   * Resource path for the Document store mapping files.
-   */
-  protected String mappingPath;
-
-  /**
-   * Suffix used for mapping files.
-   */
-  protected String mappingSuffix;
-
-  /**
-   * Location of resources that mapping files are generated into.
-   */
-  protected String pathToResources = "src/main/resources";
-
-  /**
-   * Return true if the Document store (ElasticSearch) integration is active.
-   */
-  public boolean isActive() {
-    String systemValue = System.getProperty("ebean.docstore.active");
-    if (systemValue != null) {
-      return Boolean.parseBoolean(systemValue);
-    }
-    return active;
-  }
-
-  /**
-   * Set to true to make the Document store (ElasticSearch) integration active.
-   */
-  public void setActive(boolean active) {
-    this.active = active;
-  }
-
-  /**
-   * Return the URL to the Document store.
-   */
-  public String getUrl() {
-    String systemValue = System.getProperty("ebean.docstore.url");
-    if (systemValue != null) {
-      return systemValue;
-    }
-
-    return url;
-  }
-
-  /**
-   * Set the URL to the Document store server.
-   * <p>
-   * For a local ElasticSearch server this would be: http://localhost:9200
-   */
-  public void setUrl(String url) {
-    this.url = url;
-  }
-
-  /**
-   * Return true if Ebean should generate mapping files on server startup.
-   */
-  public boolean isGenerateMapping() {
-    return generateMapping;
-  }
-
-  /**
-   * Set to true if Ebean should generate mapping files on server startup.
-   */
-  public void setGenerateMapping(boolean generateMapping) {
-    this.generateMapping = generateMapping;
-  }
-
-  /**
-   * Return true if the document store should recreate mapped indexes.
-   */
-  public boolean isDropCreate() {
-    return dropCreate;
-  }
-
-  /**
-   * Set to true if the document store should recreate mapped indexes.
-   */
-  public void setDropCreate(boolean dropCreate) {
-    this.dropCreate = dropCreate;
-  }
-
-  /**
-   * Create true if the document store should create mapped indexes that don't yet exist.
-   * This is only used if dropCreate is false.
-   */
-  public boolean isCreate() {
-    return create;
-  }
-
-  /**
-   * Set to true if the document store should create mapped indexes that don't yet exist.
-   * This is only used if dropCreate is false.
-   */
-  public void setCreate(boolean create) {
-    this.create = create;
-  }
-
-  /**
-   * Return the default batch size to use for calls to the Bulk API.
-   */
-  public int getBulkBatchSize() {
-    return bulkBatchSize;
-  }
-
-  /**
-   * Set the default batch size to use for calls to the Bulk API.
-   * <p>
-   * The batch size can be set on a transaction via {@link com.avaje.ebean.Transaction#setDocStoreBatchSize(int)}.
-   * </p>
-   */
-  public void setBulkBatchSize(int bulkBatchSize) {
-    this.bulkBatchSize = bulkBatchSize;
-  }
-
-  /**
-   * Return the mapping path.
-   */
-  public String getMappingPath() {
-    return mappingPath;
-  }
-
-  /**
-   * Set the mapping path.
-   */
-  public void setMappingPath(String mappingPath) {
-    this.mappingPath = mappingPath;
-  }
-
-  /**
-   * Return the mapping suffix.
-   */
-  public String getMappingSuffix() {
-    return mappingSuffix;
-  }
-
-  /**
-   * Set the mapping suffix.
-   */
-  public void setMappingSuffix(String mappingSuffix) {
-    this.mappingSuffix = mappingSuffix;
-  }
-
-  /**
-   * Return the relative file system path to resources when generating mapping files.
-   */
-  public String getPathToResources() {
-    return pathToResources;
-  }
-
-  /**
-   * Set the relative file system path to resources when generating mapping files.
-   */
-  public void setPathToResources(String pathToResources) {
-    this.pathToResources = pathToResources;
-  }
-
-  /**
-   * Return the default behavior for when Insert, Update and Delete events occur on beans that have an associated
-   * Document store.
-   */
-  public DocStoreMode getPersist() {
-    return persist;
-  }
-
-  /**
-   * Set the default behavior for when Insert, Update and Delete events occur on beans that have an associated
-   * Document store.
-   * <ul>
-   * <li>DocStoreEvent.UPDATE - build and send message to Bulk API</li>
-   * <li>DocStoreEvent.QUEUE - add an entry with the index type and id only into a queue for later processing</li>
-   * <li>DocStoreEvent.IGNORE - ignore. Most likely used when some scheduled batch job handles updating the index</li>
-   * </ul>
-   * <p>
-   * You might choose to use QUEUE if that particular index data is updating very frequently or the cost of indexing
-   * is expensive.  Setting it to QUEUE can mean many changes can be batched together potentially coalescing multiple
-   * updates for an index entry into a single update.
-   * </p>
-   * <p>
-   * You might choose to use IGNORE when you have your own external process for updating the indexes. In this case
-   * you don't want Ebean to do anything when the data changes.
-   * </p>
-   */
-  public void setPersist(DocStoreMode persist) {
-    this.persist = persist;
-  }
-
-  /**
-   * Load settings specified in properties files.
-   */
-  public void loadSettings(PropertiesWrapper properties) {
-
-    active = properties.getBoolean("docstore.active", active);
-    url = properties.get("docstore.url", url);
-    persist = properties.getEnum(DocStoreMode.class, "docstore.persist", persist);
-    bulkBatchSize = properties.getInt("docstore.bulkBatchSize", bulkBatchSize);
-    generateMapping = properties.getBoolean("docstore.generateMapping", generateMapping);
-    dropCreate = properties.getBoolean("docstore.dropCreate", dropCreate);
-    create = properties.getBoolean("docstore.create", create);
-    mappingPath = properties.get("docstore.mappingPath", mappingPath);
-    mappingSuffix = properties.get("docstore.mappingSuffix", mappingSuffix);
-    pathToResources = properties.get("docstore.pathToResources", pathToResources);
-  }
-}

src/main/java/com/avaje/ebean/config/MatchingNamingConvention.java

@@ -1,46 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * The JPA naming convention where column names match property names and table
- * names match entity names.
- * 
- * <p>
- * The JPA specification states that the in the case of no annotations the name
- * of the class will be take as the table name and the name of a property will
- * be taken as the name of the column.
- * </p>
- * 
- * @author emcgreal
- */
-public class MatchingNamingConvention extends AbstractNamingConvention {
-
-  /**
-   * Create with a sequence format of "{table}_seq".
-   */
-  public MatchingNamingConvention() {
-    super();
-  }
-
-  /**
-   * Instantiates with a specific format for DB sequences.
-   * 
-   * @param sequenceFormat
-   *          the sequence format
-   */
-  public MatchingNamingConvention(String sequenceFormat) {
-    super(sequenceFormat);
-  }
-
-  public String getColumnFromProperty(Class<?> beanClass, String propertyName) {
-    return propertyName;
-  }
-
-  public TableName getTableNameByConvention(Class<?> beanClass) {
-
-    return new TableName(getCatalog(), getSchema(), beanClass.getSimpleName());
-  }
-
-  public String getPropertyFromColumn(Class<?> beanClass, String dbColumnName) {
-    return dbColumnName;
-  }
-}

src/main/java/com/avaje/ebean/config/PersistBatch.java

@@ -1,52 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Defines the mode for JDBC batch processing.
- * <p>
- * Used both at a per transaction basis and per request basis.
- * </p>
- *
- * @see com.avaje.ebean.config.ServerConfig#setPersistBatch(PersistBatch)
- * @see com.avaje.ebean.config.ServerConfig#setPersistBatchOnCascade(PersistBatch)
- *
- * @see com.avaje.ebean.Transaction#setBatch(PersistBatch)
- * @see com.avaje.ebean.Transaction#setBatchOnCascade(PersistBatch)
- */
-public enum PersistBatch {
-
-  /**
-   * Do not use JDBC Batch mode.
-   */
-  NONE(false),
-
-  /**
-   * Use JDBC Batch mode on Inserts.
-   */
-  INSERT(true),
-
-  /**
-   * Use JDBC Batch mode on Inserts, Updates and Deletes.
-   */
-  ALL(true),
-
-  /**
-   * You should not use this value explicitly. It should only used on the Transactional annotation
-   * to indicate that the value should inherit from the ServerConfig setting.
-   */
-  INHERIT(false);
-
-
-  final boolean forInsert;
-
-  PersistBatch(boolean forInsert) {
-    this.forInsert = forInsert;
-  }
-
-  /**
-   * Return true if persist cascade should use JDBC batch for inserts.
-   */
-  public boolean forInsert() {
-    return forInsert;
-  }
-
-}

src/main/java/com/avaje/ebean/config/ScalarTypeConverter.java

@@ -1,74 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Used to convert between a value object and a known scalar type. The value
- * object is the logical type used in your application and the scalar type is
- * the value used to persist than to the DB.
- * <p>
- * The Value object should be immutable and scalar (aka not compound) and
- * converts to and from a known scalar type which Ebean will use to persist the
- * value.
- * </p>
- * <p>
- * This is an easier alternative to implementing the
- * com.avaje.ebean.server.type.ScalarType interface.
- * </p>
- * <p>
- * Note that Ebean will automatically try to detect Immutable Scalar Value
- * Objects and automatically support them via reflection. This however would not
- * be appropriate when the logical type is different from the type you wish to
- * use for persistence - for example, if the logical type was long and you
- * wanted to use java.sql.Timestamp for persistence. In this case you would want
- * to implement this interface rather than let Ebean automatically support that
- * type via reflection.
- * </p>
- * <p>
- * If you want to support a Compound Type rather than a Scalar Type refer to
- * {@link CompoundType}.
- * </p>
- * 
- * @author rbygrave
- * 
- * @param <B>
- *          The value object type.
- * @param <S>
- *          The scalar object type that is used to persist the value object.
- * 
- * @see CompoundType
- * @see CompoundTypeProperty
- */
-public interface ScalarTypeConverter<B, S> {
-
-  /**
-   * Return the value to represent null. Typically this is actually null but for
-   * scala.Option and similar type converters this actually returns an instance
-   * representing "None".
-   */
-  B getNullValue();
-
-  /**
-   * Convert the scalar type value into the value object.
-   * <p>
-   * This typically occurs when Ebean reads the value from a resultSet or other
-   * data source.
-   * </p>
-   * 
-   * @param scalarType
-   *          the value from the data source
-   */
-  B wrapValue(S scalarType);
-
-  /**
-   * Convert the value object into a scalar value that Ebean knows how to
-   * persist.
-   * <p>
-   * This typically occurs when Ebean is persisting the value object to the data
-   * store.
-   * </p>
-   * 
-   * @param beanType
-   *          the value object
-   */
-  S unwrapValue(B beanType);
-
-}