SessionBroker (EclipseLink 2.6.0, API Reference)

java.lang.Object
- org.eclipse.persistence.internal.core.sessions.CoreAbstractSession<ClassDescriptor,Login,org.eclipse.persistence.internal.databaseaccess.Platform,Project,SessionEventManager>
- - org.eclipse.persistence.internal.sessions.AbstractSession
  - - org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
    - - org.eclipse.persistence.sessions.broker.SessionBroker

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, CoreSession<ClassDescriptor,Login,org.eclipse.persistence.internal.databaseaccess.Platform,Project,SessionEventManager>, CommandProcessor, DatabaseSession, Session
```
public class SessionBroker
extends org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
```
Purpose: Provide a single view to a TopLink session that transparently accesses multple databases.
Responsibilities:
- Broker queries to the appropriate child sessions.
- Use a simplified two-stage commit policy on commit of transaction.
- Support brokered units of work.
See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected SessionBroker`	`parent`
`protected org.eclipse.persistence.internal.sequencing.Sequencing`	`sequencing`
`protected java.util.Map<java.lang.Class,java.lang.String>`	`sessionNamesByClass`
`protected java.util.Map<java.lang.String,org.eclipse.persistence.internal.sessions.AbstractSession>`	`sessionsByName`
`protected boolean`	`shouldUseDescriptorAliases`

Fields inherited from class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
connectedTime, databaseEventListener, isLoggedIn, sequencingHome, serverPlatform, tuner

Fields inherited from class org.eclipse.persistence.internal.sessions.AbstractSession
accessors, activeCommandThreads, attributeGroups, broker, commandManager, commitManager, defaultReferenceMode, deferredEvents, descriptors, entityListenerInjectionManager, eventManager, exceptionHandler, externalTransactionController, identityMapAccessor, integrityChecker, isConcurrent, isExecutingEvents, isFinalizersEnabled, isInBroker, isInProfile, isLoggingOff, isSynchronized, jpaQueriesProcessed, lastDescriptorAccessed, logSessionString, metadatalistener, multitenantContextProperties, name, numberOfActiveUnitsOfWork, objectsLockedForClone, partitioningPolicy, pessimisticLockTimeoutDefault, platform, profiler, project, properties, queries, queryBuilder, queryTimeoutDefault, serializer, sessionLog, shouldCheckWriteLock, shouldOptimizeResultSetAccess, shouldPropagateChanges, staticMetamodelClasses, tablePerTenantDescriptors, tablePerTenantQueries, tolerateInvalidJPQL, transactionMutex, wasJTSTransactionInternallyStarted

Fields inherited from interface org.eclipse.persistence.sessions.coordination.CommandProcessor
LOG_DEBUG, LOG_ERROR, LOG_INFO, LOG_WARNING

Constructor Summary

Constructors
Modifier	Constructor and Description
	`SessionBroker()` PUBLIC: Create and return a session broker.
`protected`	`SessionBroker(java.util.Map sessionNames)` INTERNAL: Create and return a session broker.

Method Summary

Methods
Modifier and Type	Method and Description
`SessionBroker`	`acquireClientSessionBroker()` PUBLIC: Return a session broker that behaves as a client session broker.
`SessionBroker`	`acquireClientSessionBroker(java.util.Map<java.lang.String,ConnectionPolicy> connectionPolicies, java.util.Map mapOfProperties)` PUBLIC: Return a session broker that behaves as a client session broker.
`Session`	`acquireHistoricalSession(AsOfClause clause)` INTERNAL: Acquires a special historical session for reading objects as of a past time.
`org.eclipse.persistence.internal.sessions.UnitOfWorkImpl`	`acquireUnitOfWork()` PUBLIC: Return a unit of work for this session broker.
`void`	`addDescriptor(ClassDescriptor descriptor)` PUBLIC: You cannot add a descriptor to a session broker, you must add it to its session.
`void`	`addDescriptors(Project project)` PUBLIC: You cannot add a project to a session broker, you must add it to its session.
`void`	`addDescriptors(java.util.Vector descriptors)` PUBLIC: You cannot add descriptors to a session broker, you must add them to its session.
`void`	`addSequence(Sequence sequence)` PUBLIC: You cannot add a sequence to a session broker, you must add it to its session.
`protected void`	`basicBeginTransaction()` INTERNAL: Begin the transaction on all child sessions.
`protected void`	`basicCommitTransaction()` INTERNAL: Commit the transaction on all child sessions.
`protected void`	`basicRollbackTransaction()` INTERNAL: Rollback the transaction on all child sessions.
`boolean`	`containsQuery(java.lang.String queryName)` PUBLIC: Return true if the pre-defined query is defined on the session.
`protected SessionBroker`	`copySessionBroker()` INTERNAL: Return a copy (not using clone) of a session broker.
`java.util.Collection<org.eclipse.persistence.internal.databaseaccess.Accessor>`	`getAccessors(Call call, org.eclipse.persistence.internal.sessions.AbstractRecord translationRow, DatabaseQuery query)` INTERNAL: Return the low-level database accessors.
`AsOfClause`	`getAsOfClause()` ADVANCED: Answers the past time this session is as of.
`org.eclipse.persistence.internal.sessions.AbstractSession`	`getExecutionSession(DatabaseQuery query)` INTERNAL: Gets the session which this query will be executed on.
`SessionBroker`	`getParent()` INTERNAL: Gets the parent SessionBroker.
`org.eclipse.persistence.internal.databaseaccess.Platform`	`getPlatform(java.lang.Class domainClass)` INTERNAL: Return the platform for a particular class.
`DatabaseQuery`	`getQuery(java.lang.String name, java.util.Vector arguments, boolean shouldSearchParent)` PUBLIC: Return the query from the session pre-defined queries with the given name and argument types.
`org.eclipse.persistence.internal.sequencing.Sequencing`	`getSequencing()` PUBLIC: Return the Sequencing object used by the session.
`protected org.eclipse.persistence.internal.sequencing.SequencingHome`	`getSequencingHome()` PROTECTED: Session broker doesn't have SequencingHome.
`org.eclipse.persistence.internal.sessions.AbstractSession`	`getSessionForClass(java.lang.Class domainClass)` INTERNAL: Return the session to be used for the class.
`org.eclipse.persistence.internal.sessions.AbstractSession`	`getSessionForName(java.lang.String name)` INTERNAL: Return the session by name.
`protected org.eclipse.persistence.internal.sessions.AbstractSession`	`getSessionForQuery(DatabaseQuery query)` INTERNAL: Answers the session to be used for the given query.
`protected java.util.Map<java.lang.Class,java.lang.String>`	`getSessionNamesByClass()` INTERNAL: Return sessions indexed by class, each class can only have one default session.
`java.util.Map<java.lang.String,org.eclipse.persistence.internal.sessions.AbstractSession>`	`getSessionsByName()` INTERNAL: Return sessions indexed by name.
`int`	`howManySequencingCallbacks()` INTERNAL: Returns a number of member sessions that require sequencing callback.
`void`	`initializeDescriptors()` INTERNAL: Allow each descriptor to initialize any dependencies on this session.
`void`	`initializeIdentityMapAccessor()` INTERNAL: Set up the IdentityMapManager.
`void`	`initializeSequencing()` ADVANCED: Creates sequencing object for the session broker.
`java.lang.Object`	`internalExecuteQuery(DatabaseQuery query, org.eclipse.persistence.internal.sessions.AbstractRecord row)` INTERNAL: Return the results from exeucting the database query.
`boolean`	`isBroker()` INTERNAL: Returns true if the session is a session Broker.
`boolean`	`isClientSessionBroker()` PUBLIC: Return if this session is a client session broker.
`boolean`	`isConnected()` PUBLIC: Return if all sessions are still connected to the database.
`boolean`	`isSequencingCallbackRequired()` INTERNAL: Indicates whether SequencingCallback is required.
`boolean`	`isServerSessionBroker()` PUBLIC: Return if this session is a server session broker.
`boolean`	`isSessionBroker()` INTERNAL: Return if this session is a session broker.
`void`	`login()` PUBLIC: Connect to the database using the predefined login.
`void`	`login(java.lang.String userName, java.lang.String password)` PUBLIC: Connect to the database using the predefined login.
`void`	`loginAndDetectDatasource()` PUBLIC: Connect to the database using the predefined login.
`void`	`logout()` PUBLIC: Disconnect from all databases.
`void`	`postLogin()` INTERNAL: Rise postLogin events for member sessions and the SessionBroker.
`void`	`registerSession(java.lang.String name, org.eclipse.persistence.internal.sessions.AbstractSession session)` PUBLIC: Register the session under its name.
`void`	`registerSession(java.lang.String name, Session session)` PUBLIC: Register the session under its name.
`void`	`release()` PUBLIC: Release the session.
`void`	`releaseJTSConnection()` INTERNAL: Called in the end of beforeCompletion of external transaction sychronization listener.
`java.lang.Object`	`retryQuery(DatabaseQuery query, org.eclipse.persistence.internal.sessions.AbstractRecord row, DatabaseException databaseException, int retryCount, org.eclipse.persistence.internal.sessions.AbstractSession executionSession)` INTERNAL: A query execution failed due to an invalid query.
`void`	`setExternalTransactionController(ExternalTransactionController externalTransactionController)` INTERNAL: Used for JTS integration internally by ServerPlatform.
`void`	`setIntegrityChecker(IntegrityChecker integrityChecker)` PUBLIC: set the integrityChecker.
`void`	`setLog(java.io.Writer log)` PUBLIC: Set the message log.
`void`	`setProfiler(SessionProfiler profiler)` PUBLIC: Set the profiler for the session.
`void`	`setSessionLog(SessionLog log)` PUBLIC: Set the session log.
`protected void`	`setSessionNameByClass(java.util.HashMap sessionNameByClass)` INTERNAL: Set sessions indexed by class, each class can only have one default session.
`void`	`setSessionsByName(java.util.Map sessionsByName)` INTERNAL: Set sessions indexed by name.
`void`	`setShouldUseDescriptorAliases(boolean shouldUseDescriptorAliases)` PUBLIC: Indicates whether descriptors should use aliasDescriptors map.
`void`	`setSynchronized(boolean synched)` INTERNAL: Set isSynchronized flag to indicate that members of session broker are synchronized.
`boolean`	`shouldUseDescriptorAliases()` PUBLIC: Indicates whether descriptors should use aliasDescriptors map.
`void`	`writesCompleted()` INTERNAL: This method notifies the accessor that a particular sets of writes has completed.

Methods inherited from class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
addDescriptors, addDescriptorsToSequencing, connect, disconnect, finalize, getConnectedTime, getDatabaseEventListener, getDatasourcePlatform, getPlatform, getReadLogin, getSequencingControl, getServerPlatform, getTuner, initializeConnectedTime, initializeDescriptorIfSessionAlive, initializeDescriptors, initializeDescriptors, initializeDescriptors, initializeDescriptors, isDatabaseSession, isLoggedIn, isProtectedSession, login, postConnectDatasource, preConnectDatasource, setDatabaseEventListener, setDatasourceAndInitialize, setOrDetectDatasource, setSequencingHome, setServerPlatform, setTuner, writeAllObjects, writeAllObjects

Methods inherited from class org.eclipse.persistence.internal.sessions.AbstractSession
acquireNonSynchronizedUnitOfWork, acquireNonSynchronizedUnitOfWork, acquireRepeatableWriteUnitOfWork, acquireUnitOfWork, addAlias, addJPAQuery, addJPATablePerTenantQuery, addMultitenantContextProperty, addQuery, addQuery, addQuery, addStaticMetamodelClass, addTablePerTenantDescriptor, addTablePerTenantQuery, basicBeginTransaction, basicExecuteCall, beginExternalTransaction, beginTransaction, buildDefaultQueryBuilder, checkAndRefreshInvalidObject, checkHierarchyForDescriptor, cleanUpEntityListenerInjectionManager, clearDescriptors, clearIntegrityChecker, clearLastDescriptorAccessed, clearProfile, clone, commitExternalTransaction, commitTransaction, compareObjects, compareObjectsDontMatch, config, copy, copy, copyDescriptorNamedQueries, copyDescriptorsFromProject, copyInternal, copyObject, copyObject, copyReadOnlyClasses, createCloneQueryValueHolder, createCloneTransformationValueHolder, createEntityListenerInjectionManager, createProtectedInstanceFromCachedData, deferEvent, deleteAllObjects, deleteAllObjects, deleteObject, doesObjectExist, dontLogMessages, endOperationProfile, endOperationProfile, executeCall, executeDeferredEvents, executeNonSelectingCall, executeNonSelectingSQL, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeSelectingCall, executeSQL, fine, finer, finest, getAccessor, getAccessors, getActiveCommandThreads, getActiveSession, getActiveUnitOfWork, getAliasDescriptors, getAllQueries, getAttributeGroups, getBroker, getCacheKeyFromTargetSessionForMerge, getClassDescriptor, getClassDescriptor, getClassDescriptorForAlias, getCommandManager, getCommitManager, getDatasourceLogin, getDefaultReadOnlyClasses, getDefaultReferenceMode, getDescriptor, getDescriptor, getDescriptorForAlias, getDescriptors, getEntityListenerInjectionManager, getEventManager, getExceptionHandler, getExceptionHandlerClass, getExternalTransactionController, getId, getIdentityMapAccessor, getIdentityMapAccessorInstance, getIntegrityChecker, getJPAQueries, getJPATablePerTenantQueries, getLoader, getLog, getLogin, getLogLevel, getLogLevel, getLogSessionString, getMappedSuperclass, getMultitenantContextProperties, getName, getNextQueryId, getNextSequenceNumberValue, getNumberOfActiveUnitsOfWork, getParentIdentityMapSession, getParentIdentityMapSession, getParentIdentityMapSession, getPartitioningPolicy, getPessimisticLockTimeoutDefault, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, getQuery, getQuery, getQueryBuilder, getQueryTimeoutDefault, getRefreshMetadataListener, getRootSession, getSerializer, getSessionLog, getSessionTypeString, getStaticMetamodelClass, getTablePerTenantDescriptors, getTablePerTenantQueries, getTransactionMutex, handleException, handleSevere, hasBroker, hasCommitManager, hasDescriptor, hasEventManager, hasExceptionHandler, hasExternalTransactionController, hasProperties, hasTablePerTenantDescriptors, hasTablePerTenantQueries, incrementProfile, incrementProfile, info, insertObject, isClassReadOnly, isClassReadOnly, isClientSession, isConcurrent, isConsideredInvalid, isDistributedSession, isExclusiveConnectionRequired, isExclusiveIsolatedClientSession, isFinalizersEnabled, isHistoricalSession, isInBroker, isInProfile, isInTransaction, isIsolatedClientSession, isJPAQueriesProcessed, isLoggingOff, isRemoteSession, isRemoteUnitOfWork, isServerSession, isSynchronized, isUnitOfWork, keyFromObject, keyFromObject, load, load, log, log, log, log, log, log, log, log, log, log, logMessage, logMessage, logThrowable, postAcquireConnection, prepareDatabaseQuery, preReleaseConnection, priviledgedExecuteNonSelectingCall, priviledgedExecuteSelectingCall, processCommand, processJPAQueries, processJPAQuery, readAllObjects, readAllObjects, readAllObjects, readAllObjects, readObject, readObject, readObject, readObject, readObject, refreshAndLockObject, refreshAndLockObject, refreshObject, registerFinalizer, releaseConnectionAfterCall, releaseReadConnection, releaseUnitOfWork, removeProperty, removeQuery, removeQuery, retrieveCacheKey, retryTransaction, rollbackExternalTransaction, rollbackTransaction, setAccessor, setBroker, setCommandManager, setCommitManager, setDatasourceLogin, setDefaultReferenceMode, setEntityListenerInjectionManager, setEventManager, setExceptionHandler, setIsConcurrent, setIsFinalizersEnabled, setIsInBroker, setIsInProfile, setJPAQueriesProcessed, setLoggingOff, setLogin, setLogin, setLogLevel, setName, setNumberOfActiveUnitsOfWork, setPartitioningPolicy, setPessimisticLockTimeoutDefault, setProject, setProperties, setProperty, setQueries, setQueryBuilder, setQueryTimeoutDefault, setRefreshMetadataListener, setSerializer, setShouldOptimizeResultSetAccess, setShouldPropagateChanges, setTolerateInvalidJPQL, setTransactionMutex, setWasJTSTransactionInternallyStarted, severe, shouldDisplayData, shouldLog, shouldLogMessages, shouldLogMessages, shouldOptimizeResultSetAccess, shouldPropagateChanges, shouldTolerateInvalidJPQL, startOperationProfile, startOperationProfile, toString, unwrapObject, updateObject, updateProfile, updateTablePerTenantDescriptors, validateCache, validateQuery, verifyDelete, warning, wasJTSTransactionInternallyStarted, wrapObject, writeAllObjectsWithChangeSet, writeObject

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

Methods inherited from interface org.eclipse.persistence.sessions.DatabaseSession
beginTransaction, commitTransaction, deleteAllObjects, deleteObject, getCommandManager, insertObject, isInTransaction, refreshAndLockObject, refreshAndLockObject, rollbackTransaction, setCommandManager, setDatasourceLogin, setLogin, setShouldPropagateChanges, shouldPropagateChanges, updateObject, writeObject

Methods inherited from interface org.eclipse.persistence.sessions.Session
acquireUnitOfWork, addJPAQuery, addQuery, clearIntegrityChecker, clearProfile, copy, copy, copyObject, copyObject, doesObjectExist, dontLogMessages, executeNonSelectingCall, executeNonSelectingSQL, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeSelectingCall, executeSQL, getActiveSession, getActiveUnitOfWork, getClassDescriptor, getClassDescriptor, getClassDescriptorForAlias, getDatasourceLogin, getDefaultReferenceMode, getDescriptor, getDescriptor, getDescriptorForAlias, getDescriptors, getEventManager, getExceptionHandler, getExternalTransactionController, getId, getIdentityMapAccessor, getIntegrityChecker, getJPAQueries, getLog, getLogin, getLogLevel, getLogLevel, getName, getNextSequenceNumberValue, getPartitioningPolicy, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, getQuery, getSerializer, getSessionLog, handleException, handleSevere, hasDescriptor, hasExceptionHandler, hasExternalTransactionController, isClientSession, isDistributedSession, isFinalizersEnabled, isInProfile, isRemoteSession, isRemoteUnitOfWork, isServerSession, isUnitOfWork, keyFromObject, log, logMessage, readAllObjects, readAllObjects, readAllObjects, readObject, readObject, readObject, readObject, refreshObject, removeProperty, removeQuery, setDefaultReferenceMode, setExceptionHandler, setIsFinalizersEnabled, setLogLevel, setName, setPartitioningPolicy, setProperty, setQueryTimeoutDefault, setSerializer, shouldLog, shouldLogMessages, validateCache

- Field Detail
  - parent
```
protected SessionBroker parent
```
  - sessionNamesByClass
```
protected java.util.Map<java.lang.Class,java.lang.String> sessionNamesByClass
```
  - sessionsByName
```
protected java.util.Map<java.lang.String,org.eclipse.persistence.internal.sessions.AbstractSession> sessionsByName
```
  - sequencing
```
protected org.eclipse.persistence.internal.sequencing.Sequencing sequencing
```
  - shouldUseDescriptorAliases
```
protected boolean shouldUseDescriptorAliases
```
- Constructor Detail
  - SessionBroker
```
public SessionBroker()
```
    PUBLIC: Create and return a session broker. Because a session broker has multiple sessions it does not used a login.
  - SessionBroker
```
protected SessionBroker(java.util.Map sessionNames)
```
    INTERNAL: Create and return a session broker. Used internally to set the Names by Class from the parent. Reduces garbage.
- Method Detail
  - acquireClientSessionBroker
```
public SessionBroker acquireClientSessionBroker()
```
    PUBLIC: Return a session broker that behaves as a client session broker. An acquire session broker is done under the covers on each session inside the session broker, and a new broker is returned. NOTE: when finished with the client broker, it should be released.
  - acquireClientSessionBroker
```
public SessionBroker acquireClientSessionBroker(java.util.Map<java.lang.String,ConnectionPolicy> connectionPolicies,
                                       java.util.Map mapOfProperties)
```
    PUBLIC: Return a session broker that behaves as a client session broker. An acquire session broker is done under the covers on each session inside the session broker, and a new broker is returned. NOTE: when finished with the client broker, it should be released.
    
    Parameters:
    connectionPolicies - maps session name to connectionPolicy to be used for this session;
    mapOfProperties - maps session name to properties to be used for this session.
  - acquireHistoricalSession
```
public Session acquireHistoricalSession(AsOfClause clause)
                                 throws ValidationException
```
    INTERNAL: Acquires a special historical session for reading objects as of a past time.
    
    Specified by:
    
    acquireHistoricalSession in interface Session
    
    Overrides:
    
    acquireHistoricalSession in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Parameters:
    clause - Represents a valid snap shot time.
    
    Throws:
    
    ValidationException - if this not a ClientSession, plain Session, or SessionBroker.
    See Also:
    AsOfClause, Expression.asOf(org.eclipse.persistence.history.AsOfClause), ObjectLevelReadQuery.setAsOfClause(org.eclipse.persistence.history.AsOfClause), HistoryPolicy
  - releaseJTSConnection
```
public void releaseJTSConnection()
```
    INTERNAL: Called in the end of beforeCompletion of external transaction sychronization listener. Close the managed sql connection corresponding to the external transaction, if applicable releases accessor.
    
    Overrides:
    
    releaseJTSConnection in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - acquireUnitOfWork
```
public org.eclipse.persistence.internal.sessions.UnitOfWorkImpl acquireUnitOfWork()
```
    PUBLIC: Return a unit of work for this session broker. Acquire a client session broker if is a server session broker.
    
    Specified by:
    
    acquireUnitOfWork in interface Session
    
    Overrides:
    
    acquireUnitOfWork in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    See Also:
    UnitOfWorkImpl
  - addDescriptor
```
public void addDescriptor(ClassDescriptor descriptor)
```
    PUBLIC: You cannot add a descriptor to a session broker, you must add it to its session.
    
    Specified by:
    
    addDescriptor in interface DatabaseSession
    
    Overrides:
    
    addDescriptor in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
    
    See Also:
    DatabaseSession.addDescriptors(Collection), DatabaseSession.addDescriptors(Project)
  - addDescriptors
```
public void addDescriptors(java.util.Vector descriptors)
                    throws ValidationException
```
    PUBLIC: You cannot add descriptors to a session broker, you must add them to its session.
    
    Throws:
    
    ValidationException
  - addDescriptors
```
public void addDescriptors(Project project)
                    throws ValidationException
```
    PUBLIC: You cannot add a project to a session broker, you must add it to its session.
    
    Specified by:
    
    addDescriptors in interface DatabaseSession
    
    Overrides:
    
    addDescriptors in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
    
    Throws:
    
    ValidationException
  - addSequence
```
public void addSequence(Sequence sequence)
```
    PUBLIC: You cannot add a sequence to a session broker, you must add it to its session.
    
    Specified by:
    
    addSequence in interface DatabaseSession
    
    Overrides:
    
    addSequence in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
    
    See Also:
    DatabaseSession.addDescriptor(org.eclipse.persistence.descriptors.ClassDescriptor), DatabaseSession.addDescriptors(java.util.Collection)
  - basicBeginTransaction
```
protected void basicBeginTransaction()
                              throws DatabaseException
```
    INTERNAL: Begin the transaction on all child sessions.
    
    Overrides:
    
    basicBeginTransaction in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Throws:
    
    DatabaseException
  - basicCommitTransaction
```
protected void basicCommitTransaction()
                               throws DatabaseException
```
    INTERNAL: Commit the transaction on all child sessions. This assumes that the commit of the transaction will not fail because all of the modification has already taken place and no errors would have occurred.
    
    Overrides:
    
    basicCommitTransaction in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Throws:
    
    DatabaseException
  - basicRollbackTransaction
```
protected void basicRollbackTransaction()
                                 throws DatabaseException
```
    INTERNAL: Rollback the transaction on all child sessions.
    
    Overrides:
    
    basicRollbackTransaction in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Throws:
    
    DatabaseException
  - containsQuery
```
public boolean containsQuery(java.lang.String queryName)
```
    PUBLIC: Return true if the pre-defined query is defined on the session.
    
    Specified by:
    
    containsQuery in interface Session
    
    Overrides:
    
    containsQuery in class org.eclipse.persistence.internal.sessions.AbstractSession
  - copySessionBroker
```
protected SessionBroker copySessionBroker()
```
    INTERNAL: Return a copy (not using clone) of a session broker.
  - getAccessors
```
public java.util.Collection<org.eclipse.persistence.internal.databaseaccess.Accessor> getAccessors(Call call,
                                                                                          org.eclipse.persistence.internal.sessions.AbstractRecord translationRow,
                                                                                          DatabaseQuery query)
```
    INTERNAL: Return the low-level database accessors. The database accessor is used for direct database access. The right accessor for this broker will be returned.
    
    Overrides:
    
    getAccessors in class org.eclipse.persistence.internal.sessions.AbstractSession
  - getAsOfClause
```
public AsOfClause getAsOfClause()
```
    ADVANCED: Answers the past time this session is as of. Only meaningful for special historical sessions.
    
    Specified by:
    
    getAsOfClause in interface Session
    
    Overrides:
    
    getAsOfClause in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Returns:
    An immutable object representation of the past time. null if no clause set, or this a regular session.
    See Also:
    AsOfClause, acquireHistoricalSession(AsOfClause), Expression.hasAsOfClause()
  - getParent
```
public SessionBroker getParent()
```
    INTERNAL: Gets the parent SessionBroker.
    
    Overrides:
    
    getParent in class org.eclipse.persistence.internal.sessions.AbstractSession
  - getExecutionSession
```
public org.eclipse.persistence.internal.sessions.AbstractSession getExecutionSession(DatabaseQuery query)
```
    INTERNAL: Gets the session which this query will be executed on. Generally will be called immediately before the call is translated, which is immediately before session.executeCall.
    Since the execution session also knows the correct datasource platform to execute on, it is often used in the mappings where the platform is needed for type conversion, or where calls are translated.
    Is also the session with the accessor. Will return a ClientSession if it is in transaction and has a write connection.
    
    Overrides:
    
    getExecutionSession in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Parameters:
    query - may store session name or reference class for brokers case
    
    Returns:
    a session with a live accessor
  - getPlatform
```
public org.eclipse.persistence.internal.databaseaccess.Platform getPlatform(java.lang.Class domainClass)
```
    INTERNAL: Return the platform for a particular class.
    
    Overrides:
    
    getPlatform in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - getQuery
```
public DatabaseQuery getQuery(java.lang.String name,
                     java.util.Vector arguments,
                     boolean shouldSearchParent)
```
    PUBLIC: Return the query from the session pre-defined queries with the given name and argument types. This allows for common queries to be pre-defined, reused and executed by name. This method should be used if the Session has multiple queries with the same name but different arguments. The search order is: for ClientSessionBroker: the broker; it's member ClientSessions (but not their parent ServerSessions); the parent SessionBroker. for ServerSession or DatabaseSession SessionBroker: the broker; it's member ServerSessions (or DatabaseSessions).
    
    Overrides:
    
    getQuery in class org.eclipse.persistence.internal.sessions.AbstractSession
  - getSessionForClass
```
public org.eclipse.persistence.internal.sessions.AbstractSession getSessionForClass(java.lang.Class domainClass)
                                                                             throws ValidationException
```
    INTERNAL: Return the session to be used for the class.
    
    Overrides:
    
    getSessionForClass in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Throws:
    
    ValidationException
  - getSessionForName
```
public org.eclipse.persistence.internal.sessions.AbstractSession getSessionForName(java.lang.String name)
                                                                            throws ValidationException
```
    INTERNAL: Return the session by name.
    
    Overrides:
    
    getSessionForName in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Throws:
    
    ValidationException
  - getSessionForQuery
```
protected org.eclipse.persistence.internal.sessions.AbstractSession getSessionForQuery(DatabaseQuery query)
```
    INTERNAL: Answers the session to be used for the given query.
  - getSessionNamesByClass
```
protected java.util.Map<java.lang.Class,java.lang.String> getSessionNamesByClass()
```
    INTERNAL: Return sessions indexed by class, each class can only have one default session.
  - getSessionsByName
```
public java.util.Map<java.lang.String,org.eclipse.persistence.internal.sessions.AbstractSession> getSessionsByName()
```
    INTERNAL: Return sessions indexed by name.
  - initializeDescriptors
```
public void initializeDescriptors()
```
    INTERNAL: Allow each descriptor to initialize any dependencies on this session. This is done in two passes to allow the inheritance to be resolved first. Normally the descriptors are added before login, then initialized on login. Should not be called on client SessoionBroker
    
    Overrides:
    
    initializeDescriptors in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - initializeIdentityMapAccessor
```
public void initializeIdentityMapAccessor()
```
    INTERNAL: Set up the IdentityMapManager. This method allows subclasses of Session to override the default IdentityMapManager functionality.
    
    Overrides:
    
    initializeIdentityMapAccessor in class org.eclipse.persistence.internal.sessions.AbstractSession
  - internalExecuteQuery
```
public java.lang.Object internalExecuteQuery(DatabaseQuery query,
                                    org.eclipse.persistence.internal.sessions.AbstractRecord row)
                                      throws DatabaseException,
                                             QueryException
```
    INTERNAL: Return the results from exeucting the database query. the arguments should be a database row with raw data values. Find the correct child session to broker the query to, and return the result of the session executing the query.
    
    Overrides:
    
    internalExecuteQuery in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Throws:
    
    DatabaseException
    
    QueryException
  - isBroker
```
public boolean isBroker()
```
    INTERNAL: Returns true if the session is a session Broker.
    
    Overrides:
    
    isBroker in class org.eclipse.persistence.internal.sessions.AbstractSession
  - isClientSessionBroker
```
public boolean isClientSessionBroker()
```
    PUBLIC: Return if this session is a client session broker.
  - isConnected
```
public boolean isConnected()
```
    PUBLIC: Return if all sessions are still connected to the database.
    
    Specified by:
    
    isConnected in interface Session
    
    Overrides:
    
    isConnected in class org.eclipse.persistence.internal.sessions.AbstractSession
  - isServerSessionBroker
```
public boolean isServerSessionBroker()
```
    PUBLIC: Return if this session is a server session broker.
  - isSessionBroker
```
public boolean isSessionBroker()
```
    INTERNAL: Return if this session is a session broker.
    
    Specified by:
    
    isSessionBroker in interface Session
    
    Overrides:
    
    isSessionBroker in class org.eclipse.persistence.internal.sessions.AbstractSession
  - login
```
public void login()
           throws DatabaseException
```
    PUBLIC: Connect to the database using the predefined login. This connects all of the child sessions and expects that they are in a valid state to be connected.
    
    Specified by:
    
    login in interface DatabaseSession
    
    Overrides:
    
    login in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
    
    Throws:
    
    DatabaseException
    See Also:
    DatabaseSession.login(Login)
  - loginAndDetectDatasource
```
public void loginAndDetectDatasource()
                              throws DatabaseException
```
    PUBLIC: Connect to the database using the predefined login. During connection, attempt to auto detect the required database platform. This method can be used in systems where for ease of use developers have EclipseLink autodetect the platform. To be safe, however, the platform should be configured directly. The login must have been assigned when or after creating the session.
    
    Overrides:
    
    loginAndDetectDatasource in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
    
    Throws:
    
    DatabaseException
  - login
```
public void login(java.lang.String userName,
         java.lang.String password)
           throws DatabaseException
```
    PUBLIC: Connect to the database using the predefined login. This connects all of the child sessions and expects that they are in a valid state to be connected.
    
    Specified by:
    
    login in interface DatabaseSession
    
    Overrides:
    
    login in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
    
    Throws:
    
    DatabaseException
  - logout
```
public void logout()
            throws DatabaseException
```
    PUBLIC: Disconnect from all databases.
    
    Specified by:
    
    logout in interface DatabaseSession
    
    Overrides:
    
    logout in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
    
    Throws:
    
    EclipseLinkException - if a transaction is active, you must rollback any active transaction before logout.
    
    DatabaseException - the database will also raise an error if their is an active transaction, or a general error occurs.
  - postLogin
```
public void postLogin()
```
    INTERNAL: Rise postLogin events for member sessions and the SessionBroker.
    
    Overrides:
    
    postLogin in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - registerSession
```
public void registerSession(java.lang.String name,
                   org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    PUBLIC: Register the session under its name. All of the session's descriptors must have already been registered. DatabaseSession/ServerSession should not be connected and descriptors should not be initialized.
  - registerSession
```
public void registerSession(java.lang.String name,
                   Session session)
```
    PUBLIC: Register the session under its name. All of the session's descriptors must have already been registered. DatabaseSession/ServerSession should not be connected and descriptors should not be initialized.
  - release
```
public void release()
```
    PUBLIC: Release the session. This does nothing by default, but allows for other sessions such as the ClientSession to do something.
    
    Specified by:
    
    release in interface Session
    
    Overrides:
    
    release in class org.eclipse.persistence.internal.sessions.AbstractSession
  - retryQuery
```
public java.lang.Object retryQuery(DatabaseQuery query,
                          org.eclipse.persistence.internal.sessions.AbstractRecord row,
                          DatabaseException databaseException,
                          int retryCount,
                          org.eclipse.persistence.internal.sessions.AbstractSession executionSession)
```
    INTERNAL: A query execution failed due to an invalid query. Re-connect and retry the query.
    
    Overrides:
    
    retryQuery in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - setExternalTransactionController
```
public void setExternalTransactionController(ExternalTransactionController externalTransactionController)
```
    INTERNAL: Used for JTS integration internally by ServerPlatform.
    
    Specified by:
    
    setExternalTransactionController in interface DatabaseSession
    
    Specified by:
    
    setExternalTransactionController in interface Session
    
    Overrides:
    
    setExternalTransactionController in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    See Also:
    CustomServerPlatform
  - setIntegrityChecker
```
public void setIntegrityChecker(IntegrityChecker integrityChecker)
```
    PUBLIC: set the integrityChecker. IntegrityChecker holds all the ClassDescriptor Exceptions.
    
    Specified by:
    
    setIntegrityChecker in interface Session
    
    Overrides:
    
    setIntegrityChecker in class org.eclipse.persistence.internal.sessions.AbstractSession
  - setSessionLog
```
public void setSessionLog(SessionLog log)
```
    PUBLIC: Set the session log.
    
    Specified by:
    
    setSessionLog in interface Session
    
    Overrides:
    
    setSessionLog in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    See Also:
    AbstractSession.logMessage(java.lang.String)
  - setLog
```
public void setLog(java.io.Writer log)
```
    PUBLIC: Set the message log.
    
    Specified by:
    
    setLog in interface Session
    
    Overrides:
    
    setLog in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    See Also:
    AbstractSession.logMessage(java.lang.String)
  - setProfiler
```
public void setProfiler(SessionProfiler profiler)
```
    PUBLIC: Set the profiler for the session. This allows for performance operations to be profiled.
    
    Specified by:
    
    setProfiler in interface Session
    
    Overrides:
    
    setProfiler in class org.eclipse.persistence.internal.sessions.AbstractSession
  - setSessionNameByClass
```
protected void setSessionNameByClass(java.util.HashMap sessionNameByClass)
```
    INTERNAL: Set sessions indexed by class, each class can only have one default session.
  - setSessionsByName
```
public void setSessionsByName(java.util.Map sessionsByName)
```
    INTERNAL: Set sessions indexed by name.
  - setSynchronized
```
public void setSynchronized(boolean synched)
```
    INTERNAL: Set isSynchronized flag to indicate that members of session broker are synchronized. This method should only be called by setSynchronized method of UnitOfWork obtained from either DatabaseSession Broker or ClientSession Broker.
    
    Overrides:
    
    setSynchronized in class org.eclipse.persistence.internal.sessions.AbstractSession
  - writesCompleted
```
public void writesCompleted()
```
    INTERNAL: This method notifies the accessor that a particular sets of writes has completed. This notification can be used for such thing as flushing the batch mechanism
    
    Overrides:
    
    writesCompleted in class org.eclipse.persistence.internal.sessions.AbstractSession
  - initializeSequencing
```
public void initializeSequencing()
```
    ADVANCED: Creates sequencing object for the session broker. Typically there is no need for the user to call this method - it is called by login() and acquireClientSessionBroker.
    
    Overrides:
    
    initializeSequencing in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - getSequencingHome
```
protected org.eclipse.persistence.internal.sequencing.SequencingHome getSequencingHome()
```
    PROTECTED: Session broker doesn't have SequencingHome.
    
    Overrides:
    
    getSequencingHome in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - getSequencing
```
public org.eclipse.persistence.internal.sequencing.Sequencing getSequencing()
```
    PUBLIC: Return the Sequencing object used by the session.
    
    Overrides:
    
    getSequencing in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - howManySequencingCallbacks
```
public int howManySequencingCallbacks()
```
    INTERNAL: Returns a number of member sessions that require sequencing callback. Always returns 0 if sequencing is not connected.
  - isSequencingCallbackRequired
```
public boolean isSequencingCallbackRequired()
```
    INTERNAL: Indicates whether SequencingCallback is required. Always returns false if sequencing is not connected.
    
    Overrides:
    
    isSequencingCallbackRequired in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
  - shouldUseDescriptorAliases
```
public boolean shouldUseDescriptorAliases()
```
    PUBLIC: Indicates whether descriptors should use aliasDescriptors map. If aliasDescriptors is used then descriptors' aliases should be unique.
  - setShouldUseDescriptorAliases
```
public void setShouldUseDescriptorAliases(boolean shouldUseDescriptorAliases)
```
    PUBLIC: Indicates whether descriptors should use aliasDescriptors map. If aliasDescriptors is used then descriptors' aliases should be unique.

Class SessionBroker

Field Summary

Fields inherited from class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl

Fields inherited from class org.eclipse.persistence.internal.sessions.AbstractSession

Fields inherited from interface org.eclipse.persistence.sessions.coordination.CommandProcessor

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl

Methods inherited from class org.eclipse.persistence.internal.sessions.AbstractSession

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.persistence.sessions.DatabaseSession

Methods inherited from interface org.eclipse.persistence.sessions.Session

Field Detail

parent

sessionNamesByClass

sessionsByName

sequencing

shouldUseDescriptorAliases

Constructor Detail

SessionBroker

SessionBroker

Method Detail

acquireClientSessionBroker

acquireClientSessionBroker

acquireHistoricalSession

releaseJTSConnection

acquireUnitOfWork

addDescriptor

addDescriptors

addDescriptors

addSequence

basicBeginTransaction

basicCommitTransaction

basicRollbackTransaction

containsQuery

copySessionBroker

getAccessors

getAsOfClause

getParent

getExecutionSession

getPlatform

getQuery

getSessionForClass

getSessionForName

getSessionForQuery

getSessionNamesByClass

getSessionsByName

initializeDescriptors

initializeIdentityMapAccessor

internalExecuteQuery

isBroker

isClientSessionBroker

isConnected

isServerSessionBroker

isSessionBroker

login

loginAndDetectDatasource

login

logout

postLogin

registerSession

registerSession

release

retryQuery

setExternalTransactionController

setIntegrityChecker

setSessionLog

setLog

setProfiler

setSessionNameByClass

setSessionsByName

setSynchronized

writesCompleted

initializeSequencing

getSequencingHome

getSequencing

howManySequencingCallbacks

isSequencingCallbackRequired

shouldUseDescriptorAliases

setShouldUseDescriptorAliases