EclipseLink 2.0.0, build 'v20091127-r5931' API Reference

org.eclipse.persistence.sessions.server
Class ServerSession

java.lang.Object
  extended by org.eclipse.persistence.internal.sessions.AbstractSession
      extended by org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
          extended by org.eclipse.persistence.sessions.server.ServerSession
All Implemented Interfaces:
java.io.Serializable, java.lang.Cloneable, CommandProcessor, DatabaseSession, Server, Session

public class ServerSession
extends org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
implements Server

Implementation of Server INTERNAL: The public interface should be used.

Purpose: A single session that supports multiple user/clients connection at the same time.

Description: This session supports a shared session that can be used by multiple users or clients in a three-tiered application. It brokers client sessions to allow read and write access through a unified object cache. The server session uses a single connection pool by default, but allows multiple connection pools and separate read/write pools to be configured. All changes to objects and the database must be done through a unit of work acquired from the client session, this allows the changes to occur in a transactional object space and under a exclusive database connection.

Responsibilities:

See Also:
Server, ClientSession, UnitOfWork, Serialized Form

Field Summary
protected  java.util.Map connectionPools
           
protected  ConnectionPolicy defaultConnectionPolicy
           
protected  int maxNumberOfNonPooledConnections
           
static int NO_MAX
           
protected  int numberOfNonPooledConnectionsUsed
           
protected  ConnectionPool readConnectionPool
           
 
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
ServerSession()
          INTERNAL: Create and return a new default server session.
ServerSession(Login login)
          INTERNAL: Create and return a new server session.
ServerSession(Login login, ConnectionPolicy defaultConnectionPolicy)
          INTERNAL: Create and return a new default server session.
ServerSession(Login login, int minNumberOfPooledConnection, int maxNumberOfPooledConnection)
          INTERNAL: Create and return a new server session.
ServerSession(Project project)
          INTERNAL: Create and return a new server session.
ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy)
          INTERNAL: Create and return a new server session.
ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy, int initialNumberOfPooledConnections, int minNumberOfPooledConnections, int maxNumberOfPooledConnections, Login readLogin, Login sequenceLogin)
          INTERNAL: Create and return a new server session.
ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy, Login readLogin)
          INTERNAL: Create and return a new server session.
ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy, Login readLogin, Login sequenceLogin)
          INTERNAL: Create and return a new server session.
ServerSession(Project project, int minNumberOfPooledConnection, int maxNumberOfPooledConnection)
          INTERNAL: Create and return a new server session.
ServerSession(Project project, int initialNumberOfPooledConnection, int minNumberOfPooledConnection, int maxNumberOfPooledConnection)
          INTERNAL: Create and return a new server session.
ServerSession(Project project, int minNumberOfPooledConnection, int maxNumberOfPooledConnection, Login readLogin)
          INTERNAL: Create and return a new server session.
ServerSession(Project project, int minNumberOfPooledConnection, int maxNumberOfPooledConnection, Login readLogin, Login sequenceLogin)
          INTERNAL: Create and return a new server session.
 
Method Summary
 void acquireClientConnection(ClientSession clientSession)
          INTERNAL: Allocate the client's connection resource.
 ClientSession acquireClientSession()
          PUBLIC: Return a client session for this server session.
 ClientSession acquireClientSession(ConnectionPolicy connectionPolicy)
          PUBLIC: Return a client session for this server session.
 ClientSession acquireClientSession(ConnectionPolicy connectionPolicy, java.util.Map properties)
          PUBLIC: Return a client session for this server session.
 ClientSession acquireClientSession(Login login)
          PUBLIC: Return a client session for this server session.
 ClientSession acquireClientSession(Login login, java.util.Map properties)
          PUBLIC: Return a client session for this server session.
 ClientSession acquireClientSession(java.util.Map properties)
          PUBLIC: Return a client session for this server session.
 ClientSession acquireClientSession(java.lang.String poolName)
          PUBLIC: Return a client session for this server session.
 ClientSession acquireClientSession(java.lang.String poolName, java.util.Map properties)
          PUBLIC: Return a client session for this server session.
 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.
 void addConnectionPool(ConnectionPool pool)
          PUBLIC: Connection are pooled to share and restrict the number of database connections.
 void addConnectionPool(java.lang.String poolName, Login login, int minNumberOfConnections, int maxNumberOfConnections)
          PUBLIC: Add the connection pool.
 org.eclipse.persistence.internal.databaseaccess.Accessor allocateReadConnection()
          INTERNAL: Return a read connection from the read pool.
 void connect()
          INTERNAL: Startup the server session, also startup all of the connection pools.
 void disconnect()
          INTERNAL: Disconnect the accessor only.
 java.lang.Object executeCall(Call call, org.eclipse.persistence.internal.sessions.AbstractRecord translationRow, DatabaseQuery query)
          INTERNAL: Override to acquire the connection from the pool at the last minute
 ConnectionPool getConnectionPool(java.lang.String poolName)
          PUBLIC: Return the pool by name.
 java.util.Map getConnectionPools()
          INTERNAL: Connection are pooled to share and restrict the number of database connections.
 ConnectionPolicy getDefaultConnectionPolicy()
          PUBLIC: The default connection policy is used by default by the acquireClientConnection() protocol.
 ConnectionPool getDefaultConnectionPool()
          PUBLIC: Return the default connection pool.
 org.eclipse.persistence.internal.sessions.AbstractSession getExecutionSession(DatabaseQuery query)
          INTERNAL: Gets the session which this query will be executed on.
 int getMaxNumberOfNonPooledConnections()
          PUBLIC: Return the number of non-pooled database connections allowed.
 int getNumberOfNonPooledConnectionsUsed()
          INTERNAL: Return the current number of non-pooled connections in use.
 ConnectionPool getReadConnectionPool()
          PUBLIC: Return the read connection pool.
protected  Login getReadLogin()
          INTERNAL: Return the login for the read connection.
 org.eclipse.persistence.internal.sequencing.SequencingServer getSequencingServer()
          INTERNAL: Return SequencingServer object owned by the session.
 boolean isConnected()
          PUBLIC: Return if this session has been connected to the database.
 boolean isServerSession()
          INTERNAL: Return if this session is a server session.
 void logout()
          PUBLIC: Shutdown the server session, also shutdown all of the connection pools.
 void postConnectExternalConnection(org.eclipse.persistence.internal.databaseaccess.Accessor accessor)
          INTERNAL: This method is called in case externalConnectionPooling is used right after the accessor is connected.
 void preDisconnectExternalConnection(org.eclipse.persistence.internal.databaseaccess.Accessor accessor)
          INTERNAL: This method is called in case externalConnectionPooling is used right before the accessor is disconnected.
 void releaseClientSession(ClientSession clientSession)
          INTERNAL: Release the clients connection resource.
 void releaseReadConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection)
          INTERNAL: Release the read connection back into the read pool.
 void setCheckConnections()
          INTERNAL: This method is called to indicate that all available connections should be checked.
 void setConnectionPools(java.util.Map connectionPools)
          INTERNAL: Connection are pooled to share and restrict the number of database connections.
 void setDefaultConnectionPolicy(ConnectionPolicy defaultConnectionPolicy)
          PUBLIC: The default connection policy is used by default by the acquireClientConnection() protocol.
 void setDefaultConnectionPool()
          PUBLIC: Creates and adds "default" connection pool using default parameter values
 void setMaxNumberOfNonPooledConnections(int maxNumberOfNonPooledConnections)
          PUBLIC: Set the number of non-pooled database connections allowed.
 void setNumberOfNonPooledConnectionsUsed(int numberOfNonPooledConnectionsUsed)
          INTERNAL: Set the current number of connections being used that are not from a connection pool.
 void setReadConnectionPool(ConnectionPool readConnectionPool)
          PUBLIC: Set the read connection pool.
 void setReadConnectionPool(Login readLogin)
          PUBLIC: Creates and sets the new read connection pool.
 void setSynchronized(boolean synched)
          INTERNAL: Set isSynchronized flag to indicate that this session is synchronized.
protected  void updateStandardConnectionPools()
          INTERNAL: Updates standard connection pools.
 void useExclusiveReadConnectionPool(int minNumerOfConnections, int maxNumerOfConnections)
          PUBLIC: Configure the read connection pool.
 void useExclusiveReadConnectionPool(int initialNumberOfConnections, int minNumerOfConnections, int maxNumerOfConnections)
          PUBLIC: Configure the read connection pool.
 void useExternalReadConnectionPool()
          PUBLIC: Configure the read connection pool.
 void useReadConnectionPool(int minNumerOfConnections, int maxNumerOfConnections)
          PUBLIC: Configure the read connection pool.
 void useReadConnectionPool(int initialNumerOfConnections, int minNumerOfConnections, int maxNumerOfConnections)
          PUBLIC: Configure the read connection pool.
 void validateQuery(DatabaseQuery query)
          INTERNAL: This method will be used to update the query with any settings required For this session.
 
Methods inherited from class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
addDescriptor, addDescriptors, addDescriptors, finalize, getConnectedTime, getDatasourcePlatform, getPlatform, getPlatform, getSequencing, getSequencingControl, getSequencingHome, getServerPlatform, initializeConnectedTime, initializeDescriptorIfSessionAlive, initializeDescriptors, initializeDescriptors, initializeDescriptors, initializeSequencing, isDatabaseSession, isLoggedIn, isSequencingCallbackRequired, login, login, login, loginAndDetectDatasource, postConnectDatasource, preConnectDatasource, releaseJTSConnection, setSequencingHome, setServerPlatform, writeAllObjects, writeAllObjects
 
Methods inherited from class org.eclipse.persistence.internal.sessions.AbstractSession
acquireNonSynchronizedUnitOfWork, acquireNonSynchronizedUnitOfWork, acquireUnitOfWork, addAlias, addJPAQuery, addQuery, addQuery, addStaticMetamodelClass, basicBeginTransaction, basicBeginTransaction, basicCommitTransaction, basicRollbackTransaction, beginExternalTransaction, beginTransaction, checkHierarchyForDescriptor, clearDescriptors, clearIntegrityChecker, clearLastDescriptorAccessed, clearProfile, clone, commitExternalTransaction, commitTransaction, compareObjects, compareObjectsDontMatch, config, containsQuery, copyDescriptorNamedQueries, copyObject, copyObject, copyReadOnlyClasses, deleteAllObjects, deleteAllObjects, deleteObject, doesObjectExist, dontLogMessages, endOperationProfile, endOperationProfile, executeNonSelectingCall, executeNonSelectingSQL, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeSelectingCall, executeSQL, fine, finer, finest, getAccessor, getAccessor, getAccessor, getActiveCommandThreads, getActiveSession, getActiveUnitOfWork, getAliasDescriptors, getAllQueries, getAsOfClause, 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, getParent, getParentIdentityMapSession, getParentIdentityMapSession, getPessimisticLockTimeoutDefault, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, getQuery, getQuery, getQueryTimeoutDefault, getRootSession, getSessionForClass, getSessionLog, getSessionTypeString, getStaticMetamodelClass, getTransactionMutex, handleException, handleSevere, hasBroker, hasCommitManager, hasDescriptor, hasEventManager, hasExceptionHandler, hasExternalTransactionController, hasProperties, incrementProfile, info, initializeIdentityMapAccessor, insertObject, internalExecuteQuery, isBroker, isClassReadOnly, isClassReadOnly, isClientSession, isDistributedSession, isExclusiveConnectionRequired, isExclusiveIsolatedClientSession, isFinalizersEnabled, isHistoricalSession, isInBroker, isInProfile, isInTransaction, isIsolatedClientSession, isLoggingOff, isRemoteSession, isRemoteUnitOfWork, isSessionBroker, isSynchronized, isUnitOfWork, keyFromObject, keyFromObject, log, log, log, log, log, log, log, log, log, log, logMessage, logMessage, logThrowable, prepareDatabaseQuery, processCommand, processJPAQueries, readAllObjects, readAllObjects, readAllObjects, readAllObjects, readObject, readObject, readObject, readObject, readObject, refreshAndLockObject, refreshAndLockObject, refreshObject, registerFinalizer, release, releaseUnitOfWork, removeProperty, removeQuery, removeQuery, rollbackExternalTransaction, rollbackTransaction, setAccessor, setBroker, setCommandManager, setCommitManager, setDatasourceLogin, setDefaultReferenceMode, setEventManager, setExceptionHandler, setExternalTransactionController, setIntegrityChecker, setIsFinalizersEnabled, setIsInBroker, setIsInProfile, setLog, setLogin, setLogin, setLogLevel, setName, setNumberOfActiveUnitsOfWork, setPessimisticLockTimeoutDefault, setProfiler, setProject, setProperties, setProperty, setQueries, setQueryTimeoutDefault, setSessionLog, setShouldPropagateChanges, setTransactionMutex, setWasJTSTransactionInternallyStarted, severe, shouldLog, shouldLogMessages, shouldLogMessages, shouldPropagateChanges, startOperationProfile, startOperationProfile, toString, unwrapObject, updateObject, updateProfile, validateCache, verifyDelete, warning, wasJTSTransactionInternallyStarted, wrapObject, writeAllObjectsWithChangeSet, writeObject, writesCompleted
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface org.eclipse.persistence.sessions.server.Server
setDatasourceLogin
 
Methods inherited from interface org.eclipse.persistence.sessions.DatabaseSession
addDescriptor, addDescriptors, addDescriptors, beginTransaction, commitTransaction, deleteAllObjects, deleteObject, getCommandManager, getSequencingControl, getServerPlatform, insertObject, isInTransaction, login, login, login, refreshAndLockObject, refreshAndLockObject, rollbackTransaction, setCommandManager, setExternalTransactionController, setLogin, setServerPlatform, setShouldPropagateChanges, shouldPropagateChanges, updateObject, writeAllObjects, writeObject
 
Methods inherited from interface org.eclipse.persistence.sessions.Session
acquireUnitOfWork, addJPAQuery, addQuery, clearIntegrityChecker, clearProfile, containsQuery, copyObject, copyObject, doesObjectExist, dontLogMessages, executeNonSelectingCall, executeNonSelectingSQL, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeSelectingCall, executeSQL, getActiveSession, getActiveUnitOfWork, getAsOfClause, getClassDescriptor, getClassDescriptor, getClassDescriptorForAlias, getDatasourceLogin, getDatasourcePlatform, getDefaultReferenceMode, getDescriptor, getDescriptor, getDescriptorForAlias, getDescriptors, getEventManager, getExceptionHandler, getExternalTransactionController, getIdentityMapAccessor, getIntegrityChecker, getJPAQueries, getLog, getLogin, getLogLevel, getLogLevel, getName, getNextSequenceNumberValue, getPlatform, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, getQuery, getSessionLog, handleException, handleSevere, hasDescriptor, hasExceptionHandler, hasExternalTransactionController, isClientSession, isDatabaseSession, isDistributedSession, isFinalizersEnabled, isInProfile, isRemoteSession, isRemoteUnitOfWork, isSessionBroker, isUnitOfWork, keyFromObject, log, logMessage, readAllObjects, readAllObjects, readAllObjects, readObject, readObject, readObject, readObject, refreshObject, release, removeProperty, removeQuery, setDefaultReferenceMode, setExceptionHandler, setIntegrityChecker, setIsFinalizersEnabled, setLog, setLogLevel, setName, setProfiler, setProperty, setSessionLog, shouldLog, shouldLogMessages, validateCache
 

Field Detail

readConnectionPool

protected ConnectionPool readConnectionPool

connectionPools

protected java.util.Map connectionPools

defaultConnectionPolicy

protected ConnectionPolicy defaultConnectionPolicy

maxNumberOfNonPooledConnections

protected int maxNumberOfNonPooledConnections

NO_MAX

public static final int NO_MAX
See Also:
Constant Field Values

numberOfNonPooledConnectionsUsed

protected int numberOfNonPooledConnectionsUsed
Constructor Detail

ServerSession

public ServerSession()
INTERNAL: Create and return a new default server session.

See Also:
Project.createServerSession()

ServerSession

public ServerSession(Login login)
INTERNAL: Create and return a new server session.

See Also:
Project.createServerSession()

ServerSession

public ServerSession(Login login,
                     int minNumberOfPooledConnection,
                     int maxNumberOfPooledConnection)
INTERNAL: Create and return a new server session.

See Also:
Project.createServerSession(int, int)

ServerSession

public ServerSession(Login login,
                     ConnectionPolicy defaultConnectionPolicy)
INTERNAL: Create and return a new default server session.

See Also:
Project.createServerSession(ConnectionPolicy)

ServerSession

public ServerSession(Project project)
INTERNAL: Create and return a new server session.

See Also:
This is used by JPA, and SessionManager.

ServerSession

public ServerSession(Project project,
                     int minNumberOfPooledConnection,
                     int maxNumberOfPooledConnection)
INTERNAL: Create and return a new server session.

See Also:
Project.createServerSession(int, int)

ServerSession

public ServerSession(Project project,
                     int initialNumberOfPooledConnection,
                     int minNumberOfPooledConnection,
                     int maxNumberOfPooledConnection)
INTERNAL: Create and return a new server session.

See Also:
Project.createServerSession(int, int, int)

ServerSession

public ServerSession(Project project,
                     int minNumberOfPooledConnection,
                     int maxNumberOfPooledConnection,
                     Login readLogin)
INTERNAL: Create and return a new server session.

Parameters:
project - the project associated with this session
minNumberOfPooledConnection - the minimum number of connections in the pool
maxNumberOfPooledConnection - the maximum number of connections in the pool
readLogin - the login used to create the read connection pool
See Also:
Project.createServerSession(int, int)

ServerSession

public ServerSession(Project project,
                     int minNumberOfPooledConnection,
                     int maxNumberOfPooledConnection,
                     Login readLogin,
                     Login sequenceLogin)
INTERNAL: Create and return a new server session.

See Also:
Project.createServerSession(int, int)

ServerSession

public ServerSession(Project project,
                     ConnectionPolicy defaultConnectionPolicy,
                     int initialNumberOfPooledConnections,
                     int minNumberOfPooledConnections,
                     int maxNumberOfPooledConnections,
                     Login readLogin,
                     Login sequenceLogin)
INTERNAL: Create and return a new server session.

Configure the initial, min and max number of connections for the default pool.

Configure the default connection policy to be used. This policy is used on the "acquireClientSession()" protocol.

Use the login from the project for the write pool. Use the passed in login for the read pool, if specified, or the project login if not. Use the sequenceLogin, if specified, for creating a connection pool to be used by sequencing through SequencingConnectionHandler sequenceLogin *MUST*:
1. specify *NON-JTS* connections (such as NON_JTS driver or read-only datasource);
2. sequenceLogin.shouldUseExternalTransactionController()==false

Parameters:
project - the project associated with this session
defaultConnectionPolicy - the default connection policy to be used
initialNumberOfPooledConnections - the minimum number of connections in the pool
minNumberOfPooledConnections - the minimum number of connections in the pool
maxNumberOfPooledConnections - the maximum number of connections in the pool
readLogin - the login used to create the read connection pool
sequenceLogin - the login used to create a connection pool for sequencing
See Also:
Project.createServerSession(int, int)

ServerSession

public ServerSession(Project project,
                     ConnectionPolicy defaultConnectionPolicy)
INTERNAL: Create and return a new server session.

See Also:
Project.createServerSession(ConnectionPolicy)

ServerSession

public ServerSession(Project project,
                     ConnectionPolicy defaultConnectionPolicy,
                     Login readLogin)
INTERNAL: Create and return a new server session.

See Also:
Project.createServerSession(ConnectionPolicy)

ServerSession

public ServerSession(Project project,
                     ConnectionPolicy defaultConnectionPolicy,
                     Login readLogin,
                     Login sequenceLogin)
INTERNAL: Create and return a new server session.

See Also:
Project.createServerSession(ConnectionPolicy)
Method Detail

acquireClientConnection

public void acquireClientConnection(ClientSession clientSession)
                             throws DatabaseException,
                                    ConcurrencyException
INTERNAL: Allocate the client's connection resource.

Throws:
DatabaseException
ConcurrencyException

acquireClientSession

public ClientSession acquireClientSession()
                                   throws DatabaseException
PUBLIC: Return a client session for this server session. Each user/client connected to this server session must acquire there own client session to communicate to the server through. This method allows for a client session to be acquired sharing the same login as the server session.

Specified by:
acquireClientSession in interface Server
Throws:
DatabaseException

acquireClientSession

public ClientSession acquireClientSession(java.util.Map properties)
                                   throws DatabaseException
PUBLIC: Return a client session for this server session. Each user/client connected to this server session must acquire there own client session to communicate to the server through. This method allows for a client session to be acquired sharing the same login as the server session. The properties set into the client session at construction time, before postAcquireClientSession is risen.

Throws:
DatabaseException

acquireClientSession

public ClientSession acquireClientSession(java.lang.String poolName)
                                   throws DatabaseException
PUBLIC: Return a client session for this server session. Each user/client connected to this server session must acquire there own client session to communicate to the server through. This method allows for a client session to be acquired sharing its connection from a pool of connection allocated on the server session. By default this uses a lazy connection policy.

Specified by:
acquireClientSession in interface Server
Throws:
DatabaseException

acquireClientSession

public ClientSession acquireClientSession(java.lang.String poolName,
                                          java.util.Map properties)
                                   throws DatabaseException
PUBLIC: Return a client session for this server session. Each user/client connected to this server session must acquire there own client session to communicate to the server through. This method allows for a client session to be acquired sharing its connection from a pool of connection allocated on the server session. By default this uses a lazy connection policy. The properties set into the client session at construction time, before postAcquireClientSession is risen.

Throws:
DatabaseException

acquireClientSession

public ClientSession acquireClientSession(Login login)
                                   throws DatabaseException
PUBLIC: Return a client session for this server session. Each user/client connected to this server session must acquire there own client session to communicate to the server through. The client must provide its own login to use, and the client session returned will have its own exclusive database connection. This connection will be used to perform all database modification for all units of work acquired from the client session. By default this does not use a lazy connection policy.

Specified by:
acquireClientSession in interface Server
Throws:
DatabaseException

acquireClientSession

public ClientSession acquireClientSession(Login login,
                                          java.util.Map properties)
                                   throws DatabaseException
PUBLIC: Return a client session for this server session. Each user/client connected to this server session must acquire there own client session to communicate to the server through. The client must provide its own login to use, and the client session returned will have its own exclusive database connection. This connection will be used to perform all database modification for all units of work acquired from the client session. By default this does not use a lazy connection policy. The properties set into the client session at construction time, before postAcquireClientSession is risen.

Throws:
DatabaseException

acquireClientSession

public ClientSession acquireClientSession(ConnectionPolicy connectionPolicy)
                                   throws DatabaseException,
                                          ValidationException
PUBLIC: Return a client session for this server session. The connection policy specifies how the client session's connection will be acquired.

Specified by:
acquireClientSession in interface Server
Throws:
DatabaseException
ValidationException

acquireClientSession

public ClientSession acquireClientSession(ConnectionPolicy connectionPolicy,
                                          java.util.Map properties)
                                   throws DatabaseException,
                                          ValidationException
PUBLIC: Return a client session for this server session. The connection policy specifies how the client session's connection will be acquired. The properties set into the client session at construction time, before postAcquireClientSession is risen.

Throws:
DatabaseException
ValidationException

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

acquireUnitOfWork

public org.eclipse.persistence.internal.sessions.UnitOfWorkImpl acquireUnitOfWork()
PUBLIC: Return a unit of work for this session. The unit of work is an object level transaction that allows a group of changes to be applied as a unit. First acquire a client session as server session does not allow direct units of work.

Specified by:
acquireUnitOfWork in interface Session
Overrides:
acquireUnitOfWork in class org.eclipse.persistence.internal.sessions.AbstractSession
See Also:
UnitOfWorkImpl

addConnectionPool

public void addConnectionPool(java.lang.String poolName,
                              Login login,
                              int minNumberOfConnections,
                              int maxNumberOfConnections)
                       throws ValidationException
PUBLIC: Add the connection pool. Connections are pooled to share and restrict the number of database connections.

Specified by:
addConnectionPool in interface Server
Throws:
ValidationException

addConnectionPool

public void addConnectionPool(ConnectionPool pool)
PUBLIC: Connection are pooled to share and restrict the number of database connections.

Specified by:
addConnectionPool in interface Server

allocateReadConnection

public org.eclipse.persistence.internal.databaseaccess.Accessor allocateReadConnection()
INTERNAL: Return a read connection from the read pool. Note that depending on the type of pool this may be a shared or exclusive connection. Each query execution is assigned a read connection.


connect

public void connect()
INTERNAL: Startup the server session, also startup all of the connection pools.

Overrides:
connect in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl

disconnect

public void disconnect()
                throws DatabaseException
INTERNAL: Disconnect the accessor only.

Overrides:
disconnect in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
Throws:
DatabaseException

executeCall

public java.lang.Object executeCall(Call call,
                                    org.eclipse.persistence.internal.sessions.AbstractRecord translationRow,
                                    DatabaseQuery query)
                             throws DatabaseException
INTERNAL: Override to acquire the connection from the pool at the last minute

Overrides:
executeCall in class org.eclipse.persistence.internal.sessions.AbstractSession
Throws:
DatabaseException

getConnectionPool

public ConnectionPool getConnectionPool(java.lang.String poolName)
PUBLIC: Return the pool by name.

Specified by:
getConnectionPool in interface Server

getConnectionPools

public java.util.Map getConnectionPools()
INTERNAL: Connection are pooled to share and restrict the number of database connections.


getDefaultConnectionPolicy

public ConnectionPolicy getDefaultConnectionPolicy()
PUBLIC: The default connection policy is used by default by the acquireClientConnection() protocol. By default it is a connection pool with min 5 and max 10 lazy pooled connections.

Specified by:
getDefaultConnectionPolicy in interface Server

getDefaultConnectionPool

public ConnectionPool getDefaultConnectionPool()
PUBLIC: Return the default connection pool.

Specified by:
getDefaultConnectionPool in interface Server

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

getMaxNumberOfNonPooledConnections

public int getMaxNumberOfNonPooledConnections()
PUBLIC: Return the number of non-pooled database connections allowed. This can be enforced to make up for the resource limitation of most JDBC drivers and database clients. By default this is 50.

Specified by:
getMaxNumberOfNonPooledConnections in interface Server

getNumberOfNonPooledConnectionsUsed

public int getNumberOfNonPooledConnectionsUsed()
INTERNAL: Return the current number of non-pooled connections in use.


getReadLogin

protected Login getReadLogin()
INTERNAL: Return the login for the read connection. Used by the platform autodetect feature

Overrides:
getReadLogin in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl

getReadConnectionPool

public ConnectionPool getReadConnectionPool()
PUBLIC: Return the read connection pool. The read connection pool handles allocating connection for read queries.

Specified by:
getReadConnectionPool in interface Server
See Also:
Server.setReadConnectionPool(ConnectionPool), Server.useExclusiveReadConnectionPool(int, int), Server.useExternalReadConnectionPool(), Server.useReadConnectionPool(int, int)

isConnected

public boolean isConnected()
PUBLIC: Return if this session has been connected to the database.

Specified by:
isConnected in interface Session
Overrides:
isConnected in class org.eclipse.persistence.internal.sessions.AbstractSession

isServerSession

public boolean isServerSession()
INTERNAL: Return if this session is a server session.

Specified by:
isServerSession in interface Session
Overrides:
isServerSession in class org.eclipse.persistence.internal.sessions.AbstractSession

logout

public void logout()
PUBLIC: Shutdown the server session, also shutdown all of the connection pools.

Specified by:
logout in interface DatabaseSession
Overrides:
logout in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl

postConnectExternalConnection

public void postConnectExternalConnection(org.eclipse.persistence.internal.databaseaccess.Accessor accessor)
INTERNAL: This method is called in case externalConnectionPooling is used right after the accessor is connected. Used by the session to rise an appropriate event.

Overrides:
postConnectExternalConnection in class org.eclipse.persistence.internal.sessions.AbstractSession

preDisconnectExternalConnection

public void preDisconnectExternalConnection(org.eclipse.persistence.internal.databaseaccess.Accessor accessor)
INTERNAL: This method is called in case externalConnectionPooling is used right before the accessor is disconnected. Used by the session to rise an appropriate event.

Overrides:
preDisconnectExternalConnection in class org.eclipse.persistence.internal.sessions.AbstractSession

releaseClientSession

public void releaseClientSession(ClientSession clientSession)
                          throws DatabaseException
INTERNAL: Release the clients connection resource.

Throws:
DatabaseException

releaseReadConnection

public void releaseReadConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection)
INTERNAL: Release the read connection back into the read pool.

Overrides:
releaseReadConnection in class org.eclipse.persistence.internal.sessions.AbstractSession

setCheckConnections

public void setCheckConnections()
INTERNAL: This method is called to indicate that all available connections should be checked. No-op on external connection pools.


setConnectionPools

public void setConnectionPools(java.util.Map connectionPools)
INTERNAL: Connection are pooled to share and restrict the number of database connections.


setDefaultConnectionPolicy

public void setDefaultConnectionPolicy(ConnectionPolicy defaultConnectionPolicy)
PUBLIC: The default connection policy is used by default by the acquireClientConnection() protocol. By default it is a connection pool with min 5 and max 10 lazy pooled connections.

Specified by:
setDefaultConnectionPolicy in interface Server

setDefaultConnectionPool

public void setDefaultConnectionPool()
PUBLIC: Creates and adds "default" connection pool using default parameter values


setMaxNumberOfNonPooledConnections

public void setMaxNumberOfNonPooledConnections(int maxNumberOfNonPooledConnections)
PUBLIC: Set the number of non-pooled database connections allowed. This can be enforced to make up for the resource limitation of most JDBC drivers and database clients. By default this is 50.

Specified by:
setMaxNumberOfNonPooledConnections in interface Server

setNumberOfNonPooledConnectionsUsed

public void setNumberOfNonPooledConnectionsUsed(int numberOfNonPooledConnectionsUsed)
INTERNAL: Set the current number of connections being used that are not from a connection pool.

Parameters:
int -

setReadConnectionPool

public void setReadConnectionPool(ConnectionPool readConnectionPool)
PUBLIC: Set the read connection pool. The read connection pool handles allocating connection for read queries. If external connection pooling is used, an external connection pool will be used by default.

Specified by:
setReadConnectionPool in interface Server

setReadConnectionPool

public void setReadConnectionPool(Login readLogin)
                           throws ValidationException
PUBLIC: Creates and sets the new read connection pool. By default the same connection pool is used for read and write, this allows a different login/pool to be used for reading. By default 32 min/max connections are used in the pool with an initial of 1 connection.

Throws:
ValidationException

setSynchronized

public void setSynchronized(boolean synched)
INTERNAL: Set isSynchronized flag to indicate that this session is synchronized. The method is ignored on ServerSession and should never be called.

Overrides:
setSynchronized in class org.eclipse.persistence.internal.sessions.AbstractSession

updateStandardConnectionPools

protected void updateStandardConnectionPools()
INTERNAL: Updates standard connection pools. Should not be called after session is connected. This is needed in case of pools' logins been altered after the pool has been created (SessionManager does that) All pools should be re-created in case their type doesn't match their login. In addition, sequenceConnectionPool should be removed in case its login has shouldUseExternaltransactionController()==true (see setSequenceConnectionPool)


useExclusiveReadConnectionPool

public void useExclusiveReadConnectionPool(int minNumerOfConnections,
                                           int maxNumerOfConnections)
PUBLIC: Configure the read connection pool. The read connection pool handles allocating connection for read queries.

Specified by:
useExclusiveReadConnectionPool in interface Server
See Also:
Server.getReadConnectionPool(), Server.setReadConnectionPool(ConnectionPool), Server.useReadConnectionPool(int, int), Server.useExternalReadConnectionPool()

useExclusiveReadConnectionPool

public void useExclusiveReadConnectionPool(int initialNumberOfConnections,
                                           int minNumerOfConnections,
                                           int maxNumerOfConnections)
PUBLIC: Configure the read connection pool. The read connection pool handles allocating connection for read queries.

Specified by:
useExclusiveReadConnectionPool in interface Server
See Also:
Server.getReadConnectionPool(), Server.setReadConnectionPool(ConnectionPool), Server.useReadConnectionPool(int, int), Server.useExternalReadConnectionPool()

useExternalReadConnectionPool

public void useExternalReadConnectionPool()
PUBLIC: Configure the read connection pool. The read connection pool handles allocating connection for read queries.

Specified by:
useExternalReadConnectionPool in interface Server
See Also:
Server.getReadConnectionPool(), Server.setReadConnectionPool(ConnectionPool), Server.useReadConnectionPool(int, int), Server.useExclusiveReadConnectionPool(int, int)

useReadConnectionPool

public void useReadConnectionPool(int minNumerOfConnections,
                                  int maxNumerOfConnections)
PUBLIC: Configure the read connection pool. The read connection pool handles allocating connection for read queries. If external connection pooling is used, an external connection pool will be used by default. This API uses a ReadConnectionPool which shares read connections. Some JDBC drivers may not support concurrent access to a connection, or have poor concurrency, so an exclusive read connection pool is normally recommended.

Specified by:
useReadConnectionPool in interface Server
maxNumerOfConnections - As multiple readers can use the same connection concurrently fewer connections are needed.
See Also:
useExclusiveReadConnectionPool(int, int)

useReadConnectionPool

public void useReadConnectionPool(int initialNumerOfConnections,
                                  int minNumerOfConnections,
                                  int maxNumerOfConnections)
PUBLIC: Configure the read connection pool. The read connection pool handles allocating connection for read queries. If external connection pooling is used, an external connection pool will be used by default. This API uses a ReadConnectionPool which shares read connections. Some JDBC drivers may not support concurrent access to a connection, or have poor concurrency, so an exclusive read connection pool is normally recommended.

Specified by:
useReadConnectionPool in interface Server
Parameters:
initialNumerOfConnections - connections connected at startup
minNumerOfConnections - connections that are pooled
maxNumerOfConnections - As multiple readers can use the same connection concurrently fewer connections are needed.
See Also:
useExclusiveReadConnectionPool(int, int, int)

validateQuery

public void validateQuery(DatabaseQuery query)
INTERNAL: This method will be used to update the query with any settings required For this session. It can also be used to validate execution.

Overrides:
validateQuery in class org.eclipse.persistence.internal.sessions.AbstractSession

getSequencingServer

public org.eclipse.persistence.internal.sequencing.SequencingServer getSequencingServer()
INTERNAL: Return SequencingServer object owned by the session.


EclipseLink 2.0.0, build 'v20091127-r5931' API Reference