DefaultServer (avaje-ebeanorm 3.3.1 API)

java.lang.Object
- com.avaje.ebeaninternal.server.core.DefaultServer

All Implemented Interfaces:

BeanCollectionLoader, BeanLoader, EbeanServer, SpiEbeanServer
```
public final class DefaultServer
extends Object
implements SpiEbeanServer
```
The default server side implementation of EbeanServer.

Field Summary

Fields
Modifier and Type	Field and Description
`protected ConcurrentHashMap<ObjectGraphNode,CObjectGraphNodeStatistics>`	`objectGraphStats` Cache used to collect statistics based on ObjectGraphNode (used to highlight lazy loading origin points).

Constructor Summary

Constructors
Constructor and Description

DefaultServer(InternalConfiguration config, ServerCacheManager cache)
Create the DefaultServer.

Constructors
Constructor and Description
`DefaultServer(InternalConfiguration config, ServerCacheManager cache)` Create the DefaultServer.

Method Summary

Methods
Modifier and Type	Method and Description
`Transaction`	`beginTransaction()` Start a transaction.
`Transaction`	`beginTransaction(TxIsolation isolation)` Start a transaction with a specific Isolation Level.
`void`	`clearQueryStatistics()` Clear the query execution statistics.
`void`	`collectQueryStats(ObjectGraphNode node, long loadedBeanCount, long timeMicros)` Collect query statistics by ObjectGraphNode.
`void`	`commitTransaction()` Commit the current transaction.
`<T> CQuery<T>`	`compileQuery(Query<T> query, Transaction t)` Compile a query.
`CallableSql`	`createCallableSql(String sql)` Create a CallableSql to execute a given stored procedure.
`CallStack`	`createCallStack()` Create a CallStack object.
`<T> CsvReader<T>`	`createCsvReader(Class<T> beanType)` Create a CsvReader for a given beanType.
`<T> T`	`createEntityBean(Class<T> type)` Create a new EntityBean bean.
`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.
`<T> SpiOrmQueryRequest<T>`	`createQueryRequest(BeanDescriptor<T> desc, SpiQuery<T> query, Transaction t)` Create a query request object.
`SpiTransaction`	`createQueryTransaction()` Create a ServerTransaction for query purposes.
`ScopeTrans`	`createScopeTrans(TxScope txScope)` Create a ScopeTrans for a method for the given scope definition.
`SpiTransaction`	`createServerTransaction(boolean isExplicit, int isolationLevel)` Create a ServerTransaction.
`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()` Creates a new Transaction that is NOT stored in TransactionThreadLocal.
`Transaction`	`createTransaction(TxIsolation isolation)` Create a transaction additionally specify 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()` Return the current transaction or null if there is not one currently 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 in the iterator.
`int`	`delete(Iterator<?> it, Transaction t)` Delete all the beans in the iterator with an explicit transaction.
`void`	`delete(Object bean)` Delete the bean.
`void`	`delete(Object bean, Transaction t)` Delete the bean with the 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.
`void`	`deregister(BeanPersistController c)`
`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 callSql)` Execute the CallableSql.
`int`	`execute(CallableSql callSql, Transaction t)` Execute the CallableSql with an explicit transaction.
`int`	`execute(SqlUpdate updSql)` Execute the updateSql.
`int`	`execute(SqlUpdate updSql, Transaction t)` Execute the updateSql with an explicit 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 the orm update.
`int`	`execute(Update<?> update, Transaction t)` Execute the updateSql with an explicit transaction.
`void`	`executePlugins(boolean online)`
`void`	`externalModification(String tableName, boolean inserts, boolean updates, boolean deletes)` Developer informing eBean that tables where modified outside of eBean.
`void`	`externalModification(TransactionEventTable tableEvent)` Process committed beans from another framework or server in another cluster.
`<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 `EbeanServer.createQuery(Class)`).
`<T> T`	`find(Class<T> beanType, Object uid)` Find a bean using its unique id.
`<T> T`	`find(Class<T> beanType, Object id, Transaction t)` Find a bean using its unique id.
`<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> q, 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> List<Object>`	`findIdsWithCopy(Query<T> query, Transaction t)` Execute the findId's query but without copying the query.
`<T> QueryIterator<T>`	`findIterate(Query<T> query, Transaction t)` Return a QueryIterator for the query.
`<T> List<T>`	`findList(Query<T> query, Transaction t)` Execute a query returning a list of beans.
`List<SqlRow>`	`findList(SqlQuery query, Transaction t)` Execute the sql query returning a list of MapBean.
`<T> Map<?,T>`	`findMap(Query<T> query, Transaction t)` Execute the query returning the entity beans in a Map.
`Map<?,SqlRow>`	`findMap(SqlQuery query, Transaction t)` 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 t)` Return the number of 'top level' or 'root' entities this query should return.
`<T> int`	`findRowCountWithCopy(Query<T> query, Transaction t)` Execute the findRowCount query but without copying the query.
`<T> Set<T>`	`findSet(Query<T> query, Transaction t)` Execute the query returning a set of entity beans.
`Set<SqlRow>`	`findSet(SqlQuery query, Transaction t)` Execute the sql query returning a set of MapBean.
`<T> T`	`findUnique(Query<T> query, Transaction t)` Execute the query returning at most one entity bean.
`SqlRow`	`findUnique(SqlQuery query, Transaction t)` 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.
`AutoFetchManager`	`getAutoFetchManager()` Return the AutoFetchListener.
`BackgroundExecutor`	`getBackgroundExecutor()` Return the BackgroundExecutor service for asynchronous processing of queries.
`<T> BeanDescriptor<T>`	`getBeanDescriptor(Class<T> beanClass)` Return the BeanDescriptor for a given type of bean.
`BeanDescriptor<?>`	`getBeanDescriptorById(String descriptorId)` Return the BeanDescriptor using its unique id.
`List<BeanDescriptor<?>>`	`getBeanDescriptors()` Return all the BeanDescriptors.
`List<BeanDescriptor<?>>`	`getBeanDescriptors(String tableName)` Return the BeanDescriptor's for a given table name.
`Object`	`getBeanId(Object bean)` Return the value of the Id property for a given bean.
`<T> BeanManager<T>`	`getBeanManager(Class<T> beanClass)`
`BeanState`	`getBeanState(Object bean)` Return the BeanState for a given entity bean.
`SpiTransaction`	`getCurrentServerTransaction()` Returns the current transaction (or null) from the scope.
`DatabasePlatform`	`getDatabasePlatform()` Return the DatabasePlatform for this server.
`DdlGenerator`	`getDdlGenerator()` Return the DDL generator.
`ExpressionFactory`	`getExpressionFactory()` Return the ExpressionFactory for this server.
`int`	`getLazyLoadBatchSize()` Return the default batch size for lazy loading.
`List<MetaBeanInfo>`	`getMetaBeanInfoList()`
`MetaInfoManager`	`getMetaInfoManager()` Return the MetaInfoManager which is used to get meta data from the EbeanServer such as query execution statistics.
`String`	`getName()` Return the server name.
`AutoFetchManager`	`getProfileListener()` Return the Profile Listener.
`PstmtBatch`	`getPstmtBatch()` Return a JDBC driver specific handler for batching.
`CQueryEngine`	`getQueryEngine()` Return the queryEngine for this server.
`<T> T`	`getReference(Class<T> type, Object id)` Return a Reference bean.
`RelationalQueryEngine`	`getRelationalQueryEngine()` Return the Relational query engine.
`ServerCacheManager`	`getServerCacheManager()` Return the manager of the server cache ("L2" cache).
`List<SpiEbeanPlugin>`	`getSpiEbeanPlugins()`
`void`	`initialise()` Run any initialisation required before registering with the ClusterManager.
`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.
`boolean`	`isCollectQueryOrigins()`
`boolean`	`isDefaultDeleteMissingChildren()` Return true if DeleteMissingChildren defaults to true for stateless updates.
`boolean`	`isDefaultUpdateNullProperties()` Return true if UpdateNullProperties defaults to true for stateless updates.
`boolean`	`isSupportedType(Type genericType)` Return true if the type is known as an Entity or Xml type or a List Set or Map of known bean types.
`protected void`	`loadAndInitializePlugins(InternalConfiguration config)`
`void`	`loadBean(EntityBeanIntercept ebi)` Invoke the lazy loading for this bean.
`void`	`loadBean(LoadBeanRequest loadRequest)` Load a batch of Associated One Beans.
`void`	`loadMany(BeanCollection<?> bc, boolean onlyIds)` Invoke the lazy loading for this bean collection.
`void`	`loadMany(LoadManyRequest loadRequest)` Lazy load a batch of Many's.
`Object`	`nextId(Class<?> beanType)` return the next unique identity value.
`void`	`refresh(Object bean)` Refresh the values of a bean.
`void`	`refreshMany(Object parentBean, String propertyName)` Refresh a many property of an entity bean.
`void`	`refreshMany(Object parentBean, String propertyName, Transaction t)`
`void`	`register(BeanPersistController c)`
`void`	`registerMBeans(MBeanServer mbeanServer, int uniqueServerId)`
`void`	`remoteTransactionEvent(RemoteTransactionEvent event)` Another server in the cluster sent this event so that we can inform local BeanListeners of inserts updates and deletes that occurred remotely (on another server in the cluster).
`void`	`rollbackTransaction()` Rollback the current transaction.
`void`	`runCacheWarming()` Run the cache warming queries on all beans that have them defined.
`void`	`runCacheWarming(Class<?> beanType)` Run the cache warming query for a specific bean type.
`int`	`save(Collection<?> c)` Perform an update or insert on each bean in the collection.
`int`	`save(Iterator<?> it)` Perform an update or insert on each bean in the iterator.
`int`	`save(Iterator<?> it, Transaction t)` Save all 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)` Save the 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)` Shutting down manually.
`void`	`shutdownManaged()` Shutting down via JVM Shutdown hook.
`<T> void`	`sort(List<T> list, String sortByClause)` Sort the list using the sortByClause.
`void`	`start()` Start any services after registering with the ClusterManager.
`void`	`update(Object bean)` Force an update using the bean updating non-null properties.
`void`	`update(Object bean, Set<String> updateProps)` Force an update using the bean explicitly stating which properties to include in the update.
`void`	`update(Object bean, Set<String> updateProps, Transaction t)` Force an update using the bean explicitly stating which properties to include in the update.
`void`	`update(Object bean, Set<String> updateProps, Transaction t, boolean deleteMissingChildren, boolean updateNullProperties)` Force an update using the bean explicitly stating which properties to include in the update.
`void`	`update(Object bean, Transaction t)` Force an update using the bean updating non-null properties.

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

- Field Detail
  - objectGraphStats
```
protected final ConcurrentHashMap<ObjectGraphNode,CObjectGraphNodeStatistics> objectGraphStats
```
    Cache used to collect statistics based on ObjectGraphNode (used to highlight lazy loading origin points).
- Constructor Detail
  - DefaultServer
```
public DefaultServer(InternalConfiguration config,
             ServerCacheManager cache)
```
    Create the DefaultServer.
- Method Detail
  - loadAndInitializePlugins
```
protected void loadAndInitializePlugins(InternalConfiguration config)
```
  - getSpiEbeanPlugins
```
public List<SpiEbeanPlugin> getSpiEbeanPlugins()
```
  - executePlugins
```
public void executePlugins(boolean online)
```
  - isCollectQueryOrigins
```
public boolean isCollectQueryOrigins()
```
    Specified by:
    
    isCollectQueryOrigins in interface SpiEbeanServer
  - isDefaultDeleteMissingChildren
```
public boolean isDefaultDeleteMissingChildren()
```
    Description copied from interface: SpiEbeanServer
    
    Return true if DeleteMissingChildren defaults to true for stateless updates.
    
    Specified by:
    
    isDefaultDeleteMissingChildren in interface SpiEbeanServer
  - isDefaultUpdateNullProperties
```
public boolean isDefaultUpdateNullProperties()
```
    Description copied from interface: SpiEbeanServer
    
    Return true if UpdateNullProperties defaults to true for stateless updates.
    
    Specified by:
    
    isDefaultUpdateNullProperties in interface SpiEbeanServer
  - getLazyLoadBatchSize
```
public int getLazyLoadBatchSize()
```
    Description copied from interface: SpiEbeanServer
    
    Return the default batch size for lazy loading.
    
    Specified by:
    
    getLazyLoadBatchSize in interface SpiEbeanServer
  - getPstmtBatch
```
public PstmtBatch getPstmtBatch()
```
    Description copied from interface: SpiEbeanServer
    
    Return a JDBC driver specific handler for batching.
    Required for Oracle specific batch handling.
    
    Specified by:
    
    getPstmtBatch in interface SpiEbeanServer
  - getDatabasePlatform
```
public DatabasePlatform getDatabasePlatform()
```
    Description copied from interface: SpiEbeanServer
    
    Return the DatabasePlatform for this server.
    
    Specified by:
    
    getDatabasePlatform in interface SpiEbeanServer
  - getMetaInfoManager
```
public MetaInfoManager getMetaInfoManager()
```
    Description copied from interface: EbeanServer
    
    Return the MetaInfoManager which is used to get meta data from the EbeanServer such as query execution statistics.
    
    Specified by:
    
    getMetaInfoManager in interface EbeanServer
  - getBackgroundExecutor
```
public BackgroundExecutor getBackgroundExecutor()
```
    Description copied from interface: EbeanServer
    
    Return the BackgroundExecutor service for asynchronous processing of queries.
    
    Specified by:
    
    getBackgroundExecutor in interface EbeanServer
  - getExpressionFactory
```
public ExpressionFactory getExpressionFactory()
```
    Description copied from interface: EbeanServer
    
    Return the ExpressionFactory for this server.
    
    Specified by:
    
    getExpressionFactory in interface EbeanServer
  - getDdlGenerator
```
public DdlGenerator getDdlGenerator()
```
    Description copied from interface: SpiEbeanServer
    
    Return the DDL generator.
    
    Specified by:
    
    getDdlGenerator in interface SpiEbeanServer
  - getAdminAutofetch
```
public AdminAutofetch getAdminAutofetch()
```
    Description copied from interface: EbeanServer
    
    Return the AdminAutofetch which is used to control and configure the Autofetch service at runtime.
    
    Specified by:
    
    getAdminAutofetch in interface EbeanServer
  - getAutoFetchManager
```
public AutoFetchManager getAutoFetchManager()
```
    Description copied from interface: SpiEbeanServer
    
    Return the AutoFetchListener.
    
    Specified by:
    
    getAutoFetchManager in interface SpiEbeanServer
  - initialise
```
public void initialise()
```
    Run any initialisation required before registering with the ClusterManager.
  - start
```
public void start()
```
    Start any services after registering with the ClusterManager.
  - registerMBeans
```
public void registerMBeans(MBeanServer mbeanServer,
                  int uniqueServerId)
```
  - shutdownManaged
```
public void shutdownManaged()
```
    Shutting down via JVM Shutdown hook.
    
    Specified by:
    
    shutdownManaged in interface SpiEbeanServer
  - shutdown
```
public void shutdown(boolean shutdownDataSource,
            boolean deregisterDriver)
```
    Shutting down manually.
    
    Specified by:
    
    shutdown in interface EbeanServer
    
    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.
  - getName
```
public String getName()
```
    Return the server name.
    
    Specified by:
    
    getName in interface BeanCollectionLoader
    
    Specified by:
    
    getName in interface BeanLoader
    
    Specified by:
    
    getName in interface EbeanServer
  - getBeanState
```
public BeanState getBeanState(Object bean)
```
    Description copied from interface: EbeanServer
    
    Return the BeanState for a given entity bean.
    This will return null if the bean is not an enhanced (or subclassed) entity bean.
    
    Specified by:
    
    getBeanState in interface EbeanServer
  - runCacheWarming
```
public void runCacheWarming()
```
    Run the cache warming queries on all beans that have them defined.
    
    Specified by:
    
    runCacheWarming in interface EbeanServer
  - runCacheWarming
```
public void runCacheWarming(Class<?> beanType)
```
    Description copied from interface: EbeanServer
    
    Run the cache warming query for a specific bean type.
    A cache warming query can be defined via CacheStrategy.
    
    Specified by:
    
    runCacheWarming in interface EbeanServer
  - compileQuery
```
public <T> CQuery<T> compileQuery(Query<T> query,
                         Transaction t)
```
    Compile a query. Only valid for ORM queries.
    
    Specified by:
    
    compileQuery in interface SpiEbeanServer
  - getQueryEngine
```
public CQueryEngine getQueryEngine()
```
    Description copied from interface: SpiEbeanServer
    
    Return the queryEngine for this server.
    
    Specified by:
    
    getQueryEngine in interface SpiEbeanServer
  - getServerCacheManager
```
public ServerCacheManager getServerCacheManager()
```
    Description copied from interface: EbeanServer
    
    Return the manager of the server cache ("L2" cache).
    
    Specified by:
    
    getServerCacheManager in interface EbeanServer
  - getProfileListener
```
public AutoFetchManager getProfileListener()
```
    Return the Profile Listener.
  - getRelationalQueryEngine
```
public RelationalQueryEngine getRelationalQueryEngine()
```
    Return the Relational query engine.
  - refreshMany
```
public void refreshMany(Object parentBean,
               String propertyName,
               Transaction t)
```
  - refreshMany
```
public void refreshMany(Object parentBean,
               String propertyName)
```
    Description copied from interface: EbeanServer
    
    Refresh a many property of an entity bean.
    
    Specified by:
    
    refreshMany in interface EbeanServer
    
    Parameters:
    parentBean - the entity bean containing the 'many' property
    propertyName - the 'many' property to be refreshed
    See Also:
    Ebean.refreshMany(Object, String)
  - loadMany
```
public void loadMany(LoadManyRequest loadRequest)
```
    Description copied from interface: SpiEbeanServer
    
    Lazy load a batch of Many's.
    
    Specified by:
    
    loadMany in interface SpiEbeanServer
  - loadMany
```
public void loadMany(BeanCollection<?> bc,
            boolean onlyIds)
```
    Description copied from interface: BeanCollectionLoader
    
    Invoke the lazy loading for this bean collection.
    
    Specified by:
    
    loadMany in interface BeanCollectionLoader
  - refresh
```
public void refresh(Object bean)
```
    Description copied from interface: EbeanServer
    
    Refresh the values of a bean.
    Note that this does not refresh any OneToMany or ManyToMany properties.
    
    Specified by:
    
    refresh in interface EbeanServer
    
    See Also:
    Ebean.refresh(Object)
  - loadBean
```
public void loadBean(LoadBeanRequest loadRequest)
```
    Description copied from interface: SpiEbeanServer
    
    Load a batch of Associated One Beans.
    
    Specified by:
    
    loadBean in interface SpiEbeanServer
  - loadBean
```
public void loadBean(EntityBeanIntercept ebi)
```
    Description copied from interface: BeanLoader
    
    Invoke the lazy loading for this bean.
    
    Specified by:
    
    loadBean in interface BeanLoader
  - diff
```
public Map<String,ValuePair> diff(Object a,
                         Object b)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    diff in interface EbeanServer
  - externalModification
```
public void externalModification(TransactionEventTable tableEvent)
```
    Process committed beans from another framework or server in another cluster.
    This notifies this instance of the framework that beans have been committed externally to it. Either by another framework or clustered server. It needs to maintain its cache and text indexes appropriately.
    
    Specified by:
    
    externalModification in interface SpiEbeanServer
  - externalModification
```
public void externalModification(String tableName,
                        boolean inserts,
                        boolean updates,
                        boolean deletes)
```
    Developer informing eBean that tables where modified outside of eBean. Invalidate the cache etc as required.
    
    Specified by:
    
    externalModification in interface EbeanServer
    
    See Also:
    Ebean.externalModification(String, boolean, boolean, boolean)
  - clearQueryStatistics
```
public void clearQueryStatistics()
```
    Clear the query execution statistics.
    
    Specified by:
    
    clearQueryStatistics in interface SpiEbeanServer
  - createEntityBean
```
public <T> T createEntityBean(Class<T> type)
```
    Create a new EntityBean bean.
    This will generally return a subclass of the parameter 'type' which additionally implements the EntityBean interface. That is, the returned bean is typically an instance of a dynamically generated class.
    
    Specified by:
    
    createEntityBean in interface EbeanServer
  - getReference
```
public <T> T getReference(Class<T> type,
                 Object id)
```
    Return a Reference bean.
    If a current transaction is active then this will check the Context of that transaction to see if the bean is already loaded. If it is already loaded then it will returned that object.
    
    Specified by:
    
    getReference in interface EbeanServer
    
    See Also:
    Ebean.getReference(Class, Object)
  - createTransaction
```
public Transaction createTransaction()
```
    Creates a new Transaction that is NOT stored in TransactionThreadLocal. Use this when you want a thread to have a second independent transaction.
    
    Specified by:
    
    createTransaction in interface EbeanServer
  - createTransaction
```
public Transaction createTransaction(TxIsolation isolation)
```
    Create a transaction additionally specify the Isolation level.
    Note that this transaction is not stored in a thread local.
    
    Specified by:
    
    createTransaction in interface EbeanServer
  - execute
```
public <T> T execute(TxCallable<T> c)
```
    Description copied from interface: EbeanServer
    
    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).
    
    Specified by:
    
    execute in interface EbeanServer
  - execute
```
public <T> T execute(TxScope scope,
            TxCallable<T> c)
```
    Description copied from interface: EbeanServer
    
    Execute a TxCallable in a Transaction with an explicit scope.
    The scope can control the transaction type, isolation and rollback semantics.
    
    Specified by:
    
    execute in interface EbeanServer
  - execute
```
public void execute(TxRunnable r)
```
    Description copied from interface: EbeanServer
    
    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).
    
    Specified by:
    
    execute in interface EbeanServer
  - execute
```
public void execute(TxScope scope,
           TxRunnable r)
```
    Description copied from interface: EbeanServer
    
    Execute a TxRunnable in a Transaction with an explicit scope.
    The scope can control the transaction type, isolation and rollback semantics.
    
    Specified by:
    
    execute in interface EbeanServer
  - createScopeTrans
```
public ScopeTrans createScopeTrans(TxScope txScope)
```
    Description copied from interface: SpiEbeanServer
    
    Create a ScopeTrans for a method for the given scope definition.
    
    Specified by:
    
    createScopeTrans in interface SpiEbeanServer
  - getCurrentServerTransaction
```
public SpiTransaction getCurrentServerTransaction()
```
    Returns the current transaction (or null) from the scope.
    
    Specified by:
    
    getCurrentServerTransaction in interface SpiEbeanServer
  - beginTransaction
```
public Transaction beginTransaction()
```
    Start a transaction.
    Note that the transaction is stored in a ThreadLocal variable.
    
    Specified by:
    
    beginTransaction in interface EbeanServer
    
    See Also:
    Ebean.beginTransaction()
  - beginTransaction
```
public Transaction beginTransaction(TxIsolation isolation)
```
    Start a transaction with a specific Isolation Level.
    Note that the transaction is stored in a ThreadLocal variable.
    
    Specified by:
    
    beginTransaction in interface EbeanServer
  - currentTransaction
```
public Transaction currentTransaction()
```
    Return the current transaction or null if there is not one currently in scope.
    
    Specified by:
    
    currentTransaction in interface EbeanServer
  - commitTransaction
```
public void commitTransaction()
```
    Commit the current transaction.
    
    Specified by:
    
    commitTransaction in interface EbeanServer
    
    See Also:
    Ebean.commitTransaction()
  - rollbackTransaction
```
public void rollbackTransaction()
```
    Rollback the current transaction.
    
    Specified by:
    
    rollbackTransaction in interface EbeanServer
    
    See Also:
    Ebean.rollbackTransaction()
  - endTransaction
```
public 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:
```
 <code>
 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();
 }
 </code>
 
```
    Specified by:
    
    endTransaction in interface EbeanServer
    
    See Also:
    Ebean.endTransaction()
  - nextId
```
public Object nextId(Class<?> beanType)
```
    return the next unique identity value.
    Uses the BeanDescriptor deployment information to determine the sequence to use.
    
    Specified by:
    
    nextId in interface EbeanServer
  - sort
```
public <T> void sort(List<T> list,
            String sortByClause)
```
    Description copied from interface: EbeanServer
    
    Sort the list using the sortByClause.
    
    Specified by:
    
    sort in interface EbeanServer
    
    Parameters:
    list - the list of entity beans
    sortByClause - the properties to sort the list by
    See Also:
    Ebean.sort(List, String)
  - createQuery
```
public <T> Query<T> createQuery(Class<T> beanType)
                     throws javax.persistence.PersistenceException
```
    Description copied from interface: EbeanServer
    
    Create a query for an entity bean (refer Ebean.createQuery(Class) ).
    
    Specified by:
    
    createQuery in interface EbeanServer
    
    Throws:
    
    javax.persistence.PersistenceException
    See Also:
    Ebean.createQuery(Class)
  - createNamedQuery
```
public <T> Query<T> createNamedQuery(Class<T> beanType,
                            String namedQuery)
                          throws javax.persistence.PersistenceException
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    createNamedQuery in interface EbeanServer
    
    Throws:
    
    javax.persistence.PersistenceException
    See Also:
    Ebean.createQuery(Class, String)
  - filter
```
public <T> Filter<T> filter(Class<T> beanType)
```
    Description copied from interface: EbeanServer
    
    Create a filter for filtering lists of entity beans.
    
    Specified by:
    
    filter in interface EbeanServer
  - createCsvReader
```
public <T> CsvReader<T> createCsvReader(Class<T> beanType)
```
    Description copied from interface: EbeanServer
    
    Create a CsvReader for a given beanType.
    
    Specified by:
    
    createCsvReader in interface EbeanServer
  - find
```
public <T> Query<T> find(Class<T> beanType)
```
    Description copied from interface: EbeanServer
    
    Create a query for a type of entity bean (the same as EbeanServer.createQuery(Class)).
    
    Specified by:
    
    find in interface EbeanServer
  - createQuery
```
public <T> Query<T> createQuery(Class<T> beanType,
                       String query)
```
    Description copied from interface: EbeanServer
    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 EbeanServer.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();
 
```
    Specified by:
    
    createQuery in interface EbeanServer
    
    query - the object query
  - createNamedUpdate
```
public <T> Update<T> createNamedUpdate(Class<T> beanType,
                              String namedUpdate)
```
    Description copied from interface: EbeanServer
    
    Create a named update for an entity bean (refer Ebean.createNamedUpdate(Class, String)).
    
    Specified by:
    
    createNamedUpdate in interface EbeanServer
  - createUpdate
```
public <T> Update<T> createUpdate(Class<T> beanType,
                         String ormUpdate)
```
    Description copied from interface: EbeanServer
    
    Create a update for an entity bean where you will manually specify the insert update or delete statement.
    
    Specified by:
    
    createUpdate in interface EbeanServer
  - createSqlQuery
```
public SqlQuery createSqlQuery(String sql)
```
    Description copied from interface: EbeanServer
    
    Create a sql query for executing native sql query statements (refer Ebean.createSqlQuery(String)).
    
    Specified by:
    
    createSqlQuery in interface EbeanServer
    
    See Also:
    Ebean.createSqlQuery(String)
  - createNamedSqlQuery
```
public SqlQuery createNamedSqlQuery(String namedQuery)
```
    Description copied from interface: EbeanServer
    
    Create a named sql query (refer Ebean.createNamedSqlQuery(String) ).
    The query statement will be defined in a deployment orm xml file.
    
    Specified by:
    
    createNamedSqlQuery in interface EbeanServer
    
    See Also:
    Ebean.createNamedSqlQuery(String)
  - createSqlUpdate
```
public SqlUpdate createSqlUpdate(String sql)
```
    Description copied from interface: EbeanServer
    
    Create a sql update for executing native dml statements (refer Ebean.createSqlUpdate(String)).
    
    Specified by:
    
    createSqlUpdate in interface EbeanServer
    
    See Also:
    Ebean.createSqlUpdate(String)
  - createCallableSql
```
public CallableSql createCallableSql(String sql)
```
    Description copied from interface: EbeanServer
    
    Create a CallableSql to execute a given stored procedure.
    
    Specified by:
    
    createCallableSql in interface EbeanServer
  - createNamedSqlUpdate
```
public SqlUpdate createNamedSqlUpdate(String namedQuery)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    createNamedSqlUpdate in interface EbeanServer
    
    See Also:
    Ebean.createNamedSqlUpdate(String)
  - find
```
public <T> T find(Class<T> beanType,
         Object uid)
```
    Description copied from interface: EbeanServer
    
    Find a bean using its unique id.
    
    Specified by:
    
    find in interface EbeanServer
    
    See Also:
    Ebean.find(Class, Object)
  - find
```
public <T> T find(Class<T> beanType,
         Object id,
         Transaction t)
```
    Find a bean using its unique id.
    
    Specified by:
    
    find in interface EbeanServer
    
    Type Parameters:
    T - the type of entity bean to find
    Parameters:
    beanType - the type of entity bean to find
    id - the bean id value
    t - the transaction to use (can be null)
  - createQueryRequest
```
public <T> SpiOrmQueryRequest<T> createQueryRequest(BeanDescriptor<T> desc,
                                           SpiQuery<T> query,
                                           Transaction t)
```
    Description copied from interface: SpiEbeanServer
    
    Create a query request object.
    
    Specified by:
    
    createQueryRequest in interface SpiEbeanServer
  - findUnique
```
public <T> T findUnique(Query<T> query,
               Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findUnique in interface EbeanServer
    
    Type Parameters:
    T - the type of entity bean to fetch.
    Parameters:
    query - the query to execute.
    t - the transaction to use (can be null).
    
    Returns:
    the list of fetched beans.
    See Also:
    Query.findUnique()
  - findSet
```
public <T> Set<T> findSet(Query<T> query,
                 Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findSet in interface EbeanServer
    
    Type Parameters:
    T - the type of entity bean to fetch.
    Parameters:
    query - the query to execute
    t - the transaction to use (can be null).
    
    Returns:
    the set of fetched beans.
    See Also:
    Query.findSet()
  - findMap
```
public <T> Map<?,T> findMap(Query<T> query,
                   Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findMap in interface EbeanServer
    
    Type Parameters:
    T - the type of entity bean to fetch.
    Parameters:
    query - the query to execute.
    t - the transaction to use (can be null).
    
    Returns:
    the map of fetched beans.
    See Also:
    Query.findMap()
  - findRowCount
```
public <T> int findRowCount(Query<T> query,
                   Transaction t)
```
    Description copied from interface: EbeanServer
    
    Return the number of 'top level' or 'root' entities this query should return.
    
    Specified by:
    
    findRowCount in interface EbeanServer
  - findRowCountWithCopy
```
public <T> int findRowCountWithCopy(Query<T> query,
                           Transaction t)
```
    Description copied from interface: SpiEbeanServer
    
    Execute the findRowCount query but without copying the query.
    
    Specified by:
    
    findRowCountWithCopy in interface SpiEbeanServer
  - findIds
```
public <T> List<Object> findIds(Query<T> query,
                       Transaction t)
```
    Description copied from interface: EbeanServer
    
    Return the Id values of the query as a List.
    
    Specified by:
    
    findIds in interface EbeanServer
  - findIdsWithCopy
```
public <T> List<Object> findIdsWithCopy(Query<T> query,
                               Transaction t)
```
    Description copied from interface: SpiEbeanServer
    
    Execute the findId's query but without copying the query.
    Used so that the list of Id's can be made accessible to client code before the query has finished (if executing in a background thread).
    
    Specified by:
    
    findIdsWithCopy in interface SpiEbeanServer
  - findFutureRowCount
```
public <T> FutureRowCount<T> findFutureRowCount(Query<T> q,
                                       Transaction t)
```
    Description copied from interface: EbeanServer
    
    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).
    
    Specified by:
    
    findFutureRowCount in interface EbeanServer
    
    Parameters:
    q - the query to execute the row count on
    t - the transaction (can be null).
    
    Returns:
    a Future object for the row count query
  - findFutureIds
```
public <T> FutureIds<T> findFutureIds(Query<T> query,
                             Transaction t)
```
    Description copied from interface: EbeanServer
    
    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).
    
    Specified by:
    
    findFutureIds in interface EbeanServer
    
    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
```
public <T> FutureList<T> findFutureList(Query<T> query,
                               Transaction t)
```
    Description copied from interface: EbeanServer
    
    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).
    
    Specified by:
    
    findFutureList in interface EbeanServer
    
    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
```
public <T> PagingList<T> findPagingList(Query<T> query,
                               Transaction t,
                               int pageSize)
```
    Description copied from interface: EbeanServer
    
    Find using a PagingList with explicit transaction and pageSize.
    
    Specified by:
    
    findPagingList in interface EbeanServer
  - findVisit
```
public <T> void findVisit(Query<T> query,
                 QueryResultVisitor<T> visitor,
                 Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findVisit in interface EbeanServer
  - findIterate
```
public <T> QueryIterator<T> findIterate(Query<T> query,
                               Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findIterate in interface EbeanServer
  - findList
```
public <T> List<T> findList(Query<T> query,
                   Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findList in interface EbeanServer
    
    Type Parameters:
    T - the type of entity bean to fetch.
    Parameters:
    query - the query to execute.
    t - the transaction to use (can be null).
    
    Returns:
    the list of fetched beans.
    See Also:
    Query.findList()
  - findUnique
```
public SqlRow findUnique(SqlQuery query,
                Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findUnique in interface EbeanServer
    
    Parameters:
    query - the query to execute.
    t - the transaction to use (can be null).
    
    Returns:
    the fetched MapBean or null if none was found.
    See Also:
    SqlQuery.findUnique()
  - findFutureList
```
public SqlFutureList findFutureList(SqlQuery query,
                           Transaction t)
```
    Description copied from interface: EbeanServer
    
    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).
    
    Specified by:
    
    findFutureList in interface EbeanServer
    
    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
  - findList
```
public List<SqlRow> findList(SqlQuery query,
                    Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findList in interface EbeanServer
    
    Parameters:
    query - the query to execute.
    t - the transaction to use (can be null).
    
    Returns:
    the list of fetched MapBean.
    See Also:
    SqlQuery.findList()
  - findSet
```
public Set<SqlRow> findSet(SqlQuery query,
                  Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findSet in interface EbeanServer
    
    Parameters:
    query - the query to execute.
    t - the transaction to use (can be null).
    
    Returns:
    the set of fetched MapBean.
    See Also:
    SqlQuery.findSet()
  - findMap
```
public Map<?,SqlRow> findMap(SqlQuery query,
                    Transaction t)
```
    Description copied from interface: EbeanServer
    
    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.
    
    Specified by:
    
    findMap in interface EbeanServer
    
    Parameters:
    query - the query to execute.
    t - the transaction to use (can be null).
    
    Returns:
    the set of fetched MapBean.
    See Also:
    SqlQuery.findMap()
  - save
```
public void save(Object bean)
```
    Persist the bean by either performing an insert or update.
    
    Specified by:
    
    save in interface EbeanServer
    
    See Also:
    Ebean.save(Object)
  - save
```
public void save(Object bean,
        Transaction t)
```
    Save the bean with an explicit transaction.
    
    Specified by:
    
    save in interface EbeanServer
  - update
```
public void update(Object bean)
```
    Force an update using the bean updating non-null properties.
    
    Specified by:
    
    update in interface EbeanServer
  - update
```
public void update(Object bean,
          Set<String> updateProps)
```
    Force an update using the bean explicitly stating which properties to include in the update.
    
    Specified by:
    
    update in interface EbeanServer
  - update
```
public void update(Object bean,
          Transaction t)
```
    Force an update using the bean updating non-null properties.
    
    Specified by:
    
    update in interface EbeanServer
  - update
```
public void update(Object bean,
          Set<String> updateProps,
          Transaction t)
```
    Force an update using the bean explicitly stating which properties to include in the update.
    
    Specified by:
    
    update in interface EbeanServer
  - update
```
public void update(Object bean,
          Set<String> updateProps,
          Transaction t,
          boolean deleteMissingChildren,
          boolean updateNullProperties)
```
    Force an update using the bean explicitly stating which properties to include in the update.
    
    Specified by:
    
    update in interface EbeanServer
    
    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
```
public 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.
    
    Specified by:
    
    insert in interface EbeanServer
  - insert
```
public 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.
    
    Specified by:
    
    insert in interface EbeanServer
  - deleteManyToManyAssociations
```
public 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.
    This returns the number of associations deleted.
    
    Specified by:
    
    deleteManyToManyAssociations in interface EbeanServer
    
    Returns:
    the number of associations deleted (from the intersection table).
  - deleteManyToManyAssociations
```
public 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.
    This returns the number of associations deleted.
    
    Specified by:
    
    deleteManyToManyAssociations in interface EbeanServer
    
    Returns:
    the number of associations deleted (from the intersection table).
  - saveManyToManyAssociations
```
public void saveManyToManyAssociations(Object ownerBean,
                              String propertyName)
```
    Save the associations of a ManyToMany given the owner bean and the propertyName of the ManyToMany collection.
    
    Specified by:
    
    saveManyToManyAssociations in interface EbeanServer
  - saveManyToManyAssociations
```
public 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.
    
    Specified by:
    
    saveManyToManyAssociations in interface EbeanServer
  - saveAssociation
```
public void saveAssociation(Object ownerBean,
                   String propertyName)
```
    Description copied from interface: EbeanServer
    
    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)
    
    Specified by:
    
    saveAssociation in interface EbeanServer
    
    Parameters:
    ownerBean - the bean instance holding the property we want to save
    propertyName - the property we want to save
  - saveAssociation
```
public void saveAssociation(Object ownerBean,
                   String propertyName,
                   Transaction t)
```
    Description copied from interface: EbeanServer
    
    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)
    
    Specified by:
    
    saveAssociation in interface EbeanServer
    
    Parameters:
    ownerBean - the bean instance holding the property we want to save
    propertyName - the property we want to save
  - save
```
public int save(Iterator<?> it)
```
    Perform an update or insert on each bean in the iterator. Returns the number of beans that where saved.
    
    Specified by:
    
    save in interface EbeanServer
  - save
```
public int save(Collection<?> c)
```
    Perform an update or insert on each bean in the collection. Returns the number of beans that where saved.
    
    Specified by:
    
    save in interface EbeanServer
  - save
```
public int save(Iterator<?> it,
       Transaction t)
```
    Save all beans in the iterator with an explicit transaction.
    
    Specified by:
    
    save in interface EbeanServer
  - delete
```
public int delete(Class<?> beanType,
         Object id)
```
    Description copied from interface: EbeanServer
    
    Delete the bean given its type and id.
    
    Specified by:
    
    delete in interface EbeanServer
  - delete
```
public int delete(Class<?> beanType,
         Object id,
         Transaction t)
```
    Description copied from interface: EbeanServer
    
    Delete the bean given its type and id with an explicit transaction.
    
    Specified by:
    
    delete in interface EbeanServer
  - delete
```
public void delete(Class<?> beanType,
          Collection<?> ids)
```
    Description copied from interface: EbeanServer
    
    Delete several beans given their type and id values.
    
    Specified by:
    
    delete in interface EbeanServer
  - delete
```
public void delete(Class<?> beanType,
          Collection<?> ids,
          Transaction t)
```
    Description copied from interface: EbeanServer
    
    Delete several beans given their type and id values with an explicit transaction.
    
    Specified by:
    
    delete in interface EbeanServer
  - delete
```
public void delete(Object bean)
```
    Delete the bean.
    
    Specified by:
    
    delete in interface EbeanServer
    
    See Also:
    Ebean.delete(Object)
  - delete
```
public void delete(Object bean,
          Transaction t)
```
    Delete the bean with the explicit transaction.
    
    Specified by:
    
    delete in interface EbeanServer
  - delete
```
public int delete(Iterator<?> it)
```
    Delete all the beans in the iterator.
    
    Specified by:
    
    delete in interface EbeanServer
  - delete
```
public int delete(Collection<?> c)
```
    Delete all the beans in the collection.
    
    Specified by:
    
    delete in interface EbeanServer
  - delete
```
public int delete(Iterator<?> it,
         Transaction t)
```
    Delete all the beans in the iterator with an explicit transaction.
    
    Specified by:
    
    delete in interface EbeanServer
  - execute
```
public int execute(CallableSql callSql,
          Transaction t)
```
    Execute the CallableSql with an explicit transaction.
    
    Specified by:
    
    execute in interface EbeanServer
  - execute
```
public int execute(CallableSql callSql)
```
    Execute the CallableSql.
    
    Specified by:
    
    execute in interface EbeanServer
    
    See Also:
    Ebean.execute(CallableSql)
  - execute
```
public int execute(SqlUpdate updSql,
          Transaction t)
```
    Execute the updateSql with an explicit transaction.
    
    Specified by:
    
    execute in interface EbeanServer
  - execute
```
public int execute(SqlUpdate updSql)
```
    Execute the updateSql.
    
    Specified by:
    
    execute in interface EbeanServer
    
    See Also:
    Ebean.execute(SqlUpdate)
  - execute
```
public int execute(Update<?> update,
          Transaction t)
```
    Execute the updateSql with an explicit transaction.
    
    Specified by:
    
    execute in interface EbeanServer
  - execute
```
public int execute(Update<?> update)
```
    Execute the orm update.
    
    Specified by:
    
    execute in interface EbeanServer
  - getBeanManager
```
public <T> BeanManager<T> getBeanManager(Class<T> beanClass)
```
  - getBeanDescriptors
```
public List<BeanDescriptor<?>> getBeanDescriptors()
```
    Return all the BeanDescriptors.
    
    Specified by:
    
    getBeanDescriptors in interface SpiEbeanServer
  - getMetaBeanInfoList
```
public List<MetaBeanInfo> getMetaBeanInfoList()
```
  - register
```
public void register(BeanPersistController c)
```
  - deregister
```
public void deregister(BeanPersistController c)
```
  - isSupportedType
```
public boolean isSupportedType(Type genericType)
```
    Description copied from interface: SpiEbeanServer
    
    Return true if the type is known as an Entity or Xml type or a List Set or Map of known bean types.
    
    Specified by:
    
    isSupportedType in interface SpiEbeanServer
  - getBeanId
```
public Object getBeanId(Object bean)
```
    Description copied from interface: EbeanServer
    
    Return the value of the Id property for a given bean.
    
    Specified by:
    
    getBeanId in interface EbeanServer
  - getBeanDescriptor
```
public <T> BeanDescriptor<T> getBeanDescriptor(Class<T> beanClass)
```
    Return the BeanDescriptor for a given type of bean.
    
    Specified by:
    
    getBeanDescriptor in interface SpiEbeanServer
  - getBeanDescriptors
```
public List<BeanDescriptor<?>> getBeanDescriptors(String tableName)
```
    Return the BeanDescriptor's for a given table name.
    
    Specified by:
    
    getBeanDescriptors in interface SpiEbeanServer
  - getBeanDescriptorById
```
public BeanDescriptor<?> getBeanDescriptorById(String descriptorId)
```
    Return the BeanDescriptor using its unique id.
    
    Specified by:
    
    getBeanDescriptorById in interface SpiEbeanServer
  - remoteTransactionEvent
```
public void remoteTransactionEvent(RemoteTransactionEvent event)
```
    Another server in the cluster sent this event so that we can inform local BeanListeners of inserts updates and deletes that occurred remotely (on another server in the cluster).
    
    Specified by:
    
    remoteTransactionEvent in interface SpiEbeanServer
  - createServerTransaction
```
public SpiTransaction createServerTransaction(boolean isExplicit,
                                     int isolationLevel)
```
    Description copied from interface: SpiEbeanServer
    
    Create a ServerTransaction.
    To specify to use the default transaction isolation use a value of -1.
    
    Specified by:
    
    createServerTransaction in interface SpiEbeanServer
  - createQueryTransaction
```
public SpiTransaction createQueryTransaction()
```
    Description copied from interface: SpiEbeanServer
    
    Create a ServerTransaction for query purposes.
    
    Specified by:
    
    createQueryTransaction in interface SpiEbeanServer
  - createCallStack
```
public CallStack createCallStack()
```
    Create a CallStack object.
    This trims off the avaje ebean part of the stack trace so that the first element in the CallStack should be application code.
    
    Specified by:
    
    createCallStack in interface SpiEbeanServer
  - createJsonContext
```
public JsonContext createJsonContext()
```
    Description copied from interface: EbeanServer
    
    Create a JsonContext that will use the default configuration options.
    
    Specified by:
    
    createJsonContext in interface EbeanServer
  - collectQueryStats
```
public void collectQueryStats(ObjectGraphNode node,
                     long loadedBeanCount,
                     long timeMicros)
```
    Description copied from interface: SpiEbeanServer
    
    Collect query statistics by ObjectGraphNode. Used for Lazy loading reporting.
    
    Specified by:
    
    collectQueryStats in interface SpiEbeanServer

Class DefaultServer

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

objectGraphStats

Constructor Detail

DefaultServer

Method Detail

loadAndInitializePlugins

getSpiEbeanPlugins

executePlugins

isCollectQueryOrigins

isDefaultDeleteMissingChildren

isDefaultUpdateNullProperties

getLazyLoadBatchSize

getPstmtBatch

getDatabasePlatform

getMetaInfoManager

getBackgroundExecutor

getExpressionFactory

getDdlGenerator

getAdminAutofetch

getAutoFetchManager

initialise

start

registerMBeans

shutdownManaged

shutdown

getName

getBeanState

runCacheWarming

runCacheWarming

compileQuery

getQueryEngine

getServerCacheManager

getProfileListener

getRelationalQueryEngine

refreshMany

refreshMany

loadMany

loadMany

refresh

loadBean

loadBean

diff

externalModification

externalModification

clearQueryStatistics

createEntityBean

getReference

createTransaction

createTransaction

execute

execute

execute

execute

createScopeTrans

getCurrentServerTransaction

beginTransaction

beginTransaction

currentTransaction

commitTransaction

rollbackTransaction

endTransaction

nextId

sort

createQuery

createNamedQuery

filter

createCsvReader

find

createQuery

createNamedUpdate

createUpdate

createSqlQuery

createNamedSqlQuery

createSqlUpdate

createCallableSql