com.avaje.ebean

Interface EbeanServer

All Known Subinterfaces:

SpiEbeanServer

All Known Implementing Classes:

DefaultServer

public interface EbeanServer

Provides the API for fetching and saving beans to a particular DataSource.

Registration with the Ebean Singleton:
When a EbeanServer is constructed it can be registered with the Ebean singleton (see ServerConfig.setRegister(boolean)). The Ebean singleton is essentially a map of EbeanServer's that have been registered with it. The EbeanServer can then be retrieved later via Ebean.getServer(String).

The 'default' EbeanServer
One EbeanServer can be designated as the 'default' or 'primary' EbeanServer (see ServerConfig.setDefaultServer(boolean). Many methods on Ebean such as Ebean.find(Class) etc are actually just a convenient way to call methods on the 'default/primary' EbeanServer. This is handy for applications that use a single DataSource.

There is one EbeanServer per Database (javax.sql.DataSource). One EbeanServer is referred to as the 'default' server and that is the one that Ebean methods such as Ebean.find(Class) use.

Constructing a EbeanServer
EbeanServer's are constructed by the EbeanServerFactory. They can be created programmatically via EbeanServerFactory.create(ServerConfig) or they can be automatically constructed on demand using configuration information in the ebean.properties file.

Example: Get a EbeanServer

 // Get access to the Human Resources EbeanServer/Database
 EbeanServer hrServer = Ebean.getServer("HR");
 
 
 // fetch contact 3 from the HR database Contact contact =
 hrServer.find(Contact.class, new Integer(3));
 
 contact.setStatus("INACTIVE"); ...
 
 // save the contact back to the HR database hrServer.save(contact);
 

EbeanServer has more API than Ebean
EbeanServer provides additional API compared with Ebean. For example it provides more control over the use of Transactions that is not available in the Ebean API.

External Transactions: If you wanted to use transactions created externally to eBean then EbeanServer provides additional methods where you can explicitly pass a transaction (that can be created externally).

Bypass ThreadLocal Mechanism: If you want to bypass the built in ThreadLocal transaction management you can use the createTransaction() method. Example: a single thread requires more than one transaction.

See Also:

Ebean, EbeanServerFactory, ServerConfig

Method Summary

Methods

Modifier and Type	Method and Description
Transaction	beginTransaction() Start a new transaction putting it into a ThreadLocal.
Transaction	beginTransaction(TxIsolation isolation) Start a transaction additionally specifying the isolation level.
void	commitTransaction() Commit the current transaction.
CallableSql	createCallableSql(String callableSql) Create a CallableSql to execute a given stored procedure.
<T> CsvReader<T>	createCsvReader(Class<T> beanType) Create a CsvReader for a given beanType.
<T> T	createEntityBean(Class<T> type) Create a new instance of T that is an EntityBean (for subclassing).
JsonContext	createJsonContext() Create a JsonContext that will use the default configuration options.
<T> Query<T>	createNamedQuery(Class<T> beanType, String namedQuery) Create a named query for an entity bean (refer Ebean.createQuery(Class, String))
SqlQuery	createNamedSqlQuery(String namedQuery) Create a named sql query (refer Ebean.createNamedSqlQuery(String) ).
SqlUpdate	createNamedSqlUpdate(String namedQuery) Create a named sql update (refer Ebean.createNamedSqlUpdate(String) ).
<T> Update<T>	createNamedUpdate(Class<T> beanType, String namedUpdate) Create a named update for an entity bean (refer Ebean.createNamedUpdate(Class, String)).
<T> Query<T>	createQuery(Class<T> beanType) Create a query for an entity bean (refer Ebean.createQuery(Class) ).
<T> Query<T>	createQuery(Class<T> beanType, String query) Create a query using the query language.
SqlQuery	createSqlQuery(String sql) Create a sql query for executing native sql query statements (refer Ebean.createSqlQuery(String)).
SqlUpdate	createSqlUpdate(String sql) Create a sql update for executing native dml statements (refer Ebean.createSqlUpdate(String)).
Transaction	createTransaction() Create a new transaction that is not held in TransactionThreadLocal.
Transaction	createTransaction(TxIsolation isolation) Create a new transaction additionally specifying the isolation level.
<T> Update<T>	createUpdate(Class<T> beanType, String ormUpdate) Create a update for an entity bean where you will manually specify the insert update or delete statement.
Transaction	currentTransaction() Returns the current transaction or null if there is no current transaction in scope.
void	delete(Class<?> beanType, Collection<?> ids) Delete several beans given their type and id values.
void	delete(Class<?> beanType, Collection<?> ids, Transaction t) Delete several beans given their type and id values with an explicit transaction.
int	delete(Class<?> beanType, Object id) Delete the bean given its type and id.
int	delete(Class<?> beanType, Object id, Transaction t) Delete the bean given its type and id with an explicit transaction.
int	delete(Collection<?> c) Delete all the beans in the collection.
int	delete(Iterator<?> it) Delete all the beans from an Iterator.
int	delete(Iterator<?> it, Transaction t) Delete all the beans from an iterator.
void	delete(Object bean) Delete the bean.
void	delete(Object bean, Transaction t) Delete the bean with an explicit transaction.
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.
int	deleteManyToManyAssociations(Object ownerBean, String propertyName, Transaction t) Delete the associations (from the intersection table) of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.
Map<String,ValuePair>	diff(Object a, Object b) Return a map of the differences between two objects of the same type.
void	endTransaction() If the current transaction has already been committed do nothing otherwise rollback the transaction.
int	execute(CallableSql callableSql) Call a stored procedure.
int	execute(CallableSql callableSql, Transaction t) Execute explicitly passing a transaction.
int	execute(SqlUpdate updSql) Execute a SQL Update Delete or Insert statement using the current transaction.
int	execute(SqlUpdate updSql, Transaction t) Execute explicitly passing a transaction.
<T> T	execute(TxCallable<T> c) Execute a TxCallable in a Transaction with the default scope.
void	execute(TxRunnable r) Execute a TxRunnable in a Transaction with the default scope.
<T> T	execute(TxScope scope, TxCallable<T> c) Execute a TxCallable in a Transaction with an explicit scope.
void	execute(TxScope scope, TxRunnable r) Execute a TxRunnable in a Transaction with an explicit scope.
int	execute(Update<?> update) Execute a ORM insert update or delete statement using the current transaction.
int	execute(Update<?> update, Transaction t) Execute a ORM insert update or delete statement with an explicit transaction.
void	externalModification(String tableName, boolean inserted, boolean updated, boolean deleted) Process committed changes from another framework.
<T> Filter<T>	filter(Class<T> beanType) Create a filter for filtering lists of entity beans.
<T> Query<T>	find(Class<T> beanType) Create a query for a type of entity bean (the same as createQuery(Class)).
<T> T	find(Class<T> beanType, Object uid) Find a bean using its unique id.
<T> T	find(Class<T> beanType, Object uid, Transaction transaction) Find a entity bean with an explicit transaction.
<T> FutureIds<T>	findFutureIds(Query<T> query, Transaction t) Execute find Id's query in a background thread.
<T> FutureList<T>	findFutureList(Query<T> query, Transaction t) Execute find list query in a background thread.
SqlFutureList	findFutureList(SqlQuery query, Transaction t) Execute find list SQL query in a background thread.
<T> FutureRowCount<T>	findFutureRowCount(Query<T> query, Transaction t) Execute find row count query in a background thread.
<T> List<Object>	findIds(Query<T> query, Transaction t) Return the Id values of the query as a List.
<T> QueryIterator<T>	findIterate(Query<T> query, Transaction t) Return a QueryIterator for the query.
<T> List<T>	findList(Query<T> query, Transaction transaction) Execute a query returning a list of beans.
List<SqlRow>	findList(SqlQuery query, Transaction transaction) Execute the sql query returning a list of MapBean.
<T> Map<?,T>	findMap(Query<T> query, Transaction transaction) Execute the query returning the entity beans in a Map.
Map<?,SqlRow>	findMap(SqlQuery query, Transaction transaction) Execute the sql query returning a map of MapBean.
<T> PagingList<T>	findPagingList(Query<T> query, Transaction t, int pageSize) Find using a PagingList with explicit transaction and pageSize.
<T> int	findRowCount(Query<T> query, Transaction transaction) Return the number of 'top level' or 'root' entities this query should return.
<T> Set<T>	findSet(Query<T> query, Transaction transaction) Execute the query returning a set of entity beans.
Set<SqlRow>	findSet(SqlQuery query, Transaction transaction) Execute the sql query returning a set of MapBean.
<T> T	findUnique(Query<T> query, Transaction transaction) Execute the query returning at most one entity bean.
SqlRow	findUnique(SqlQuery query, Transaction transaction) Execute the sql query returning a single MapBean or null.
<T> void	findVisit(Query<T> query, QueryResultVisitor<T> visitor, Transaction t) Execute the query visiting the results.
AdminAutofetch	getAdminAutofetch() Return the AdminAutofetch which is used to control and configure the Autofetch service at runtime.
BackgroundExecutor	getBackgroundExecutor() Return the BackgroundExecutor service for asynchronous processing of queries.
Object	getBeanId(Object bean) Return the value of the Id property for a given bean.
BeanState	getBeanState(Object bean) Return the BeanState for a given entity bean.
ExpressionFactory	getExpressionFactory() Return the ExpressionFactory for this server.
MetaInfoManager	getMetaInfoManager() Return the MetaInfoManager which is used to get meta data from the EbeanServer such as query execution statistics.
String	getName() Return the name.
<T> T	getReference(Class<T> beanType, Object uid) Get a reference Object (see Ebean.getReference(Class, Object).
ServerCacheManager	getServerCacheManager() Return the manager of the server cache ("L2" cache).
void	insert(Object bean) Force the bean to be saved with an explicit insert.
void	insert(Object bean, Transaction t) Force the bean to be saved with an explicit insert.
Object	nextId(Class<?> beanType) Return the next unique identity value for a given bean type.
void	refresh(Object bean) Refresh the values of a bean.
void	refreshMany(Object bean, String propertyName) Refresh a many property of an entity bean.
void	rollbackTransaction() Rollback the current transaction.
void	runCacheWarming() Run the cache warming queries on all bean types that have one defined.
void	runCacheWarming(Class<?> beanType) Run the cache warming query for a specific bean type.
int	save(Collection<?> it) Save all the beans in the collection.
int	save(Iterator<?> it) Save all the beans in the iterator.
int	save(Iterator<?> it, Transaction t) Save all the beans in the iterator with an explicit transaction.
void	save(Object bean) Persist the bean by either performing an insert or update.
void	save(Object bean, Transaction t) Insert or update a bean with an explicit transaction.
void	saveAssociation(Object ownerBean, String propertyName) Save the associated collection or bean given the property name.
void	saveAssociation(Object ownerBean, String propertyName, Transaction t) Save the associated collection or bean given the property name with a specific transaction.
void	saveManyToManyAssociations(Object ownerBean, String propertyName) Save the associations of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.
void	saveManyToManyAssociations(Object ownerBean, String propertyName, Transaction t) Save the associations of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.
void	shutdown(boolean shutdownDataSource, boolean deregisterDriver) Shutdown the EbeanServer.
<T> void	sort(List<T> list, String sortByClause) Sort the list using the sortByClause.
void	update(Object bean) Force an update using the bean.
void	update(Object bean, Set<String> updateProps) Force an update using the bean explicitly stating the properties to update.
void	update(Object bean, Set<String> updateProps, Transaction t) Force an update of the specified properties of the bean with an explicit transaction.
void	update(Object bean, Set<String> updateProps, Transaction t, boolean deleteMissingChildren, boolean updateNullProperties) Force an update additionally specifying whether to 'deleteMissingChildren' when the update cascades to a OneToMany or ManyToMany.
void	update(Object bean, Transaction t) Force an update of the non-null properties of the bean with an explicit transaction.

Method Detail

shutdown

void shutdown(boolean shutdownDataSource,
            boolean deregisterDriver)

Shutdown the EbeanServer.

If the under underlying DataSource is the EbeanORM implementation then you also have the option of shutting down the DataSource and deregistering the JDBC driver.

Parameters:

shutdownDataSource - if true then shutdown the underlying DataSource if it is the EbeanORM DataSource implementation.

deregisterDriver - if true then deregister the JDBC driver if it is the EbeanORM DataSource implementation.

getAdminAutofetch

AdminAutofetch getAdminAutofetch()

Return the AdminAutofetch which is used to control and configure the Autofetch service at runtime.

getName

String getName()

Return the name. This is used with Ebean.getServer(String) to get a EbeanServer that was registered with the Ebean singleton.

getExpressionFactory

ExpressionFactory getExpressionFactory()

Return the ExpressionFactory for this server.

getMetaInfoManager

MetaInfoManager getMetaInfoManager()

Return the MetaInfoManager which is used to get meta data from the EbeanServer such as query execution statistics.

getBeanState

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.

getBeanId

Object getBeanId(Object bean)

Return the value of the Id property for a given bean.

diff

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.

createEntityBean

<T> T createEntityBean(Class<T> type)

Create a new instance of T that is an EntityBean (for subclassing).

Note that if you are using enhancement (rather than subclassing) then you do not need to use this method and just new up a bean.

Potentially useful when using subclassing and you wish to programmatically load a entity bean . Otherwise this method is generally not required.

createCsvReader

<T> CsvReader<T> createCsvReader(Class<T> beanType)

Create a CsvReader for a given beanType.

createNamedQuery

<T> Query<T> createNamedQuery(Class<T> beanType,
                            String namedQuery)

Create a named query for an entity bean (refer Ebean.createQuery(Class, String))

The query statement will be defined in a deployment orm xml file.

See Also:

Ebean.createQuery(Class, String)

createQuery

<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).

  EbeanServer ebeanServer = ... ;
  String q = "find order fetch details where status = :st";
  
  List<Order> newOrders 
        = ebeanServer.createQuery(Order.class, q)
             .setParameter("st", Order.Status.NEW)
             .findList();
 

Parameters:

query - the object query

createQuery

<T> Query<T> createQuery(Class<T> beanType)

Create a query for an entity bean (refer Ebean.createQuery(Class) ).

See Also:

Ebean.createQuery(Class)

find

<T> Query<T> find(Class<T> beanType)

Create a query for a type of entity bean (the same as createQuery(Class)).

nextId

Object nextId(Class<?> beanType)

Return the next unique identity value for a given bean type.

This will only work when a IdGenerator is on the bean such as for beans that use 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.

filter

<T> Filter<T> filter(Class<T> beanType)

Create a filter for filtering lists of entity beans.

sort

<T> void sort(List<T> list,
            String sortByClause)

Sort the list using the sortByClause.

Parameters:

list - the list of entity beans

sortByClause - the properties to sort the list by

See Also:

Ebean.sort(List, String)

createNamedUpdate

<T> Update<T> createNamedUpdate(Class<T> beanType,
                              String namedUpdate)

Create a named update for an entity bean (refer Ebean.createNamedUpdate(Class, String)).

createUpdate

<T> Update<T> createUpdate(Class<T> beanType,
                         String ormUpdate)

Create a update for an entity bean where you will manually specify the insert update or delete statement.

createSqlQuery

SqlQuery createSqlQuery(String sql)

Create a sql query for executing native sql query statements (refer Ebean.createSqlQuery(String)).

See Also:

Ebean.createSqlQuery(String)

createNamedSqlQuery

SqlQuery createNamedSqlQuery(String namedQuery)

Create a named sql query (refer Ebean.createNamedSqlQuery(String) ).

The query statement will be defined in a deployment orm xml file.

See Also:

Ebean.createNamedSqlQuery(String)

createSqlUpdate

SqlUpdate createSqlUpdate(String sql)

Create a sql update for executing native dml statements (refer Ebean.createSqlUpdate(String)).

See Also:

Ebean.createSqlUpdate(String)

createCallableSql

CallableSql createCallableSql(String callableSql)

Create a CallableSql to execute a given stored procedure.

createNamedSqlUpdate

SqlUpdate createNamedSqlUpdate(String namedQuery)

Create a named sql update (refer Ebean.createNamedSqlUpdate(String) ).

The statement (an Insert Update or Delete statement) will be defined in a deployment orm xml file.

See Also:

Ebean.createNamedSqlUpdate(String)

createTransaction

Transaction createTransaction()

Create a new transaction that is not held in TransactionThreadLocal.

You will want to do this if you want multiple Transactions in a single thread or generally use transactions outside of the TransactionThreadLocal management.

createTransaction

Transaction createTransaction(TxIsolation isolation)

Create a new transaction additionally specifying the isolation level.

Note that this transaction is NOT stored in a thread local.

beginTransaction

Transaction beginTransaction()

Start a new transaction putting it into a ThreadLocal.

See Also:

Ebean.beginTransaction()

beginTransaction

Transaction beginTransaction(TxIsolation isolation)

Start a transaction additionally specifying the isolation level.

currentTransaction

Transaction currentTransaction()

Returns the current transaction or null if there is no current transaction in scope.

commitTransaction

void commitTransaction()

Commit the current transaction.

See Also:

Ebean.commitTransaction()

rollbackTransaction

void rollbackTransaction()

Rollback the current transaction.

See Also:

Ebean.rollbackTransaction()

endTransaction

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

See Also:

Ebean.endTransaction()

refresh

void refresh(Object bean)

Refresh the values of a bean.

Note that this does not refresh any OneToMany or ManyToMany properties.

See Also:

Ebean.refresh(Object)

refreshMany

void refreshMany(Object bean,
               String propertyName)

Refresh a many property of an entity bean.

Parameters:

bean - the entity bean containing the 'many' property

propertyName - the 'many' property to be refreshed

See Also:

Ebean.refreshMany(Object, String)

find

<T> T find(Class<T> beanType,
         Object uid)

Find a bean using its unique id.

See Also:

Ebean.find(Class, Object)

getReference

<T> T getReference(Class<T> beanType,
                 Object uid)

Get a reference Object (see Ebean.getReference(Class, Object).

This will not perform a query against the database.

See Also:

Ebean.getReference(Class, Object)

findRowCount

<T> int findRowCount(Query<T> query,
                   Transaction transaction)

Return the number of 'top level' or 'root' entities this query should return.

findIds

<T> List<Object> findIds(Query<T> query,
                       Transaction t)

Return the Id values of the query as a List.

findIterate

<T> QueryIterator<T> findIterate(Query<T> query,
                               Transaction t)

Return a QueryIterator for the query. This is similar to findVisit in that not all the result beans need to be held in memory at the same time and as such is go for processing large queries.

findVisit

<T> void findVisit(Query<T> query,
                 QueryResultVisitor<T> visitor,
                 Transaction t)

Execute the query visiting the results. This is similar to findIterate in that not all the result beans need to be held in memory at the same time and as such is go for processing large queries.

findList

<T> List<T> findList(Query<T> query,
                   Transaction transaction)

Execute a query returning a list of beans.

Generally you are able to use Query.findList() rather than explicitly calling this method. You could use this method if you wish to explicitly control the transaction used for the query.

Type Parameters:

T - the type of entity bean to fetch.

Parameters:

query - the query to execute.

transaction - the transaction to use (can be null).

Returns:

the list of fetched beans.

See Also:

Query.findList()

findFutureRowCount

<T> FutureRowCount<T> findFutureRowCount(Query<T> query,
                                       Transaction t)

Execute find row count query in a background thread.

This returns a Future object which can be used to cancel, check the execution status (isDone etc) and get the value (with or without a timeout).

Parameters:

query - the query to execute the row count on

t - the transaction (can be null).

Returns:

a Future object for the row count query

findFutureIds

<T> FutureIds<T> findFutureIds(Query<T> query,
                             Transaction t)

Execute find Id's query in a background thread.

This returns a Future object which can be used to cancel, check the execution status (isDone etc) and get the value (with or without a timeout).

Parameters:

query - the query to execute the fetch Id's on

t - the transaction (can be null).

Returns:

a Future object for the list of Id's

findFutureList

<T> FutureList<T> findFutureList(Query<T> query,
                               Transaction t)

Execute find list query in a background thread.

This returns a Future object which can be used to cancel, check the execution status (isDone etc) and get the value (with or without a timeout).

Parameters:

query - the query to execute in the background

t - the transaction (can be null).

Returns:

a Future object for the list result of the query

findFutureList

SqlFutureList findFutureList(SqlQuery query,
                           Transaction t)

Execute find list SQL query in a background thread.

This returns a Future object which can be used to cancel, check the execution status (isDone etc) and get the value (with or without a timeout).

Parameters:

query - the query to execute in the background

t - the transaction (can be null).

Returns:

a Future object for the list result of the query

findPagingList

<T> PagingList<T> findPagingList(Query<T> query,
                               Transaction t,
                               int pageSize)

Find using a PagingList with explicit transaction and pageSize.

findSet

<T> Set<T> findSet(Query<T> query,
                 Transaction transaction)

Execute the query returning a set of entity beans.

Generally you are able to use Query.findSet() rather than explicitly calling this method. You could use this method if you wish to explicitly control the transaction used for the query.

Type Parameters:

T - the type of entity bean to fetch.

Parameters:

query - the query to execute

transaction - the transaction to use (can be null).

Returns:

the set of fetched beans.

See Also:

Query.findSet()

findMap

<T> Map<?,T> findMap(Query<T> query,
                   Transaction transaction)

Execute the query returning the entity beans in a Map.

Generally you are able to use Query.findMap() rather than explicitly calling this method. You could use this method if you wish to explicitly control the transaction used for the query.

Type Parameters:

T - the type of entity bean to fetch.

Parameters:

query - the query to execute.

transaction - the transaction to use (can be null).

Returns:

the map of fetched beans.

See Also:

Query.findMap()

findUnique

<T> T findUnique(Query<T> query,
               Transaction transaction)

Execute the query returning at most one entity bean. This will throw a PersistenceException if the query finds more than one result.

Generally you are able to use Query.findUnique() rather than explicitly calling this method. You could use this method if you wish to explicitly control the transaction used for the query.

Type Parameters:

T - the type of entity bean to fetch.

Parameters:

query - the query to execute.

transaction - the transaction to use (can be null).

Returns:

the list of fetched beans.

See Also:

Query.findUnique()

findList

List<SqlRow> findList(SqlQuery query,
                    Transaction transaction)

Execute the sql query returning a list of MapBean.

Generally you are able to use SqlQuery.findList() rather than explicitly calling this method. You could use this method if you wish to explicitly control the transaction used for the query.

Parameters:

query - the query to execute.

transaction - the transaction to use (can be null).

Returns:

the list of fetched MapBean.

See Also:

SqlQuery.findList()

findSet

Set<SqlRow> findSet(SqlQuery query,
                  Transaction transaction)

Execute the sql query returning a set of MapBean.

Generally you are able to use SqlQuery.findSet() rather than explicitly calling this method. You could use this method if you wish to explicitly control the transaction used for the query.

Parameters:

query - the query to execute.

transaction - the transaction to use (can be null).

Returns:

the set of fetched MapBean.

See Also:

SqlQuery.findSet()

findMap

Map<?,SqlRow> findMap(SqlQuery query,
                    Transaction transaction)

Execute the sql query returning a map of MapBean.

Generally you are able to use SqlQuery.findMap() rather than explicitly calling this method. You could use this method if you wish to explicitly control the transaction used for the query.

Parameters:

query - the query to execute.

transaction - the transaction to use (can be null).

Returns:

the set of fetched MapBean.

See Also:

SqlQuery.findMap()

findUnique

SqlRow findUnique(SqlQuery query,
                Transaction transaction)

Execute the sql query returning a single MapBean or null.

This will throw a PersistenceException if the query found more than one result.

Generally you are able to use SqlQuery.findUnique() rather than explicitly calling this method. You could use this method if you wish to explicitly control the transaction used for the query.

Parameters:

query - the query to execute.

transaction - the transaction to use (can be null).

Returns:

the fetched MapBean or null if none was found.

See Also:

SqlQuery.findUnique()

save

void save(Object bean)
          throws javax.persistence.OptimisticLockException

Persist the bean by either performing an insert or update.

Throws:

javax.persistence.OptimisticLockException

See Also:

Ebean.save(Object)

save

int save(Iterator<?> it)
         throws javax.persistence.OptimisticLockException

Save all the beans in the iterator.

Throws:

javax.persistence.OptimisticLockException

save

int save(Collection<?> it)
         throws javax.persistence.OptimisticLockException

Save all the beans in the collection.

Throws:

javax.persistence.OptimisticLockException

delete

void delete(Object bean)
            throws javax.persistence.OptimisticLockException

Delete the bean.

Throws:

javax.persistence.OptimisticLockException

See Also:

Ebean.delete(Object)

delete

int delete(Iterator<?> it)
           throws javax.persistence.OptimisticLockException

Delete all the beans from an Iterator.

Throws:

javax.persistence.OptimisticLockException

delete

int delete(Collection<?> c)
           throws javax.persistence.OptimisticLockException

Delete all the beans in the collection.

Throws:

javax.persistence.OptimisticLockException

delete

int delete(Class<?> beanType,
         Object id)

Delete the bean given its type and id.

delete

int delete(Class<?> beanType,
         Object id,
         Transaction t)

Delete the bean given its type and id with an explicit transaction.

delete

void delete(Class<?> beanType,
          Collection<?> ids)

Delete several beans given their type and id values.

delete

void delete(Class<?> beanType,
          Collection<?> ids,
          Transaction t)

Delete several beans given their type and id values with an explicit transaction.

execute

int execute(SqlUpdate updSql)

Execute a SQL Update Delete or Insert statement using the current transaction. This returns the number of rows that where updated, deleted or inserted.

Refer to Ebean.execute(UpdateSql) for full documentation.

See Also:

Ebean.execute(SqlUpdate)

execute

int execute(Update<?> update)

Execute a ORM insert update or delete statement using the current transaction.

This returns the number of rows that where inserted, updated or deleted.

execute

int execute(Update<?> update,
          Transaction t)

Execute a ORM insert update or delete statement with an explicit transaction.

execute

int execute(CallableSql callableSql)

Call a stored procedure.

Refer to Ebean.execute(CallableSql) for full documentation.

See Also:

Ebean.execute(CallableSql)

externalModification

void externalModification(String tableName,
                        boolean inserted,
                        boolean updated,
                        boolean deleted)

Process committed changes from another framework.

This notifies this instance of the framework that beans have been committed externally to it. Either by another framework or clustered server. It uses this to maintain its cache and text indexes appropriately.

See Also:

Ebean.externalModification(String, boolean, boolean, boolean)

find

<T> T find(Class<T> beanType,
         Object uid,
         Transaction transaction)

Find a entity bean with an explicit transaction.

Type Parameters:

T - the type of entity bean to find

Parameters:

beanType - the type of entity bean to find

uid - the bean id value

transaction - the transaction to use (can be null)

save

void save(Object bean,
        Transaction t)
          throws javax.persistence.OptimisticLockException

Insert or update a bean with an explicit transaction.

Throws:

javax.persistence.OptimisticLockException

save

int save(Iterator<?> it,
       Transaction t)
         throws javax.persistence.OptimisticLockException

Save all the beans in the iterator with an explicit transaction.

Throws:

javax.persistence.OptimisticLockException

update

void update(Object bean)

Force an update using the bean.

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 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
 ebeanServer.update(c);
 
 

update

void update(Object bean,
          Transaction t)

Force an update of the non-null properties of the bean with an explicit transaction.

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 update(Object, Set, Transaction, boolean, boolean).

update

void update(Object bean,
          Set<String> updateProps)

Force an update using the bean explicitly stating the properties to update.

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 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
 ebeanServer.update(c);
 
 

update

void update(Object bean,
          Set<String> updateProps,
          Transaction t)

Force an update of the specified properties of the bean with an explicit transaction.

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 update(Object, Set, Transaction, boolean, boolean).

update

void update(Object bean,
          Set<String> updateProps,
          Transaction t,
          boolean deleteMissingChildren,
          boolean updateNullProperties)

Force an update additionally specifying whether to 'deleteMissingChildren' when the update cascades to a OneToMany or ManyToMany.

By default the deleteMissingChildren is true and it is assumed that when cascade saving a O2M or M2M relationship that the relationship is 'fully loaded' and any child beans that are no longer on the relationship will be deleted.

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.

Parameters:

bean - the bean to update

updateProps - optionally you can specify the properties to update (can be null).

t - optionally you can specify the transaction to use (can be null).

deleteMissingChildren - specify false if you do not want 'missing children' of a OneToMany or ManyToMany to be automatically deleted.

updateNullProperties - specify true if by default you want properties with null values to be included in the update and false if those properties should be treated as 'unloaded' and excluded from the update. This only takes effect if the updateProps is null.

insert

void insert(Object bean)

Force the bean to be saved with an explicit insert.

Typically you would use save() and let Ebean determine if the bean should be inserted or updated. This can be useful when you are transferring data between databases and want to explicitly insert a bean into a different database that it came from.

insert

void insert(Object bean,
          Transaction t)

Force the bean to be saved with an explicit insert.

Typically you would use save() and let Ebean determine if the bean should be inserted or updated. This can be useful when you are transferring data between databases and want to explicitly insert a bean into a different database that it came from.

deleteManyToManyAssociations

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).

deleteManyToManyAssociations

int deleteManyToManyAssociations(Object ownerBean,
                               String propertyName,
                               Transaction t)

Delete the associations (from the intersection table) of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.

Additionally specify a transaction to use.

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

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.

saveManyToManyAssociations

void saveManyToManyAssociations(Object ownerBean,
                              String propertyName,
                              Transaction t)

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.

saveAssociation

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.

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

saveAssociation

void saveAssociation(Object ownerBean,
                   String propertyName,
                   Transaction t)

Save the associated collection or bean given the property name with a specific transaction.

This is similar to performing a save cascade on a specific property manually.

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

void delete(Object bean,
          Transaction t)
            throws javax.persistence.OptimisticLockException

Delete the bean with an explicit transaction.

Throws:

javax.persistence.OptimisticLockException

delete

int delete(Iterator<?> it,
         Transaction t)
           throws javax.persistence.OptimisticLockException

Delete all the beans from an iterator.

Throws:

javax.persistence.OptimisticLockException

execute

int execute(SqlUpdate updSql,
          Transaction t)

Execute explicitly passing a transaction.

execute

int execute(CallableSql callableSql,
          Transaction t)

Execute explicitly passing a transaction.

execute

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.

execute

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).

execute

<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.

execute

<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).

getServerCacheManager

ServerCacheManager getServerCacheManager()

Return the manager of the server cache ("L2" cache).

getBackgroundExecutor

BackgroundExecutor getBackgroundExecutor()

Return the BackgroundExecutor service for asynchronous processing of queries.

runCacheWarming

void runCacheWarming()

Run the cache warming queries on all bean types that have one defined.

A cache warming query can be defined via CacheStrategy.

runCacheWarming

void runCacheWarming(Class<?> beanType)

Run the cache warming query for a specific bean type.

A cache warming query can be defined via CacheStrategy.

createJsonContext

JsonContext createJsonContext()

Create a JsonContext that will use the default configuration options.