Ebean (avaje-ebeanorm 3.3.1 API)

java.lang.Object
- com.avaje.ebean.Ebean

```
public final class Ebean
extends Object
```
This Ebean object is effectively a singleton that holds a map of registered EbeanServers. It additionally provides a convenient way to use the 'default/primary' EbeanServer.
If you are using a Dependency Injection framework such as Spring or Guice you will probably NOT use this Ebean singleton object. Instead you will configure and construct EbeanServer instances using ServerConfig and EbeanServerFactory and inject those EbeanServer instances into your data access objects.

In documentation "Ebean singleton" refers to this object.
- There is one EbeanServer per Database (javax.sql.DataSource).
- EbeanServers can be 'registered' with the Ebean singleton (put into its map). Registered EbeanServer's can later be retrieved via getServer(String).
- One EbeanServer can be referred to as the 'default' EbeanServer. For convenience, the Ebean singleton (this object) provides methods such as find(Class) that proxy through to the 'default' EbeanServer. This can be useful for applications that use a single database.
For developer convenience Ebean has static methods that proxy through to the methods on the 'default' EbeanServer. These methods are provided for developers who are mostly using a single database. Many developers will be able to use the methods on Ebean rather than get a EbeanServer.

EbeanServers can be created and used without ever needing or using the Ebean singleton. Refer to ServerConfig.setRegister(boolean).

You can either programmatically create/register EbeanServers via EbeanServerFactory or they can automatically be created and registered when you first use the Ebean singleton. When EbeanServers are created automatically they are configured using information in the ebean.properties file.
```
 // fetch shipped orders (and also their customer)
 List<Order> list = Ebean.find(Order.class)
        .fetch("customer")
        .where() 
        .eq("status.code", Order.Status.SHIPPED) 
        .findList();
 
 // read/use the order list ... 
 for (Order order : list) { 
        Customer customer = order.getCustomer(); 
        ... 
 }
 
```
```
 // fetch order 10, modify and save 
 Order order = Ebean.find(Order.class, 10);
 
 OrderStatus shipped = Ebean.getReference(OrderStatus.class,"SHIPPED"); 
 order.setStatus(shipped);
 order.setShippedDate(shippedDate); 
 ...
 
 // implicitly creates a transaction and commits 
 Ebean.save(order);
 
```
When you have multiple databases and need access to a specific one the getServer(String) method provides access to the EbeanServer for that specific database.
```
 // Get access to the Human Resources EbeanServer/Database
 EbeanServer hrDb = Ebean.getServer("hr");
 
 
 // fetch contact 3 from the HR database 
 Contact contact = hrDb.find(Contact.class, 3);
 
 contact.setName("I'm going to change"); 
 ...
 
 // save the contact back to the HR database 
 hrDb.save(contact);
 
```

Method Summary

Methods
Modifier and Type	Method and Description
`static Transaction`	`beginTransaction()` Start a new explicit transaction.
`static Transaction`	`beginTransaction(TxIsolation isolation)` Start a transaction additionally specifying the isolation level.
`static void`	`commitTransaction()` Commit the current transaction.
`static CallableSql`	`createCallableSql(String sql)` Create a CallableSql to execute a given stored procedure.
`static <T> CsvReader<T>`	`createCsvReader(Class<T> beanType)` Create a CsvReader for a given beanType.
`static JsonContext`	`createJsonContext()` Create a JsonContext that will use the default configuration options.
`static <T> Query<T>`	`createNamedQuery(Class<T> beanType, String namedQuery)` Return a named Query that will have defined fetch paths, predicates etc.
`static SqlQuery`	`createNamedSqlQuery(String namedQuery)` Create a named sql query.
`static SqlUpdate`	`createNamedSqlUpdate(String namedQuery)` Create a named sql update.
`static <T> Update<T>`	`createNamedUpdate(Class<T> beanType, String namedUpdate)` Create a named orm update.
`static <T> Query<T>`	`createQuery(Class<T> beanType)` Create a query for a type of entity bean.
`static <T> Query<T>`	`createQuery(Class<T> beanType, String query)` Create a query using the query language.
`static SqlQuery`	`createSqlQuery(String sql)` Create a SqlQuery for executing native sql query statements.
`static SqlUpdate`	`createSqlUpdate(String sql)` Create a sql update for executing native dml statements.
`static <T> Update<T>`	`createUpdate(Class<T> beanType, String ormUpdate)` Create a orm update where you will supply the insert/update or delete statement (rather than using a named one that is already defined using the @NamedUpdates annotation).
`static Transaction`	`currentTransaction()` Returns the current transaction or null if there is no current transaction in scope.
`static void`	`delete(Class<?> beanType, Collection<?> ids)` Delete several beans given their type and id values.
`static int`	`delete(Class<?> beanType, Object id)` Delete the bean given its type and id.
`static int`	`delete(Collection<?> c)` Delete all the beans from a Collection.
`static int`	`delete(Iterator<?> it)` Delete all the beans from an Iterator.
`static void`	`delete(Object bean)` Delete the bean.
`static int`	`deleteManyToManyAssociations(Object ownerBean, String propertyName)` Delete the associations (from the intersection table) of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.
`static Map<String,ValuePair>`	`diff(Object a, Object b)` Return a map of the differences between two objects of the same type.
`static void`	`endTransaction()` If the current transaction has already been committed do nothing otherwise rollback the transaction.
`static int`	`execute(CallableSql callableSql)` For making calls to stored procedures.
`static int`	`execute(SqlUpdate sqlUpdate)` Execute a Sql Update Delete or Insert statement.
`static <T> T`	`execute(TxCallable<T> c)` Execute a TxCallable in a Transaction with the default scope.
`static void`	`execute(TxRunnable r)` Execute a TxRunnable in a Transaction with the default scope.
`static <T> T`	`execute(TxScope scope, TxCallable<T> c)` Execute a TxCallable in a Transaction with an explicit scope.
`static void`	`execute(TxScope scope, TxRunnable r)` Execute a TxRunnable in a Transaction with an explicit scope.
`static void`	`externalModification(String tableName, boolean inserts, boolean updates, boolean deletes)` Inform Ebean that tables have been modified externally.
`static <T> Filter<T>`	`filter(Class<T> beanType)` Create a filter for sorting and filtering lists of entities locally without going back to the database.
`static <T> Query<T>`	`find(Class<T> beanType)` Create a query for a type of entity bean.
`static <T> T`	`find(Class<T> beanType, Object id)` Find a bean using its unique id.
`static BackgroundExecutor`	`getBackgroundExecutor()` Return the BackgroundExecutor service for asynchronous processing of queries.
`static BeanState`	`getBeanState(Object bean)` Return the BeanState for a given entity bean.
`static ExpressionFactory`	`getExpressionFactory()` Return the ExpressionFactory from the default server.
`static <T> T`	`getReference(Class<T> beanType, Object id)` Get a reference object.
`static EbeanServer`	`getServer(String name)` Get the EbeanServer for a given DataSource.
`static ServerCacheManager`	`getServerCacheManager()` Return the manager of the server cache ("L2" cache).
`static Object`	`nextId(Class<?> beanType)` Return the next identity value for a given bean type.
`static void`	`refresh(Object bean)` Refresh the values of a bean.
`static void`	`refreshMany(Object bean, String manyPropertyName)` Refresh a 'many' property of a bean.
`protected static void`	`register(EbeanServer server, boolean isPrimaryServer)` Register the server with this Ebean singleton.
`static void`	`rollbackTransaction()` Rollback the current transaction.
`static void`	`runCacheWarming()` Run the cache warming queries on all bean types that have one defined for the default/primary EbeanServer.
`static void`	`runCacheWarming(Class<?> beanType)` Run the cache warming query for a specific bean type for the default/primary EbeanServer.
`static int`	`save(Collection<?> c)` Save all the beans from a Collection.
`static int`	`save(Iterator<?> iterator)` Save all the beans from an Iterator.
`static void`	`save(Object bean)` Either Insert or Update the bean depending on its state.
`static void`	`saveAssociation(Object ownerBean, String propertyName)` Save the associated collection or bean given the property name.
`static void`	`saveManyToManyAssociations(Object ownerBean, String propertyName)` Save the associations of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.
`static <T> void`	`sort(List<T> list, String sortByClause)` Sort the list using the sortByClause which can contain a comma delimited list of property names and keywords asc, desc, nullsHigh and nullsLow.
`static void`	`update(Object bean)` Force an update using the bean updating the non-null properties.
`static void`	`update(Object bean, Set<String> updateProps)` Force an update using the bean explicitly stating the properties to update.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getServer
```
public static EbeanServer getServer(String name)
```
    Get the EbeanServer for a given DataSource. If name is null this will return the 'default' EbeanServer.
    This is provided to access EbeanServer for databases other than the 'default' database. EbeanServer also provides more control over transactions and the ability to use transactions created externally to Ebean.
```
 // use the "hr" database
 EbeanServer hrDatabase = Ebean.getServer("hr");
 
 Person person = hrDatabase.find(Person.class, 10);
 
```
    Parameters:
    name - the name of the server, use null for the 'default server'
  - getExpressionFactory
```
public static ExpressionFactory getExpressionFactory()
```
    Return the ExpressionFactory from the default server.
    The ExpressionFactory is used internally by the query and ExpressionList to build the WHERE and HAVING clauses. Alternatively you can use the ExpressionFactory directly to create expressions to add to the query where clause.
    
    Alternatively you can use the Expr as a shortcut to the ExpressionFactory of the 'Default' EbeanServer.
    
    You generally need to the an ExpressionFactory (or Expr) to build an expression that uses OR like Expression e = Expr.or(..., ...);
  - register
```
protected static void register(EbeanServer server,
            boolean isPrimaryServer)
```
    Register the server with this Ebean singleton. Specify if the registered server is the primary/default server.
  - nextId
```
public static Object nextId(Class<?> beanType)
```
    Return the next identity value for a given bean type.
    This will only work when a IdGenerator is on this bean type such as a DB sequence or UUID.
    
    For DB's supporting getGeneratedKeys and sequences such as Oracle10 you do not need to use this method generally. It is made available for more complex cases where it is useful to get an ID prior to some processing.
  - beginTransaction
```
public static Transaction beginTransaction()
```
    Start a new explicit transaction.
    The transaction is stored in a ThreadLocal variable and typically you only need to use the returned Transaction IF you wish to do things like use batch mode, change the transaction isolation level, use savepoints or log comments to the transaction log.
    
    Example of using a transaction to span multiple calls to find(), save() etc.
```
 // start a transaction (stored in a ThreadLocal)
 Ebean.beginTransaction(); 
 try { 
        Order order = Ebean.find(Order.class,10); ...
 
        Ebean.save(order);
 
        Ebean.commitTransaction();
 
 } finally { 
        // rollback if we didn't commit 
        // i.e. an exception occurred before commitTransaction(). 
        Ebean.endTransaction(); 
 }
 
```
    If you want to externalise the transaction management then you should be able to do this via EbeanServer. Specifically with EbeanServer you can pass the transaction to the various find() and save() execute() methods. This gives you the ability to create the transactions yourself externally from Ebean and pass those transactions through to the various methods available on EbeanServer.
  - beginTransaction
```
public static Transaction beginTransaction(TxIsolation isolation)
```
    Start a transaction additionally specifying the isolation level.
    
    Parameters:
    isolation - the Transaction isolation level
  - currentTransaction
```
public static Transaction currentTransaction()
```
    Returns the current transaction or null if there is no current transaction in scope.
  - commitTransaction
```
public static void commitTransaction()
```
    Commit the current transaction.
  - rollbackTransaction
```
public static void rollbackTransaction()
```
    Rollback the current transaction.
  - endTransaction
```
public static void endTransaction()
```
    If the current transaction has already been committed do nothing otherwise rollback the transaction.
    Useful to put in a finally block to ensure the transaction is ended, rather than a rollbackTransaction() in each catch block.
    
    Code example:
```
 Ebean.beginTransaction();
 try {
   // do some fetching and or persisting
   // commit at the end Ebean.commitTransaction();
 
 } finally {
   // if commit didn't occur then rollback the transaction
   Ebean.endTransaction();
 }
 
```
  - diff
```
public static Map<String,ValuePair> diff(Object a,
                         Object b)
```
    Return a map of the differences between two objects of the same type.
    When null is passed in for b, then the 'OldValues' of a is used for the difference comparison.
  - save
```
public static void save(Object bean)
                 throws javax.persistence.OptimisticLockException
```
    Either Insert or Update the bean depending on its state.
    If there is no current transaction one will be created and committed for you automatically.
    
    Save can cascade along relationships. For this to happen you need to specify a cascade of CascadeType.ALL or CascadeType.PERSIST on the OneToMany, OneToOne or ManyToMany annotation.
    
    In this example below the details property has a CascadeType.ALL set so saving an order will also save all its details.
```
 public class Order { ...
        
        @OneToMany(cascade=CascadeType.ALL, mappedBy="order")
        @JoinColumn(name="order_id") 
        List<OrderDetail> details; 
        ... 
 }
 
```
    When a save cascades via a OneToMany or ManyToMany Ebean will automatically set the 'parent' object to the 'detail' object. In the example below in saving the order and cascade saving the order details the 'parent' order will be set against each order detail when it is saved.
    Throws:
    
    javax.persistence.OptimisticLockException
  - update
```
public static void update(Object bean)
```
    Force an update using the bean updating the non-null properties.
    You can use this method to FORCE an update to occur (even on a bean that has not been fetched but say built from JSON or XML). When save(Object) is used Ebean determines whether to use an insert or an update based on the state of the bean. Using this method will force an update to occur.
    
    It is expected that this method is most useful in stateless REST services or web applications where you have the values you wish to update but no existing bean.
    
    For updates against beans that have not been fetched (say built from JSON or XML) this will treat deleteMissingChildren=true and will delete any 'missing children'. Refer to EbeanServer.update(Object, Set, Transaction, boolean, boolean).
```
 
 Customer c = new Customer();
 c.setId(7);
 c.setName("ModifiedNameNoOCC");
 
 // generally you should set the version property
 // so that Optimistic Concurrency Checking is used.
 // If a version property is not set then no Optimistic
 // Concurrency Checking occurs for the update
 // c.setLastUpdate(lastUpdateTime);
 
 // by default the Non-null properties
 // are included in the update
 Ebean.update(c);
 
 
```
  - update
```
public static void update(Object bean,
          Set<String> updateProps)
```
    Force an update using the bean explicitly stating the properties to update.
    If you don't specify explicit properties to use in the update then the non-null properties are included in the update.
    
    For updates against beans that have not been fetched (say built from JSON or XML) this will treat deleteMissingChildren=true and will delete any 'missing children'. Refer to EbeanServer.update(Object, Set, Transaction, boolean, boolean).
    
    Parameters:
    bean - The bean holding the values to be included in the update.
    updateProps - the explicit set of properties to include in the update (can be null).
  - save
```
public static int save(Iterator<?> iterator)
                throws javax.persistence.OptimisticLockException
```
    Save all the beans from an Iterator.
    
    Throws:
    
    javax.persistence.OptimisticLockException
  - save
```
public static int save(Collection<?> c)
                throws javax.persistence.OptimisticLockException
```
    Save all the beans from a Collection.
    
    Throws:
    
    javax.persistence.OptimisticLockException
  - deleteManyToManyAssociations
```
public static int deleteManyToManyAssociations(Object ownerBean,
                               String propertyName)
```
    Delete the associations (from the intersection table) of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.
    Typically these deletions occur automatically when persisting a ManyToMany collection and this provides a way to invoke those deletions directly.
    
    Returns:
    the number of associations deleted (from the intersection table).
  - saveManyToManyAssociations
```
public static void saveManyToManyAssociations(Object ownerBean,
                              String propertyName)
```
    Save the associations of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.
    Typically the saving of these associations (inserting into the intersection table) occurs automatically when persisting a ManyToMany. This provides a way to invoke those insertions directly.
    
    You can use this when the collection is new and in this case all the entries in the collection are treated as additions are result in inserts into the intersection table.
  - saveAssociation
```
public static void saveAssociation(Object ownerBean,
                   String propertyName)
```
    Save the associated collection or bean given the property name.
    This is similar to performing a save cascade on a specific property manually/programmatically.
    
    Note that you can turn on/off cascading for a transaction via Transaction.setPersistCascade(boolean)
    
    Parameters:
    ownerBean - the bean instance holding the property we want to save
    propertyName - the property we want to save
  - delete
```
public static void delete(Object bean)
                   throws javax.persistence.OptimisticLockException
```
    Delete the bean.
    If there is no current transaction one will be created and committed for you automatically.
    
    Throws:
    
    javax.persistence.OptimisticLockException
  - delete
```
public static int delete(Class<?> beanType,
         Object id)
```
    Delete the bean given its type and id.
  - delete
```
public static void delete(Class<?> beanType,
          Collection<?> ids)
```
    Delete several beans given their type and id values.
  - delete
```
public static int delete(Iterator<?> it)
                  throws javax.persistence.OptimisticLockException
```
    Delete all the beans from an Iterator.
    
    Throws:
    
    javax.persistence.OptimisticLockException
  - delete
```
public static int delete(Collection<?> c)
                  throws javax.persistence.OptimisticLockException
```
    Delete all the beans from a Collection.
    
    Throws:
    
    javax.persistence.OptimisticLockException
  - refresh
```
public static void refresh(Object bean)
```
    Refresh the values of a bean.
    Note that this does not refresh any OneToMany or ManyToMany properties.
  - refreshMany
```
public static void refreshMany(Object bean,
               String manyPropertyName)
```
    Refresh a 'many' property of a bean.
```
 Order order = ...;
 ...
 // refresh the order details...
 Ebean.refreshMany(order, "details");
 
```
    Parameters:
    bean - the entity bean containing the List Set or Map to refresh.
    manyPropertyName - the property name of the List Set or Map to refresh.
  - getReference
```
public static <T> T getReference(Class<T> beanType,
                 Object id)
```
    Get a reference object.
    This is sometimes described as a proxy (with lazy loading).
```
 Product product = Ebean.getReference(Product.class, 1);
 
 // You can get the id without causing a fetch/lazy load
 Integer productId = product.getId();
 
 // If you try to get any other property a fetch/lazy loading will occur
 // This will cause a query to execute...
 String name = product.getName();
 
```
    Parameters:
    beanType - the type of entity bean
    id - the id value
  - sort
```
public static <T> void sort(List<T> list,
            String sortByClause)
```
    Sort the list using the sortByClause which can contain a comma delimited list of property names and keywords asc, desc, nullsHigh and nullsLow.
    - asc - ascending order (which is the default)
    - desc - Descending order
    - nullsHigh - Treat null values as high/large values (which is the default)
    - nullsLow- Treat null values as low/very small values
    If you leave off any keywords the defaults are ascending order and treating nulls as high values.
    
    Note that the sorting uses a Comparator and Collections.sort(); and does not invoke a DB query.
```
 
 // find orders and their customers
 List<Order> list = Ebean.find(Order.class)
     .fetch("customer")
     .orderBy("id")
     .findList();
 
 // sort by customer name ascending, then by order shipDate
 // ... then by the order status descending
 Ebean.sort(list, "customer.name, shipDate, status desc");
 
 // sort by customer name descending (with nulls low)
 // ... then by the order id
 Ebean.sort(list, "customer.name desc nullsLow, id");
 
 
```
    Parameters:
    list - the list of entity beans
    sortByClause - the properties to sort the list by
  - find
```
public static <T> T find(Class<T> beanType,
         Object id)
```
    Find a bean using its unique id. This will not use caching.
```
 // Fetch order 1
 Order order = Ebean.find(Order.class, 1);
 
```
    If you want more control over the query then you can use createQuery() and Query.findUnique();
```
 // ... additionally fetching customer, customer shipping address,
 // order details, and the product associated with each order detail.
 // note: only product id and name is fetch (its a "partial object").
 // note: all other objects use "*" and have all their properties fetched.
 
 Query<Order> query = Ebean.createQuery(Order.class);
 query.setId(1);
 query.fetch("customer");
 query.fetch("customer.shippingAddress");
 query.fetch("details");
 
 // fetch associated products but only fetch their product id and name
 query.fetch("details.product", "name");
 
 // traverse the object graph...
 
 Order order = query.findUnique();
 Customer customer = order.getCustomer();
 Address shippingAddress = customer.getShippingAddress();
 List<OrderDetail> details = order.getDetails();
 OrderDetail detail0 = details.get(0);
 Product product = detail0.getProduct();
 String productName = product.getName();
 
```
    Parameters:
    beanType - the type of entity bean to fetch
    id - the id value
  - createSqlQuery
```
public static SqlQuery createSqlQuery(String sql)
```
    Create a SqlQuery for executing native sql query statements.
    Note that you can use raw SQL with entity beans, refer to the SqlSelect annotation for examples.
  - createNamedSqlQuery
```
public static SqlQuery createNamedSqlQuery(String namedQuery)
```
    Create a named sql query.
    The query statement will be defined in a deployment orm xml file.
    
    Parameters:
    namedQuery - the name of the query
  - createSqlUpdate
```
public static SqlUpdate createSqlUpdate(String sql)
```
    Create a sql update for executing native dml statements.
    Use this to execute a Insert Update or Delete statement. The statement will be native to the database and contain database table and column names.
    
    See SqlUpdate for example usage.
    
    Where possible it would be expected practice to put the statement in a orm xml file (named update) and use createNamedSqlUpdate(String) .
  - createCallableSql
```
public static CallableSql createCallableSql(String sql)
```
    Create a CallableSql to execute a given stored procedure.
    
    See Also:
    CallableSql
  - createNamedSqlUpdate
```
public static SqlUpdate createNamedSqlUpdate(String namedQuery)
```
    Create a named sql update.
    The statement (an Insert Update or Delete statement) will be defined in a deployment orm xml file.
```
 // Use a namedQuery
 UpdateSql update = Ebean.createNamedSqlUpdate("update.topic.count");
 
 update.setParameter("count", 1);
 update.setParameter("topicId", 50);
 
 int modifiedCount = update.execute();
 
```
  - createNamedQuery
```
public static <T> Query<T> createNamedQuery(Class<T> beanType,
                            String namedQuery)
```
    Return a named Query that will have defined fetch paths, predicates etc.
    The query is created from a statement that will be defined in a deployment orm xml file or NamedQuery annotations. The query will typically already define fetch paths, predicates, order by clauses etc so often you will just need to bind required parameters and then execute the query.
```
 // example
 Query<Order> query = Ebean.createNamedQuery(Order.class, "new.for.customer");
 query.setParameter("customerId", 23);
 List<Order> newOrders = query.findList();
 
```
    Parameters:
    beanType - the class of entity to be fetched
    namedQuery - the name of the query
  - createQuery
```
public static <T> Query<T> createQuery(Class<T> beanType,
                       String query)
```
    Create a query using the query language.
    Note that you are allowed to add additional clauses using where() as well as use fetch() and setOrderBy() after the query has been created.
    
    Note that this method signature used to map to named queries and that has moved to createNamedQuery(Class, String).
```
 
 String q = "find order fetch details where status = :st";
 
 List<Order> newOrders = Ebean.createQuery(Order.class, q)
     .setParameter("st", Order.Status.NEW)
     .findList();
 
```
    Parameters:
    query - the object query
  - createNamedUpdate
```
public static <T> Update<T> createNamedUpdate(Class<T> beanType,
                              String namedUpdate)
```
    Create a named orm update. The update statement is specified via the NamedUpdate annotation.
    The orm update differs from the SqlUpdate in that it uses the bean name and bean property names rather than table and column names.
    
    Note that named update statements can be specified in raw sql (with column and table names) or using bean name and bean property names. This can be specified with the isSql flag.
    
    Example named updates:
```
 package app.data;
 
 import ...
 
 @NamedUpdates(value = { 
        @NamedUpdate( name = "setTitle", 
                isSql = false, 
                notifyCache = false, 
                update = "update topic set title = :title, postCount = :postCount where id = :id"), 
        @NamedUpdate( name = "setPostCount",
                notifyCache = false,
                update = "update f_topic set post_count = :postCount where id = :id"), 
        @NamedUpdate( name = "incrementPostCount", 
                notifyCache = false, 
                isSql = false,
                update = "update Topic set postCount = postCount + 1 where id = :id") }) 
 @Entity 
 @Table(name = "f_topic") 
 public class Topic { ...
 
```
    Example using a named update:
```
 Update<Topic> update = Ebean.createNamedUpdate(Topic.class, "setPostCount");
 update.setParameter("postCount", 10);
 update.setParameter("id", 3);
 
 int rows = update.execute();
 System.out.println("rows updated: " + rows);
 
```
  - createUpdate
```
public static <T> Update<T> createUpdate(Class<T> beanType,
                         String ormUpdate)
```
    Create a orm update where you will supply the insert/update or delete statement (rather than using a named one that is already defined using the @NamedUpdates annotation).
    The orm update differs from the sql update in that it you can use the bean name and bean property names rather than table and column names.
    
    An example:
```
 
 // The bean name and properties - "topic","postCount" and "id"
 
 // will be converted into their associated table and column names
 String updStatement = "update topic set postCount = :pc where id = :id";
 
 Update<Topic> update = Ebean.createUpdate(Topic.class, updStatement);
 
 update.set("pc", 9);
 update.set("id", 3);
 
 int rows = update.execute();
 System.out.println("rows updated:" + rows);
 
```
  - createCsvReader
```
public static <T> CsvReader<T> createCsvReader(Class<T> beanType)
```
    Create a CsvReader for a given beanType.
  - createQuery
```
public static <T> Query<T> createQuery(Class<T> beanType)
```
    Create a query for a type of entity bean.
    You can use the methods on the Query object to specify fetch paths, predicates, order by, limits etc.
    
    You then use findList(), findSet(), findMap() and findUnique() to execute the query and return the collection or bean.
    
    Note that a query executed by Query.findList() Query.findSet() etc will execute against the same EbeanServer from which is was created.
```
 // Find order 2 additionally fetching the customer, details and details.product
 // name.
 
 Query<Order> query = Ebean.createQuery(Order.class);
 query.fetch("customer");
 query.fetch("details");
 query.fetch("detail.product", "name");
 query.setId(2);
 
 Order order = query.findUnique();
 
 // Find order 2 additionally fetching the customer, details and details.product
 // name.
 // Note: same query as above but using the query language
 // Note: using a named query would be preferred practice
 
 String oql = "find order fetch customer fetch details fetch details.product (name) where id = :orderId ";
 
 Query<Order> query = Ebean.createQuery(Order.class);
 query.setQuery(oql);
 query.setParameter("orderId", 2);
 
 Order order = query.findUnique();
 
 // Using a named query
 Query<Order> query = Ebean.createQuery(Order.class, "with.details");
 query.setParameter("orderId", 2);
 
 Order order = query.findUnique();
 
 
```
    Parameters:
    beanType - the class of entity to be fetched
    
    Returns:
    A ORM Query object for this beanType
  - find
```
public static <T> Query<T> find(Class<T> beanType)
```
    Create a query for a type of entity bean.
    This is actually the same as createQuery(Class). The reason it exists is that people used to JPA will probably be looking for a createQuery method (the same as entityManager).
    
    Parameters:
    beanType - the type of entity bean to find
    
    Returns:
    A ORM Query object for this beanType
  - filter
```
public static <T> Filter<T> filter(Class<T> beanType)
```
    Create a filter for sorting and filtering lists of entities locally without going back to the database.
    This produces and returns a new list with the sort and filters applied.
    
    Refer to Filter for an example of its use.
  - execute
```
public static int execute(SqlUpdate sqlUpdate)
```
    Execute a Sql Update Delete or Insert statement. This returns the number of rows that where updated, deleted or inserted. If is executed in batch then this returns -1. You can get the actual rowCount after commit() from updateSql.getRowCount().
    If you wish to execute a Sql Select natively then you should use the FindByNativeSql object.
    
    Note that the table modification information is automatically deduced and you do not need to call the Ebean.externalModification() method when you use this method.
    
    Example:
```
 // example that uses 'named' parameters 
 String s = "UPDATE f_topic set post_count = :count where id = :id"
 
 SqlUpdate update = Ebean.createSqlUpdate(s);
 
 update.setParameter("id", 1);
 update.setParameter("count", 50);
 
 int modifiedCount = Ebean.execute(update);
 
 String msg = "There where " + modifiedCount + "rows updated";
 
```
    Parameters:
    sqlUpdate - the update sql potentially with bind values
    
    Returns:
    the number of rows updated or deleted. -1 if executed in batch.
    See Also:
    SqlUpdate, CallableSql, execute(CallableSql)
  - execute
```
public static int execute(CallableSql callableSql)
```
    For making calls to stored procedures.
    Example:
```
 String sql = "{call sp_order_modify(?,?,?)}";
 
 CallableSql cs = Ebean.createCallableSql(sql);
 cs.setParameter(1, 27);
 cs.setParameter(2, "SHIPPED");
 cs.registerOut(3, Types.INTEGER);
 
 Ebean.execute(cs);
 
 // read the out parameter
 Integer returnValue = (Integer) cs.getObject(3);
 
```
    See Also:
    CallableSql, execute(SqlUpdate)
  - execute
```
public static void execute(TxScope scope,
           TxRunnable r)
```
    Execute a TxRunnable in a Transaction with an explicit scope.
    The scope can control the transaction type, isolation and rollback semantics.
```
 // set specific transactional scope settings 
 TxScope scope = TxScope.requiresNew().setIsolation(TxIsolation.SERIALIZABLE);
 
 Ebean.execute(scope, new TxRunnable() { 
        public void run() { 
                User u1 = Ebean.find(User.class, 1); 
                ...
 
        } 
 });
 
```
  - execute
```
public static void execute(TxRunnable r)
```
    Execute a TxRunnable in a Transaction with the default scope.
    The default scope runs with REQUIRED and by default will rollback on any exception (checked or runtime).
```
 Ebean.execute(new TxRunnable() {
   public void run() {
     User u1 = Ebean.find(User.class, 1);
     User u2 = Ebean.find(User.class, 2);
 
     u1.setName("u1 mod");
     u2.setName("u2 mod");
 
     Ebean.save(u1);
     Ebean.save(u2);
   }
 });
 
```
  - execute
```
public static <T> T execute(TxScope scope,
            TxCallable<T> c)
```
    Execute a TxCallable in a Transaction with an explicit scope.
    The scope can control the transaction type, isolation and rollback semantics.
```
 // set specific transactional scope settings 
 TxScope scope = TxScope.requiresNew().setIsolation(TxIsolation.SERIALIZABLE);
 
 Ebean.execute(scope, new TxCallable<String>() {
        public String call() { 
                User u1 = Ebean.find(User.class, 1); 
                ...
                return u1.getEmail(); 
        } 
 });
 
```
  - execute
```
public static <T> T execute(TxCallable<T> c)
```
    Execute a TxCallable in a Transaction with the default scope.
    The default scope runs with REQUIRED and by default will rollback on any exception (checked or runtime).
    
    This is basically the same as TxRunnable except that it returns an Object (and you specify the return type via generics).
```
 Ebean.execute(new TxCallable<String>() {
   public String call() {
     User u1 = Ebean.find(User.class, 1);
     User u2 = Ebean.find(User.class, 2);
 
     u1.setName("u1 mod");
     u2.setName("u2 mod");
 
     Ebean.save(u1);
     Ebean.save(u2);
 
     return u1.getEmail();
   }
 });
 
```
  - externalModification
```
public static void externalModification(String tableName,
                        boolean inserts,
                        boolean updates,
                        boolean deletes)
```
    Inform Ebean that tables have been modified externally. These could be the result of from calling a stored procedure, other JDBC calls or external programs including other frameworks.
    If you use Ebean.execute(UpdateSql) then the table modification information is automatically deduced and you do not need to call this method yourself.
    
    This information is used to invalidate objects out of the cache and potentially text indexes. This information is also automatically broadcast across the cluster.
    
    If there is a transaction then this information is placed into the current transactions event information. When the transaction is commited this information is registered (with the transaction manager). If this transaction is rolled back then none of the transaction event information registers including the information you put in via this method.
    
    If there is NO current transaction when you call this method then this information is registered immediately (with the transaction manager).
    
    Parameters:
    tableName - the name of the table that was modified
    inserts - true if rows where inserted into the table
    updates - true if rows on the table where updated
    deletes - true if rows on the table where deleted
  - getBeanState
```
public static BeanState getBeanState(Object bean)
```
    Return the BeanState for a given entity bean.
    This will return null if the bean is not an enhanced (or subclassed) entity bean.
  - getServerCacheManager
```
public static ServerCacheManager getServerCacheManager()
```
    Return the manager of the server cache ("L2" cache).
  - getBackgroundExecutor
```
public static BackgroundExecutor getBackgroundExecutor()
```
    Return the BackgroundExecutor service for asynchronous processing of queries.
  - runCacheWarming
```
public static void runCacheWarming()
```
    Run the cache warming queries on all bean types that have one defined for the default/primary EbeanServer.
    A cache warming query can be defined via CacheStrategy.
  - runCacheWarming
```
public static void runCacheWarming(Class<?> beanType)
```
    Run the cache warming query for a specific bean type for the default/primary EbeanServer.
    A cache warming query can be defined via CacheStrategy.
  - createJsonContext
```
public static JsonContext createJsonContext()
```
    Create a JsonContext that will use the default configuration options.

Class Ebean

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getServer

getExpressionFactory

register

nextId

beginTransaction

beginTransaction

currentTransaction

commitTransaction

rollbackTransaction

endTransaction

diff

save

update

update

save

save

deleteManyToManyAssociations

saveManyToManyAssociations

saveAssociation

delete

delete

delete

delete

delete

refresh

refreshMany

getReference

sort

find

createSqlQuery

createNamedSqlQuery

createSqlUpdate

createCallableSql

createNamedSqlUpdate

createNamedQuery

createQuery

createNamedUpdate

createUpdate

createCsvReader

createQuery

find

filter

execute

execute

execute

execute

execute

execute

externalModification

getBeanState

getServerCacheManager

getBackgroundExecutor

runCacheWarming

runCacheWarming

createJsonContext