ServerSession (EclipseLink 2.5.1, build 'v20130918-f2b9fc5' 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.server.ServerSession

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, CoreSession<ClassDescriptor,Login,org.eclipse.persistence.internal.databaseaccess.Platform,Project,SessionEventManager>, 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:
- Connection pooling.
- Reading objects and maintaining the object cache.
- Brokering client sessions.
- Requiring the UnitOfWork to be used for modification.
See Also:
Server, ClientSession, UnitOfWork, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.util.Map<java.lang.String,ConnectionPool>`	`connectionPools`
`static java.lang.String`	`DEFAULT_POOL`
`protected ConnectionPolicy`	`defaultConnectionPolicy`
`protected int`	`maxNumberOfNonPooledConnections`
`static int`	`NO_MAX`
`static java.lang.String`	`NOT_POOLED`
`protected int`	`numberOfNonPooledConnectionsUsed`
`protected ConnectionPool`	`readConnectionPool`

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, transactionMutex, wasJTSTransactionInternallyStarted

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

Constructor Summary

Constructors
Constructor and Description
`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

Methods
Modifier and Type	Method and Description
`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: Execute the call on the correct connection accessor.
`java.lang.Object`	`executeQuery(DatabaseQuery query, java.util.List argumentValues)` PUBLIC: Return the results from executing the database query.
`java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor>`	`getAccessors(Call call, org.eclipse.persistence.internal.sessions.AbstractRecord translationRow, DatabaseQuery query)` INTERNAL: Return the connections to use for the query execution.
`ConnectionPool`	`getConnectionPool(java.lang.String poolName)` PUBLIC: Return the pool by name.
`java.util.Map<java.lang.String,ConnectionPool>`	`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`	`releaseClientSession(ClientSession clientSession)` INTERNAL: Release the clients connection resource.
`void`	`releaseConnectionAfterCall(DatabaseQuery query)` INTERNAL: Release (if required) connection after call.
`void`	`releaseInvalidClientSession(ClientSession clientSession)` INTERNAL: Release any invalid connection in the client session.
`void`	`releaseReadConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection)` INTERNAL: Release the read connection back into the read pool.
`void`	`setConnectionPools(java.util.Map<java.lang.String,ConnectionPool> 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, addDescriptorsToSequencing, addSequence, finalize, getConnectedTime, getDatabaseEventListener, getDatasourcePlatform, getPlatform, getPlatform, getSequencing, getSequencingControl, getSequencingHome, getServerPlatform, getTuner, initializeConnectedTime, initializeDescriptorIfSessionAlive, initializeDescriptors, initializeDescriptors, initializeDescriptors, initializeDescriptors, initializeDescriptors, initializeSequencing, isDatabaseSession, isLoggedIn, isProtectedSession, isSequencingCallbackRequired, login, login, login, loginAndDetectDatasource, postConnectDatasource, postLogin, preConnectDatasource, releaseJTSConnection, retryQuery, 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, basicBeginTransaction, basicCommitTransaction, basicExecuteCall, basicRollbackTransaction, beginExternalTransaction, beginTransaction, buildDefaultQueryBuilder, checkAndRefreshInvalidObject, checkHierarchyForDescriptor, cleanUpEntityListenerInjectionManager, clearDescriptors, clearIntegrityChecker, clearLastDescriptorAccessed, clearProfile, clone, commitExternalTransaction, commitTransaction, compareObjects, compareObjectsDontMatch, config, containsQuery, copy, copy, copyDescriptorNamedQueries, copyDescriptorsFromProject, copyInternal, copyObject, copyObject, copyReadOnlyClasses, createCloneQueryValueHolder, createCloneTransformationValueHolder, createEntityListenerInjectionManager, createProtectedInstanceFromCachedData, deferEvent, deleteAllObjects, deleteAllObjects, deleteObject, doesObjectExist, dontLogMessages, endOperationProfile, endOperationProfile, executeDeferredEvents, executeNonSelectingCall, executeNonSelectingSQL, 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, getAsOfClause, 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, getParent, getParentIdentityMapSession, getParentIdentityMapSession, getParentIdentityMapSession, getPartitioningPolicy, getPessimisticLockTimeoutDefault, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, getQuery, getQuery, getQuery, getQueryBuilder, getQueryTimeoutDefault, getRefreshMetadataListener, getRootSession, getSerializer, getSessionForClass, getSessionForName, getSessionLog, getSessionTypeString, getStaticMetamodelClass, getTablePerTenantDescriptors, getTablePerTenantQueries, getTransactionMutex, handleException, handleSevere, hasBroker, hasCommitManager, hasDescriptor, hasEventManager, hasExceptionHandler, hasExternalTransactionController, hasProperties, hasTablePerTenantDescriptors, hasTablePerTenantQueries, incrementProfile, incrementProfile, info, initializeIdentityMapAccessor, insertObject, internalExecuteQuery, isBroker, isClassReadOnly, isClassReadOnly, isClientSession, isConcurrent, isConsideredInvalid, isDistributedSession, isExclusiveConnectionRequired, isExclusiveIsolatedClientSession, isFinalizersEnabled, isHistoricalSession, isInBroker, isInProfile, isInTransaction, isIsolatedClientSession, isJPAQueriesProcessed, isLoggingOff, isRemoteSession, isRemoteUnitOfWork, isSessionBroker, 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, release, releaseUnitOfWork, removeProperty, removeQuery, removeQuery, retrieveCacheKey, retryTransaction, rollbackExternalTransaction, rollbackTransaction, setAccessor, setBroker, setCommandManager, setCommitManager, setDatasourceLogin, setDefaultReferenceMode, setEntityListenerInjectionManager, setEventManager, setExceptionHandler, setExternalTransactionController, setIntegrityChecker, setIsConcurrent, setIsFinalizersEnabled, setIsInBroker, setIsInProfile, setJPAQueriesProcessed, setLog, setLogin, setLogin, setLogLevel, setName, setNumberOfActiveUnitsOfWork, setPartitioningPolicy, setPessimisticLockTimeoutDefault, setProfiler, setProject, setProperties, setProperty, setQueries, setQueryBuilder, setQueryTimeoutDefault, setRefreshMetadataListener, setSerializer, setSessionLog, setShouldOptimizeResultSetAccess, setShouldPropagateChanges, setTransactionMutex, setWasJTSTransactionInternallyStarted, severe, shouldDisplayData, shouldLog, shouldLogMessages, shouldLogMessages, shouldOptimizeResultSetAccess, shouldPropagateChanges, startOperationProfile, startOperationProfile, toString, unwrapObject, updateObject, updateProfile, updateTablePerTenantDescriptors, 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, addSequence, beginTransaction, commitTransaction, deleteAllObjects, deleteObject, getCommandManager, getDatabaseEventListener, getSequencingControl, getServerPlatform, insertObject, isInTransaction, login, login, login, refreshAndLockObject, refreshAndLockObject, rollbackTransaction, setCommandManager, setDatabaseEventListener, setExternalTransactionController, setLogin, setServerPlatform, setShouldPropagateChanges, shouldPropagateChanges, updateObject, writeAllObjects, writeObject

Methods inherited from interface org.eclipse.persistence.sessions.Session
acquireUnitOfWork, addJPAQuery, addQuery, clearIntegrityChecker, clearProfile, containsQuery, copy, copy, copyObject, copyObject, doesObjectExist, dontLogMessages, executeNonSelectingCall, executeNonSelectingSQL, 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, getId, getIdentityMapAccessor, getIntegrityChecker, getJPAQueries, getLog, getLogin, getLogLevel, getLogLevel, getName, getNextSequenceNumberValue, getPartitioningPolicy, getPlatform, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, getQuery, getSerializer, 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, setPartitioningPolicy, setProfiler, setProperty, setQueryTimeoutDefault, setSerializer, setSessionLog, shouldLog, shouldLogMessages, validateCache

- Field Detail
  - readConnectionPool
```
protected ConnectionPool readConnectionPool
```
  - connectionPools
```
protected java.util.Map<java.lang.String,ConnectionPool> connectionPools
```
  - defaultConnectionPolicy
```
protected ConnectionPolicy defaultConnectionPolicy
```
  - numberOfNonPooledConnectionsUsed
```
protected int numberOfNonPooledConnectionsUsed
```
  - maxNumberOfNonPooledConnections
```
protected int maxNumberOfNonPooledConnections
```
  - NO_MAX
```
public static final int NO_MAX
```
    See Also:
    Constant Field Values
  - DEFAULT_POOL
```
public static final java.lang.String DEFAULT_POOL
```
    See Also:
    Constant Field Values
  - NOT_POOLED
```
public static final java.lang.String NOT_POOLED
```
    See Also:
    Constant Field Values
- 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
  - getAccessors
```
public java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor> getAccessors(Call call,
                                                                                    org.eclipse.persistence.internal.sessions.AbstractRecord translationRow,
                                                                                    DatabaseQuery query)
```
    INTERNAL: Return the connections to use for the query execution.
    
    Overrides:
    
    getAccessors in class org.eclipse.persistence.internal.sessions.AbstractSession
  - executeCall
```
public java.lang.Object executeCall(Call call,
                           org.eclipse.persistence.internal.sessions.AbstractRecord translationRow,
                           DatabaseQuery query)
                             throws DatabaseException
```
    INTERNAL: Execute the call on the correct connection accessor. By default the server session executes calls using is read connection pool. A connection is allocated for the execution of the query, then released back to the pool. If partitioning is used the partition policy can use a different connection pool, or even execute the call on multiple connections.
    
    Overrides:
    
    executeCall in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Throws:
    
    DatabaseException
  - releaseConnectionAfterCall
```
public void releaseConnectionAfterCall(DatabaseQuery query)
```
    INTERNAL: Release (if required) connection after call.
    
    Overrides:
    
    releaseConnectionAfterCall in class org.eclipse.persistence.internal.sessions.AbstractSession
    
    Parameters:
    query -
  - executeQuery
```
public java.lang.Object executeQuery(DatabaseQuery query,
                            java.util.List argumentValues)
                              throws DatabaseException
```
    PUBLIC: Return the results from executing the database query. The query arguments are passed in as a List of argument values in the same order as the query arguments.
    
    Specified by:
    
    executeQuery in interface Session
    
    Overrides:
    
    executeQuery 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<java.lang.String,ConnectionPool> 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
  - releaseInvalidClientSession
```
public void releaseInvalidClientSession(ClientSession clientSession)
                                 throws DatabaseException
```
    INTERNAL: Release any invalid connection in the client session.
    
    Throws:
    
    DatabaseException
  - 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
  - setConnectionPools
```
public void setConnectionPools(java.util.Map<java.lang.String,ConnectionPool> 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.

Class ServerSession

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

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

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

Field Detail

readConnectionPool

connectionPools

defaultConnectionPolicy

numberOfNonPooledConnectionsUsed

maxNumberOfNonPooledConnections

NO_MAX

DEFAULT_POOL

NOT_POOLED

Constructor Detail

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

ServerSession

Method Detail

acquireClientConnection

acquireClientSession

acquireClientSession

acquireClientSession

acquireClientSession

acquireClientSession

acquireClientSession

acquireClientSession

acquireClientSession

acquireHistoricalSession

acquireUnitOfWork

addConnectionPool

addConnectionPool

allocateReadConnection

connect

disconnect

getAccessors

executeCall

releaseConnectionAfterCall

executeQuery

getConnectionPool

getConnectionPools

getDefaultConnectionPolicy

getDefaultConnectionPool

getExecutionSession

getMaxNumberOfNonPooledConnections

getNumberOfNonPooledConnectionsUsed

getReadLogin

getReadConnectionPool

isConnected

isServerSession

logout

releaseInvalidClientSession

releaseClientSession

releaseReadConnection

setConnectionPools

setDefaultConnectionPolicy

setDefaultConnectionPool

setMaxNumberOfNonPooledConnections

setNumberOfNonPooledConnectionsUsed

setReadConnectionPool

setReadConnectionPool

setSynchronized