#919 - io.ebean package initial

src/main/java/com/avaje/ebeaninternal/api/package-info.java

@@ -1 +0,0 @@
-package com.avaje.ebeaninternal.api;

src/main/java/com/avaje/ebeaninternal/server/autotune/service/AutoTuneServiceFactory.java

@@ -1,14 +0,0 @@
-package com.avaje.ebeaninternal.server.autotune.service;
-
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebeaninternal.api.SpiEbeanServer;
-import com.avaje.ebeaninternal.server.autotune.AutoTuneService;
-
-public class AutoTuneServiceFactory {
-
-  public static AutoTuneService create(SpiEbeanServer server, ServerConfig serverConfig) {
-
-    return new DefaultAutoTuneService(server, serverConfig);
-  }
-
-}

src/main/java/com/avaje/ebeaninternal/server/cache/package-info.java

@@ -1 +0,0 @@
-package com.avaje.ebeaninternal.server.cache;

src/main/java/com/avaje/ebeaninternal/server/el/package-info.java

@@ -1 +0,0 @@
-package com.avaje.ebeaninternal.server.el;

src/main/java/com/avaje/ebeaninternal/server/loadcontext/package-info.java

@@ -1 +0,0 @@
-package com.avaje.ebeaninternal.server.loadcontext;

src/main/java/com/avaje/ebeaninternal/server/query/package-info.java

@@ -1 +0,0 @@
-package com.avaje.ebeaninternal.server.query;

src/main/java/com/avaje/ebeaninternal/server/querydefn/package-info.java

@@ -1 +0,0 @@
-package com.avaje.ebeaninternal.server.querydefn;

src/main/java/com/avaje/ebeaninternal/server/text/csv/package-info.java

@@ -1 +0,0 @@
-package com.avaje.ebeaninternal.server.text.csv;

src/main/java/com/avaje/ebeanservice/docstore/api/mapping/package-info.java

@@ -1,4 +0,0 @@
-/**
- * Mapping for document store integration.
- */
-package com.avaje.ebeanservice.docstore.api.mapping;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Administrative control of AutoTune during runtime.

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.beans.PropertyChangeListener;
 import java.util.Map;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.sql.CallableStatement;
 import java.sql.SQLException;
@@ -73,8 +73,8 @@ import java.sql.SQLException;
  * }
  * }</pre>
  *
- * @see com.avaje.ebean.SqlUpdate
- * @see com.avaje.ebean.Ebean#execute(CallableSql)
+ * @see SqlUpdate
+ * @see Ebean#execute(CallableSql)
  */
 public interface CallableSql {
 

src/main/java/io/ebean/DRawSqlColumnsParser.java

@@ -1,6 +1,6 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.RawSql.ColumnMapping;
+import io.ebean.RawSql.ColumnMapping;
 
 import javax.persistence.PersistenceException;
 import java.util.ArrayList;

src/main/java/io/ebean/DRawSqlParser.java

@@ -1,7 +1,7 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.RawSql.Sql;
-import com.avaje.ebeaninternal.server.querydefn.SimpleTextParser;
+import io.ebean.RawSql.Sql;
+import io.ebeaninternal.server.querydefn.SimpleTextParser;
 
 /**
  * Parses sql-select queries to try and determine the location where WHERE and

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Bean holding the details to update the document store.

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

@@ -1,6 +1,6 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebeanservice.docstore.api.DocQueryRequest;
+import io.ebeanservice.docstore.api.DocQueryRequest;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;

src/main/java/io/ebean/Ebean.java

@@ -1,9 +1,9 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.cache.ServerCacheManager;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.text.csv.CsvReader;
-import com.avaje.ebean.text.json.JsonContext;
+import io.ebean.cache.ServerCacheManager;
+import io.ebean.config.ServerConfig;
+import io.ebean.text.csv.CsvReader;
+import io.ebean.text.json.JsonContext;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

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

@@ -1,11 +1,11 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.cache.ServerCacheManager;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.meta.MetaInfoManager;
-import com.avaje.ebean.plugin.SpiServer;
-import com.avaje.ebean.text.csv.CsvReader;
-import com.avaje.ebean.text.json.JsonContext;
+import io.ebean.cache.ServerCacheManager;
+import io.ebean.config.ServerConfig;
+import io.ebean.meta.MetaInfoManager;
+import io.ebean.plugin.SpiServer;
+import io.ebean.text.csv.CsvReader;
+import io.ebean.text.json.JsonContext;
 import org.jetbrains.annotations.Nullable;
 
 import javax.persistence.NonUniqueResultException;
@@ -907,7 +907,7 @@ public interface EbeanServer {
    * @param query       the query to execute the row count on
    * @param transaction the transaction (can be null).
    * @return a Future object for the row count query
-   * @see com.avaje.ebean.Query#findFutureCount()
+   * @see Query#findFutureCount()
    */
   <T> FutureRowCount<T> findFutureCount(Query<T> query, Transaction transaction);
 
@@ -922,7 +922,7 @@ public interface EbeanServer {
    * @param query       the query to execute the fetch Id's on
    * @param transaction the transaction (can be null).
    * @return a Future object for the list of Id's
-   * @see com.avaje.ebean.Query#findFutureIds()
+   * @see Query#findFutureIds()
    */
   <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction);
 

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

@@ -1,9 +1,9 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.common.SpiContainer;
-import com.avaje.ebean.config.ContainerConfig;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebeaninternal.server.lib.ShutdownManager;
+import io.ebean.common.SpiContainer;
+import io.ebean.config.ContainerConfig;
+import io.ebean.config.ServerConfig;
+import io.ebeaninternal.server.lib.ShutdownManager;
 
 import javax.persistence.PersistenceException;
 import java.lang.reflect.Constructor;
@@ -30,7 +30,7 @@ import java.util.Properties;
 public class EbeanServerFactory {
 
 
-  private static final String DEFAULT_CONTAINER = "com.avaje.ebeaninternal.server.core.DefaultContainer";
+  private static final String DEFAULT_CONTAINER = "io.ebeaninternal.server.core.DefaultContainer";
 
   private static SpiContainer container;
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Query by Example expression.

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.util.Collection;
 import java.util.Map;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * An expression that is part of a WHERE or HAVING clause.

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

@@ -1,10 +1,10 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.search.Match;
-import com.avaje.ebean.search.MultiMatch;
-import com.avaje.ebean.search.TextCommonTerms;
-import com.avaje.ebean.search.TextQueryString;
-import com.avaje.ebean.search.TextSimple;
+import io.ebean.search.Match;
+import io.ebean.search.MultiMatch;
+import io.ebean.search.TextCommonTerms;
+import io.ebean.search.TextQueryString;
+import io.ebean.search.TextSimple;
 
 import java.util.Collection;
 import java.util.List;

src/main/java/io/ebean/ExpressionList.java

@@ -1,10 +1,10 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.search.Match;
-import com.avaje.ebean.search.MultiMatch;
-import com.avaje.ebean.search.TextCommonTerms;
-import com.avaje.ebean.search.TextQueryString;
-import com.avaje.ebean.search.TextSimple;
+import io.ebean.search.Match;
+import io.ebean.search.MultiMatch;
+import io.ebean.search.TextCommonTerms;
+import io.ebean.search.TextQueryString;
+import io.ebean.search.TextSimple;
 import org.jetbrains.annotations.Nullable;
 
 import javax.persistence.NonUniqueResultException;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.io.Serializable;
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.util.Set;
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.util.List;
 import java.util.Set;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import org.jetbrains.annotations.Nullable;
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.util.List;
 import java.util.concurrent.Future;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import javax.persistence.PersistenceException;
 import java.util.List;

src/main/java/io/ebean/FutureRowCount.java

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.util.concurrent.Future;
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Represents a Conjunction or a Disjunction.

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Used to specify the type of like matching used.
@@ -32,4 +32,4 @@ public enum LikeType {
    * </p>
    */
   EQUAL_TO
-}
+}

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

@@ -1,6 +1,6 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.bean.EntityBean;
+import io.ebean.bean.EntityBean;
 
 import javax.persistence.MappedSuperclass;
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.io.Serializable;
 import java.util.ArrayList;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.util.List;
 import java.util.concurrent.Future;

src/main/java/io/ebean/PersistBatch.java

@@ -0,0 +1,58 @@
+package io.ebean;
+
+/**
+ * Defines the mode for JDBC batch processing.
+ * <p>
+ * Used both at a per transaction basis and per request basis.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ *   // set full jdbc batch as default
+ *   serverConfig.setPersistBatch(PersistBatch.ALL);
+ *
+ *
+ *   // set full jdbc batch per transaction
+ *   transaction.setBatch(PersistBatch.ALL);
+ *
+ * }</pre>
+ *
+ */
+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/io/ebean/PersistenceContextScope.java

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Defines the scope for PersistenceContext.
@@ -6,8 +6,8 @@ package com.avaje.ebean;
  * Ebean has traditionally used Transaction scope for the PersistenceContext. This is used to change the scope to
  * use (by default) and explicitly set the scope to use for an individual query.
  *
- * @see com.avaje.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)
- * @see com.avaje.ebean.Query#setPersistenceContextScope(PersistenceContextScope)
+ * @see io.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)
+ * @see Query#setPersistenceContextScope(PersistenceContextScope)
  */
 public enum PersistenceContextScope {
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import javax.persistence.PersistenceException;
 

src/main/java/io/ebean/Platform.java

@@ -0,0 +1,58 @@
+package io.ebean;
+
+/**
+ * Built in supported platforms.
+ */
+public enum Platform {
+
+  /**
+   * Generic base platform configured via properties or code.
+   */
+  GENERIC,
+
+  /**
+   * DB2.
+   */
+  DB2,
+
+  /**
+   * H2.
+   */
+  H2,
+
+  /**
+   * HsqlDB.
+   */
+  HSQLDB,
+
+  /**
+   * Postgres.
+   */
+  POSTGRES,
+
+  /**
+   * MySql.
+   */
+  MYSQL,
+
+  /**
+   * Oracle.
+   */
+  ORACLE,
+
+  /**
+   * SQLAnywhere.
+   */
+  SQLANYWHERE,
+
+  /**
+   * SQLite.
+   */
+  SQLITE,
+
+  /**
+   * Microsoft SQL Server.
+   */
+  SQLSERVER;
+
+}

src/main/java/io/ebean/PrimaryServer.java

@@ -1,6 +1,6 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.config.PropertyMap;
+import io.ebean.config.PropertyMap;
 
 import java.util.Properties;
 

src/main/java/io/ebean/Query.java

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import org.jetbrains.annotations.Nullable;
 
@@ -243,7 +243,7 @@ public interface Query<T> {
   /**
    * Specify the PersistenceContextScope to use for this query.
    * <p/>
-   * When this is not set the 'default' configured on {@link com.avaje.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)}
+   * When this is not set the 'default' configured on {@link io.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)}
    * is used - this value defaults to {@link PersistenceContextScope#TRANSACTION}.
    * <p/>
    * Note that the same persistence Context is used for subsequent lazy loading and query join queries.

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.util.Iterator;
 

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

@@ -1,6 +1,6 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.util.CamelCaseHelper;
+import io.ebean.util.CamelCaseHelper;
 
 import java.io.Serializable;
 import java.sql.ResultSet;

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

@@ -1,7 +1,7 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.RawSql.ColumnMapping;
-import com.avaje.ebean.RawSql.Sql;
+import io.ebean.RawSql.ColumnMapping;
+import io.ebean.RawSql.Sql;
 
 import java.sql.ResultSet;
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.io.Serializable;
 import java.util.List;

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.io.Serializable;
 import java.math.BigDecimal;
@@ -165,4 +165,4 @@ public interface SqlRow extends Serializable, Map<String, Object> {
    */
   Collection<Object> values();
 
-}
+}

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * A SqlUpdate for executing insert update or delete statements.
@@ -50,7 +50,7 @@ public interface SqlUpdate {
    * {@link Transaction#setBatchSize(int)}.
    * </p>
    *
-   * @see com.avaje.ebean.Ebean#execute(SqlUpdate)
+   * @see Ebean#execute(SqlUpdate)
    */
   int execute();
 

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

@@ -1,9 +1,8 @@
-package com.avaje.ebean;
+package io.ebean;
 
-import com.avaje.ebean.annotation.DocStoreMode;
-import com.avaje.ebean.config.DocStoreConfig;
-import com.avaje.ebean.config.PersistBatch;
-import com.avaje.ebean.config.ServerConfig;
+import io.ebean.annotation.DocStoreMode;
+import io.ebean.config.DocStoreConfig;
+import io.ebean.config.ServerConfig;
 
 import javax.persistence.PersistenceException;
 import javax.persistence.RollbackException;
@@ -324,7 +323,7 @@ public interface Transaction extends Closeable {
    * </p>
    *
    * @param persistBatchMode the batch mode to use for this transaction
-   * @see com.avaje.ebean.config.ServerConfig#setPersistBatch(com.avaje.ebean.config.PersistBatch)
+   * @see io.ebean.config.ServerConfig#setPersistBatch(PersistBatch)
    */
   void setBatch(PersistBatch persistBatchMode);
 
@@ -345,7 +344,7 @@ public interface Transaction extends Closeable {
    * </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)
+   * @see io.ebean.config.ServerConfig#setPersistBatchOnCascade(PersistBatch)
    */
   void setBatchOnCascade(PersistBatch batchOnCascadeMode);
 

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Provides a callback that can be registered with a Transaction.

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Adapter that can be extended for easier implementation of TransactionCallback.

src/main/java/io/ebean/TxCallable.java

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Execute a TxCallable in a Transaction scope.

src/main/java/io/ebean/TxIsolation.java

@@ -0,0 +1,100 @@
+package io.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/io/ebean/TxRunnable.java

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Execute a TxRunnable in a Transaction scope.

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

@@ -1,6 +1,4 @@
-package com.avaje.ebean;
-
-import com.avaje.ebean.config.PersistBatch;
+package io.ebean;
 
 import java.util.ArrayList;
 

src/main/java/io/ebean/TxType.java

@@ -0,0 +1,50 @@
+package io.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/io/ebean/Update.java

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * An Insert Update or Delete statement.

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * An update query typically intended to perform a bulk update of many rows that match the query.

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 /**
  * Holds two values as the result of a difference comparison.

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

@@ -1,4 +1,4 @@
-package com.avaje.ebean;
+package io.ebean;
 
 import java.sql.Timestamp;
 import java.util.Map;

src/main/java/io/ebean/annotation/Aggregation.java

@@ -0,0 +1,50 @@
+package io.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 to be an aggregation formula.
+ * <p>
+ * The aggregation formula should be a sum, count, avg, min or max.
+ * By default aggregation properties are treated as transient and not
+ * included in a query. To populate the aggregation property it must be
+ * explicitly included in the select().
+ * </p>
+ * <p>
+ * <h3>Example:</h3>
+ * <pre>{@code
+ *
+ * @Aggregation("count(details)")
+ * Long totalCount;
+ *
+ * @Aggregation("sum(details.quantity*details.unitPrice)")
+ * Long totalAmount;
+ *
+ * }</pre>
+ * <p>
+ * <h3>Example query</h3>
+ * <pre>{@code
+ *
+ *  List<TEventOne> list = Ebean.find(TEventOne.class)
+ *       .select("name, totalCount, totalUnits, totalAmount")
+ *       .where()
+ *         .startsWith("logs.description", "a")
+ *       .having()
+ *         .ge("count", 1)
+ *       .orderBy().asc("name")
+ *       .findList();
+ *
+ * }</pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Aggregation {
+
+  /**
+   * Aggregation formula using sum, count, avg, min, max.
+   */
+  String value();
+}

src/main/java/io/ebean/annotation/Cache.java

@@ -0,0 +1,63 @@
+package io.ebean.annotation;
+
+import io.ebean.Query;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the default cache use specific entity type.
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Cache {
+
+  /**
+   * Set this to true to enable the use of query cache.
+   * <p>
+   * By default query caching is disabled as the query cache invalidates
+   * frequently and so it is typically used for specific bean types and cases.
+   * </p>
+   */
+  boolean enableQueryCache() default false;
+
+  /**
+   * Set this to false to disable the use of bean cache.
+   * <p>
+   * By default bean caching is expected so this defaults to true.  We might
+   * set this to false on a bean type that we want to use query caching but no
+   * bean caching (and this is expected to be a rare case).
+   * </p>
+   * <p>
+   * When bean caching is enabled by default "find by id" and "find by unique natural key"
+   * queries will try to use the bean cache. We use {@link Query#setUseCache(boolean)}
+   * with <code>false</code> for the case when we do NOT want to use the bean cache.
+   * </p>
+   */
+  boolean enableBeanCache() default true;
+
+  /**
+   * Specify the property that is a natural unique identifier for the bean.
+   * <p>
+   * When a findUnique() query is used with this property as the sole expression
+   * then there will be a lookup into the L2 natural key cache.
+   * </p>
+   */
+  String naturalKey() default "";
+
+  /**
+   * When set to true the beans returned from a query will default to be
+   * readOnly.
+   * <p>
+   * If the bean is readOnly and has no relationships then it may be sharable.
+   * </p>
+   * <p>
+   * If you try to modify a readOnly bean it will throw an
+   * IllegalStateException.
+   * </p>
+   */
+  boolean readOnly() default false;
+
+}

src/main/java/io/ebean/annotation/CacheBeanTuning.java

@@ -0,0 +1,56 @@
+package io.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Cache tuning hints for the L2 bean cache of a specific entity type.
+ * <p>
+ * Note that this is not useful when distributed L2 bean caches are used like
+ * ElasticSearch, Hazelcast, Ignite etc.
+ * </p>
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CacheBeanTuning {
+
+  /**
+   * The maximum size for the cache.
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxSize() default 0;
+
+  /**
+   * The maximum time (in seconds) that a cache entry is allowed to stay in the
+   * cache when it has not been accessed.
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxIdleSecs() default 0;
+
+  /**
+   * The maximum time (in seconds) a cache entry is allowed to stay in the
+   * cache.
+   * <p>
+   * This is not generally required as the cache entries are automatically
+   * evicted when related data changes are committed.
+   * </p>
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxSecsToLive() default 0;
+
+  /**
+   * The frequency (in seconds) that cache trimming should occur.
+   * <p>
+   * This is a hint for cache implementations that use background cache trimming.
+   * </p>
+   */
+  int trimFrequency() default 0;
+}

src/main/java/io/ebean/annotation/CacheQueryTuning.java

@@ -0,0 +1,55 @@
+package io.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify cache tuning for query caching on a specific entity type.
+ * <p>
+ * If this is not specified then the system default settings are used.
+ * </p>
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CacheQueryTuning {
+
+  /**
+   * The maximum size for the cache.
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxSize() default 0;
+
+  /**
+   * The maximum time (in seconds) that a cache entry is allowed to stay in the
+   * cache when it has not been accessed.
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxIdleSecs() default 0;
+
+  /**
+   * The maximum time (in seconds) a cache entry is allowed to stay in the
+   * cache.
+   * <p>
+   * This is not generally required as the cache entries are automatically
+   * evicted when related data changes are committed.
+   * </p>
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxSecsToLive() default 0;
+
+  /**
+   * The frequency (in seconds) that cache trimming should occur.
+   * <p>
+   * This is a hint for cache implementations that use background cache trimming.
+   * </p>
+   */
+  int trimFrequency() default 0;
+}

src/main/java/io/ebean/annotation/ChangeLog.java

@@ -0,0 +1,34 @@
+package io.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/io/ebean/annotation/ChangeLogInsertMode.java

@@ -0,0 +1,22 @@
+package io.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/io/ebean/annotation/CreatedTimestamp.java

@@ -0,0 +1,38 @@
+package io.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>
+ * <p>
+ * <h3>Example:</h3>
+ * <pre>{@code
+ *
+ *   @CreatedTimestamp
+ *   Timestamp whenCreated;
+ *
+ * }</pre>
+ */
+@Target({ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CreatedTimestamp {
+
+}

src/main/java/io/ebean/annotation/DbArray.java

@@ -0,0 +1,40 @@
+package io.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify a collection property that will be stored into a DB ARRAY type.
+ * <p>
+ * If the target database does not support ARRAY type (so not Postgres)
+ * then the collection will be stored in JSON format into a VARCHAR column.
+ * </p>
+ * <p>
+ * <h3>Example:</h3>
+ * <pre>{@code
+ *
+ * // Store as ARRAY of UUID on Postgres
+ * @DbArray
+ * List<UUID> uids = new ArrayList<>();
+ *
+ * // Store as ARRAY on Postgres
+ * @DbArray
+ * List<String> phoneNumbers = new ArrayList<>();
+ *
+ * // Store as ARRAY of INTEGER on Postgres
+ * @DbArray
+ * List<Long> someLongs = new ArrayList<>();
+ *
+ * }</pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DbArray {
+
+  /**
+   * For VARCHAR storage specify the column length (defaults to 1000).
+   */
+  int length() default 0;
+}

src/main/java/io/ebean/annotation/DbComment.java

@@ -0,0 +1,19 @@
+package io.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/io/ebean/annotation/DbEnumType.java

@@ -0,0 +1,17 @@
+package io.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/io/ebean/annotation/DbEnumValue.java

@@ -0,0 +1,44 @@
+package io.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/io/ebean/annotation/DbHstore.java

@@ -0,0 +1,30 @@
+package io.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>
+ * <p>
+ * <h3>Example:</h3>
+ * <pre>{@code
+ *
+ *   @DbHstore
+ *   Map<String, String> tags;
+ *
+ * }</pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DbHstore {
+
+  /**
+   * For VARCHAR storage specify the column length (defaults to 1000).
+   */
+  int length() default 0;
+}

src/main/java/io/ebean/annotation/DbJson.java

@@ -0,0 +1,44 @@
+package io.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>
+ * <p>
+ * <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/io/ebean/annotation/DbJsonB.java

@@ -0,0 +1,43 @@
+package io.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>
+ * <p>
+ * <h3>Example:</h3>
+ * <pre>{@code
+ *
+ * // Store as JSONB on Postgres or Clob on other databases
+ * @DbJsonB
+ * Map<String,Object> content;
+ *
+ * }</pre>
+ * <p>
+ * <h3>Equivalent to:</h3>
+ * <pre>{@code
+ *
+ * // Store as JSONB on Postgres or Clob on other databases
+ * @DbJson(storage = DbJsonType.JSONB)
+ * Map<String,Object> content;
+ *
+ * }</pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DbJsonB {
+
+  /**
+   * For VARCHAR storage specify the column length.
+   */
+  int length() default 0;
+}

src/main/java/io/ebean/annotation/DbJsonType.java

@@ -0,0 +1,32 @@
+package io.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/io/ebean/annotation/DocCode.java

@@ -0,0 +1,32 @@
+package io.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/io/ebean/annotation/DocEmbedded.java

@@ -0,0 +1,36 @@
+package io.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/io/ebean/annotation/DocMapping.java

@@ -0,0 +1,24 @@
+package io.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/io/ebean/annotation/DocProperty.java

@@ -0,0 +1,110 @@
+package io.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/io/ebean/annotation/DocSortable.java

@@ -0,0 +1,34 @@
+package io.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/io/ebean/annotation/DocStore.java

@@ -0,0 +1,97 @@
+package io.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 "";
+
+  /**
+   * Set to false to disable the "_all" index.
+   */
+  boolean enableAll() default true;
+
+  /**
+   * Set the refresh interval for the index.
+   */
+  String refreshInterval() 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/io/ebean/annotation/DocStoreMode.java

@@ -0,0 +1,38 @@
+package io.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/io/ebean/annotation/Draft.java

@@ -0,0 +1,19 @@
+package io.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/io/ebean/annotation/DraftDirty.java

@@ -0,0 +1,20 @@
+package io.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/io/ebean/annotation/DraftOnly.java

@@ -0,0 +1,19 @@
+package io.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/io/ebean/annotation/DraftReset.java

@@ -0,0 +1,19 @@
+package io.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/io/ebean/annotation/Draftable.java

@@ -0,0 +1,29 @@
+package io.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/io/ebean/annotation/DraftableElement.java

@@ -0,0 +1,20 @@
+package io.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/io/ebean/annotation/EbeanDDL.java

@@ -0,0 +1,12 @@
+package io.ebean.annotation;
+
+import javax.validation.constraints.NotNull;
+
+/**
+ * special validation group for &#64;NotNull annotation to enforce <code>NOT NULL</code> generation on DDL.
+ * Normally if you put the {@link NotNull} annotation on a property, Ebean will only generate a
+ * <code>NOT NULL</code> in DDL if you do not change the validation-groups!
+ */
+public interface EbeanDDL {
+
+}

src/main/java/io/ebean/annotation/Encrypted.java

@@ -0,0 +1,24 @@
+package io.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/io/ebean/annotation/EnumValue.java

@@ -0,0 +1,47 @@
+package io.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/io/ebean/annotation/Expose.java

@@ -0,0 +1,28 @@
+package io.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/io/ebean/annotation/Formula.java

@@ -1,7 +1,8 @@
-package com.avaje.ebean.annotation;
+package io.ebean.annotation;
 
-import com.avaje.ebean.Query;
-import com.avaje.ebean.config.Platform;
+import io.ebean.Query;
+import io.ebean.FetchConfig;
+import io.ebean.Platform;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Repeatable;
@@ -22,7 +23,7 @@ import java.lang.annotation.Target;
  * 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)}.
+ * it via {@link Query#select(String)} or {@link Query#fetch(String, String, 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>

src/main/java/io/ebean/annotation/History.java

@@ -0,0 +1,19 @@
+package io.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/io/ebean/annotation/HistoryExclude.java

@@ -0,0 +1,25 @@
+package io.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/io/ebean/annotation/Index.java

@@ -0,0 +1,38 @@
+package io.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation for declaring an index.
+ *
+ * @author rvbiljouw
+ */
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(Indices.class)
+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.
+   * <p>
+   * Wnen placed on a field, and columnNames are specified, the field-column has to be included.
+   * You can use "${fa}" for alias
+   */
+  String[] columnNames() default {};
+
+}

src/main/java/io/ebean/annotation/Indices.java

@@ -0,0 +1,21 @@
+package io.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 multiple indices at class or field level.
+ *
+ * @author Roland Praml, FOCONIS AG
+ */
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Indices {
+
+  /**
+   * Array with {@link Index} definitions.
+   */
+  Index[] value() default {};
+}

src/main/java/io/ebean/annotation/JsonIgnore.java

@@ -0,0 +1,32 @@
+package io.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/io/ebean/annotation/PostSoftDelete.java

@@ -0,0 +1,15 @@
+package io.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a method as executing after a Soft Delete.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface PostSoftDelete {
+
+}