org.eclipse.persistence.sessions.broker
Class SessionBroker

java.lang.Object
  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, 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

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

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

isLoggedIn

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

accessor, activeCommandThreads, broker, commandManager, commitManager, defaultReferenceMode, descriptors, eventManager, exceptionHandler, externalTransactionController, identityMapAccessor, integrityChecker, isFinalizersEnabled, isInBroker, isInProfile, isLoggingOff, isSynchronized, jpaQueries, lastDescriptorAccessed, logSessionString, name, numberOfActiveUnitsOfWork, pessimisticLockTimeoutDefault, platform, profiler, project, properties, queries, queryTimeoutDefault, sessionLog, shouldPropagateChanges, staticMetamodelClasses, transactionMutex, wasJTSTransactionInternallyStarted

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

LOG_DEBUG, LOG_ERROR, LOG_INFO, LOG_WARNING

Constructor Summary

	SessionBroker() PUBLIC: Create and return a session broker.
protected	SessionBroker(java.util.Map sessionNames) INTERNAL: Create and return a session broker.

Method Summary

SessionBroker	acquireClientSessionBroker() 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.
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.
org.eclipse.persistence.internal.databaseaccess.Accessor	getAccessor(java.lang.Class domainClass) INTERNAL: Return the lowlevel database accessor.
org.eclipse.persistence.internal.databaseaccess.Accessor	getAccessor(java.lang.String sessionName) INTERNAL: Return the lowlevel database accessor.
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.sessions.AbstractSession	getParentIdentityMapSession(DatabaseQuery query, boolean canReturnSelf, boolean terminalOnly) INTERNAL: Gets the next link in the chain of sessions followed by a query's check early return, the chain of sessions with identity maps all the way up to the root session.
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) PUBLIC: Return the query from the session pre-defined queries with the given name.
DatabaseQuery	getQuery(java.lang.String name, java.util.Vector arguments) 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.
void	internalRegisterSession(java.lang.String name, org.eclipse.persistence.internal.sessions.AbstractSession session) INTERNAL: Register the session under its name.
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	logout() PUBLIC: Disconnect from all databases.
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.
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	setSynchronized(boolean synched) INTERNAL: Set isSynchronized flag to indicate that members of session broker are synchronized.
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, connect, disconnect, finalize, getConnectedTime, getDatasourcePlatform, getPlatform, getReadLogin, getSequencingControl, getServerPlatform, initializeConnectedTime, initializeDescriptorIfSessionAlive, initializeDescriptors, initializeDescriptors, isDatabaseSession, isLoggedIn, login, loginAndDetectDatasource, postConnectDatasource, preConnectDatasource, setSequencingHome, setServerPlatform, writeAllObjects, writeAllObjects

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

acquireNonSynchronizedUnitOfWork, acquireNonSynchronizedUnitOfWork, acquireUnitOfWork, addAlias, addJPAQuery, addQuery, addQuery, addStaticMetamodelClass, basicBeginTransaction, beginExternalTransaction, beginTransaction, checkHierarchyForDescriptor, clearDescriptors, clearIntegrityChecker, clearLastDescriptorAccessed, clearProfile, clone, commitExternalTransaction, commitTransaction, compareObjects, compareObjectsDontMatch, config, copyDescriptorNamedQueries, copyObject, copyObject, copyReadOnlyClasses, deleteAllObjects, deleteAllObjects, deleteObject, doesObjectExist, dontLogMessages, endOperationProfile, endOperationProfile, executeCall, executeNonSelectingCall, executeNonSelectingSQL, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeSelectingCall, executeSQL, fine, finer, finest, getAccessor, getActiveCommandThreads, getActiveSession, getActiveUnitOfWork, getAliasDescriptors, getAllQueries, getBroker, getClassDescriptor, getClassDescriptor, getClassDescriptorForAlias, getCommandManager, getCommitManager, getDatasourceLogin, getDefaultReadOnlyClasses, getDefaultReferenceMode, getDescriptor, getDescriptor, getDescriptorForAlias, getDescriptors, getEventManager, getExceptionHandler, getExceptionHandlerClass, getExternalTransactionController, getIdentityMapAccessor, getIdentityMapAccessorInstance, getIntegrityChecker, getJPAQueries, getLoader, getLog, getLogin, getLogLevel, getLogLevel, getLogSessionString, getName, getNextQueryId, getNextSequenceNumberValue, getNumberOfActiveUnitsOfWork, getParentIdentityMapSession, getPessimisticLockTimeoutDefault, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, getQueryTimeoutDefault, getRootSession, getSessionLog, getSessionTypeString, getStaticMetamodelClass, getTransactionMutex, handleException, handleSevere, hasBroker, hasCommitManager, hasDescriptor, hasEventManager, hasExceptionHandler, hasExternalTransactionController, hasProperties, incrementProfile, info, insertObject, isClassReadOnly, isClassReadOnly, isClientSession, isDistributedSession, isExclusiveConnectionRequired, isExclusiveIsolatedClientSession, isFinalizersEnabled, isHistoricalSession, isInBroker, isInProfile, isInTransaction, isIsolatedClientSession, isLoggingOff, isRemoteSession, isRemoteUnitOfWork, isServerSession, isSynchronized, isUnitOfWork, keyFromObject, keyFromObject, log, log, log, log, log, log, log, log, log, log, logMessage, logMessage, logThrowable, postConnectExternalConnection, preDisconnectExternalConnection, prepareDatabaseQuery, processCommand, processJPAQueries, readAllObjects, readAllObjects, readAllObjects, readAllObjects, readObject, readObject, readObject, readObject, readObject, refreshAndLockObject, refreshAndLockObject, refreshObject, registerFinalizer, releaseReadConnection, releaseUnitOfWork, removeProperty, removeQuery, removeQuery, rollbackExternalTransaction, rollbackTransaction, setAccessor, setBroker, setCommandManager, setCommitManager, setDatasourceLogin, setDefaultReferenceMode, setEventManager, setExceptionHandler, setExternalTransactionController, setIsFinalizersEnabled, setIsInBroker, setIsInProfile, setLogin, setLogin, setLogLevel, setName, setNumberOfActiveUnitsOfWork, setPessimisticLockTimeoutDefault, setProject, setProperties, setProperty, setQueries, setQueryTimeoutDefault, setShouldPropagateChanges, setTransactionMutex, setWasJTSTransactionInternallyStarted, severe, shouldLog, shouldLogMessages, shouldLogMessages, shouldPropagateChanges, startOperationProfile, startOperationProfile, toString, unwrapObject, updateObject, updateProfile, 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, setExternalTransactionController, setLogin, setShouldPropagateChanges, shouldPropagateChanges, updateObject, writeObject

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

acquireUnitOfWork, addJPAQuery, addQuery, clearIntegrityChecker, clearProfile, 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, getIdentityMapAccessor, getIntegrityChecker, getJPAQueries, getLog, getLogin, getLogLevel, getLogLevel, getName, getNextSequenceNumberValue, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, 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, setProperty, 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

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 releases. See releaseClientSessionBroker.

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

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.

getAccessor

public org.eclipse.persistence.internal.databaseaccess.Accessor getAccessor(java.lang.Class domainClass)

INTERNAL: Return the lowlevel database accessor. The database accessor is used for direct database access. The right accessor for this broker will be returned.

Overrides:

getAccessor in class org.eclipse.persistence.internal.sessions.AbstractSession

getAccessor

public org.eclipse.persistence.internal.databaseaccess.Accessor getAccessor(java.lang.String sessionName)

INTERNAL: Return the lowlevel database accessor. The database accesor is used for direct database access. The right accessor for this broker will be returned.

Overrides:

getAccessor in class org.eclipse.persistence.internal.sessions.AbstractSession

getAsOfClause

public AsOfClause getAsOfClause()

ADVANCED: Answers the past time this session is as of. Only meaningfull 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:

org.eclipse.persistence.expressions.AsOfClause, #acquireSessionAsOf(java.lang.Number), #acquireSessionAsOf(java.util.Date), #hasAsOfClause

getParent

public SessionBroker getParent()

INTERNAL: Gets the parent SessionBroker.

Overrides:

getParent in class org.eclipse.persistence.internal.sessions.AbstractSession

getParentIdentityMapSession

public org.eclipse.persistence.internal.sessions.AbstractSession getParentIdentityMapSession(DatabaseQuery query,
                                                                                             boolean canReturnSelf,
                                                                                             boolean terminalOnly)

INTERNAL: Gets the next link in the chain of sessions followed by a query's check early return, the chain of sessions with identity maps all the way up to the root session.

Used for session broker which delegates to registered sessions, or UnitOfWork which checks parent identity map also.

Overrides:

getParentIdentityMapSession in class org.eclipse.persistence.internal.sessions.AbstractSession

Parameters:

canReturnSelf - true when method calls itself. If the path starting at this is acceptable. Sometimes true if want to move to the first valid session, i.e. executing on ClientSession when really should be on ServerSession.

terminalOnly - return the session we will execute the call on, not the next step towards it.

Returns:

this if there is no next link in the chain

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)

PUBLIC: Return the query from the session pre-defined queries with the given name. This allows for common queries to be pre-defined, reused and executed by name.

Specified by:

getQuery in interface Session

Overrides:

getQuery in class org.eclipse.persistence.internal.sessions.AbstractSession

getQuery

public DatabaseQuery getQuery(java.lang.String name,
                              java.util.Vector arguments)

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.

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.

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.

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)

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.

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. The session 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. The session should not be connected and descriptors should not be initialized.

internalRegisterSession

public void internalRegisterSession(java.lang.String name,
                                    org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Register the session under its name. All of the session's descriptors must have already been registered. The session should not be connected and descriptors should not be initialized. Used for client session broker

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

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:

#logMessages()

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:

#logMessages()

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