|
EclipseLink 2.3.2, build 'v20111125-r10461' API Reference | ||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.eclipse.persistence.internal.sessions.AbstractSession
org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
org.eclipse.persistence.sessions.server.ServerSession
public class ServerSession
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:
Server
,
ClientSession
,
UnitOfWork
,
Serialized FormField Summary | |
---|---|
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 |
---|
isLoggedIn |
Fields inherited from class org.eclipse.persistence.internal.sessions.AbstractSession |
---|
accessors, activeCommandThreads, broker, commandManager, commitManager, defaultReferenceMode, deferredEvents, descriptors, eventManager, exceptionHandler, externalTransactionController, identityMapAccessor, integrityChecker, isExecutingEvents, isFinalizersEnabled, isInBroker, isInProfile, isLoggingOff, isSynchronized, jpaQueries, lastDescriptorAccessed, logSessionString, name, numberOfActiveUnitsOfWork, objectsLockedForClone, partitioningPolicy, pessimisticLockTimeoutDefault, platform, profiler, project, properties, queries, queryTimeoutDefault, sessionLog, shouldCheckWriteLock, 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: 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 |
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, getDatasourcePlatform, getPlatform, getPlatform, getSequencing, getSequencingControl, getSequencingHome, getServerPlatform, initializeConnectedTime, initializeDescriptorIfSessionAlive, initializeDescriptors, initializeDescriptors, initializeDescriptors, initializeDescriptors, initializeDescriptors, initializeSequencing, isDatabaseSession, isLoggedIn, isProtectedSession, isSequencingCallbackRequired, login, login, login, loginAndDetectDatasource, postConnectDatasource, postLogin, preConnectDatasource, releaseJTSConnection, retryQuery, 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, basicExecuteCall, basicRollbackTransaction, beginExternalTransaction, beginTransaction, checkAndRefreshInvalidObject, checkHierarchyForDescriptor, clearDescriptors, clearIntegrityChecker, clearLastDescriptorAccessed, clearProfile, clone, commitExternalTransaction, commitTransaction, compareObjects, compareObjectsDontMatch, config, containsQuery, copy, copy, copyDescriptorNamedQueries, copyDescriptorsFromProject, copyInternal, copyObject, copyObject, copyReadOnlyClasses, createCloneQueryValueHolder, createCloneTransformationValueHolder, 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, getBroker, getCacheKeyFromTargetSessionForMerge, getClassDescriptor, getClassDescriptor, getClassDescriptorForAlias, getCommandManager, getCommitManager, getDatasourceLogin, getDefaultReadOnlyClasses, getDefaultReferenceMode, getDescriptor, getDescriptor, getDescriptorForAlias, getDescriptors, getEventManager, getExceptionHandler, getExceptionHandlerClass, getExternalTransactionController, getId, getIdentityMapAccessor, getIdentityMapAccessorInstance, getIntegrityChecker, getJPAQueries, getLoader, getLog, getLogin, getLogLevel, getLogLevel, getLogSessionString, getName, getNextQueryId, getNextSequenceNumberValue, getNumberOfActiveUnitsOfWork, getParent, getParentIdentityMapSession, getParentIdentityMapSession, getParentIdentityMapSession, getPartitioningPolicy, getPessimisticLockTimeoutDefault, getProfiler, getProject, getProperties, getProperty, getQueries, getQuery, getQuery, getQuery, getQuery, getQueryTimeoutDefault, getRootSession, getSessionForClass, getSessionForName, getSessionLog, getSessionTypeString, getStaticMetamodelClass, getTransactionMutex, handleException, handleSevere, hasBroker, hasCommitManager, hasDescriptor, hasEventManager, hasExceptionHandler, hasExternalTransactionController, hasProperties, incrementProfile, incrementProfile, info, initializeIdentityMapAccessor, insertObject, internalExecuteQuery, isBroker, isClassReadOnly, isClassReadOnly, isClientSession, isConsideredInvalid, isDistributedSession, isExclusiveConnectionRequired, isExclusiveIsolatedClientSession, isFinalizersEnabled, isHistoricalSession, isInBroker, isInProfile, isInTransaction, isIsolatedClientSession, isLoggingOff, isRemoteSession, isRemoteUnitOfWork, isSessionBroker, isSynchronized, isUnitOfWork, keyFromObject, keyFromObject, load, log, log, log, log, log, log, log, log, log, log, logMessage, logMessage, logThrowable, postAcquireConnection, prepareDatabaseQuery, preReleaseConnection, priviledgedExecuteNonSelectingCall, priviledgedExecuteSelectingCall, processCommand, processJPAQueries, 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, setEventManager, setExceptionHandler, setExternalTransactionController, setIntegrityChecker, setIsFinalizersEnabled, setIsInBroker, setIsInProfile, setLog, setLogin, setLogin, setLogLevel, setName, setNumberOfActiveUnitsOfWork, setPartitioningPolicy, setPessimisticLockTimeoutDefault, setProfiler, setProject, setProperties, setProperty, setQueries, setQueryTimeoutDefault, setSessionLog, setShouldPropagateChanges, setTransactionMutex, setWasJTSTransactionInternallyStarted, severe, shouldDisplayData, 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, addSequence, beginTransaction, commitTransaction, deleteAllObjects, deleteObject, getCommandManager, getSequencingControl, getServerPlatform, insertObject, isInTransaction, login, login, login, refreshAndLockObject, refreshAndLockObject, rollbackTransaction, setCommandManager, setExternalTransactionController, setLogin, setServerPlatform, setShouldPropagateChanges, shouldPropagateChanges, updateObject, writeAllObjects, writeObject |
Field Detail |
---|
protected ConnectionPool readConnectionPool
protected java.util.Map<java.lang.String,ConnectionPool> connectionPools
protected ConnectionPolicy defaultConnectionPolicy
protected int numberOfNonPooledConnectionsUsed
protected int maxNumberOfNonPooledConnections
public static final int NO_MAX
public static final java.lang.String DEFAULT_POOL
public static final java.lang.String NOT_POOLED
Constructor Detail |
---|
public ServerSession()
Project.createServerSession()
public ServerSession(Login login)
Project.createServerSession()
public ServerSession(Login login, int minNumberOfPooledConnection, int maxNumberOfPooledConnection)
Project.createServerSession(int, int)
public ServerSession(Login login, ConnectionPolicy defaultConnectionPolicy)
Project.createServerSession(ConnectionPolicy)
public ServerSession(Project project)
This is used by JPA, and SessionManager.
public ServerSession(Project project, int minNumberOfPooledConnection, int maxNumberOfPooledConnection)
Project.createServerSession(int, int)
public ServerSession(Project project, int initialNumberOfPooledConnection, int minNumberOfPooledConnection, int maxNumberOfPooledConnection)
Project.createServerSession(int, int, int)
public ServerSession(Project project, int minNumberOfPooledConnection, int maxNumberOfPooledConnection, Login readLogin)
project
- the project associated with this sessionminNumberOfPooledConnection
- the minimum number of connections in the poolmaxNumberOfPooledConnection
- the maximum number of connections in the poolreadLogin
- the login used to create the read connection poolProject.createServerSession(int, int)
public ServerSession(Project project, int minNumberOfPooledConnection, int maxNumberOfPooledConnection, Login readLogin, Login sequenceLogin)
Project.createServerSession(int, int)
public ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy, int initialNumberOfPooledConnections, int minNumberOfPooledConnections, int maxNumberOfPooledConnections, Login readLogin, Login sequenceLogin)
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
project
- the project associated with this sessiondefaultConnectionPolicy
- the default connection policy to be usedinitialNumberOfPooledConnections
- the minimum number of connections in the poolminNumberOfPooledConnections
- the minimum number of connections in the poolmaxNumberOfPooledConnections
- the maximum number of connections in the poolreadLogin
- the login used to create the read connection poolsequenceLogin
- the login used to create a connection pool for sequencingProject.createServerSession(int, int)
public ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy)
Project.createServerSession(ConnectionPolicy)
public ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy, Login readLogin)
Project.createServerSession(ConnectionPolicy)
public ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy, Login readLogin, Login sequenceLogin)
Project.createServerSession(ConnectionPolicy)
Method Detail |
---|
public void acquireClientConnection(ClientSession clientSession) throws DatabaseException, ConcurrencyException
DatabaseException
ConcurrencyException
public ClientSession acquireClientSession() throws DatabaseException
acquireClientSession
in interface Server
DatabaseException
public ClientSession acquireClientSession(java.util.Map properties) throws DatabaseException
DatabaseException
public ClientSession acquireClientSession(java.lang.String poolName) throws DatabaseException
acquireClientSession
in interface Server
DatabaseException
public ClientSession acquireClientSession(java.lang.String poolName, java.util.Map properties) throws DatabaseException
DatabaseException
public ClientSession acquireClientSession(Login login) throws DatabaseException
acquireClientSession
in interface Server
DatabaseException
public ClientSession acquireClientSession(Login login, java.util.Map properties) throws DatabaseException
DatabaseException
public ClientSession acquireClientSession(ConnectionPolicy connectionPolicy) throws DatabaseException, ValidationException
acquireClientSession
in interface Server
DatabaseException
ValidationException
public ClientSession acquireClientSession(ConnectionPolicy connectionPolicy, java.util.Map properties) throws DatabaseException, ValidationException
DatabaseException
ValidationException
public Session acquireHistoricalSession(AsOfClause clause) throws ValidationException
acquireHistoricalSession
in interface Session
acquireHistoricalSession
in class org.eclipse.persistence.internal.sessions.AbstractSession
clause
- Represents a valid snap shot time.
ValidationException
- if this
not a ClientSession, plain Session, or SessionBroker.AsOfClause
,
Expression.asOf(org.eclipse.persistence.history.AsOfClause)
,
ObjectLevelReadQuery.setAsOfClause(org.eclipse.persistence.history.AsOfClause)
,
HistoryPolicy
public org.eclipse.persistence.internal.sessions.UnitOfWorkImpl acquireUnitOfWork()
acquireUnitOfWork
in interface Session
acquireUnitOfWork
in class org.eclipse.persistence.internal.sessions.AbstractSession
UnitOfWorkImpl
public void addConnectionPool(java.lang.String poolName, Login login, int minNumberOfConnections, int maxNumberOfConnections) throws ValidationException
addConnectionPool
in interface Server
ValidationException
public void addConnectionPool(ConnectionPool pool)
addConnectionPool
in interface Server
public org.eclipse.persistence.internal.databaseaccess.Accessor allocateReadConnection()
public void connect()
connect
in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
public void disconnect() throws DatabaseException
disconnect
in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
DatabaseException
public java.util.List<org.eclipse.persistence.internal.databaseaccess.Accessor> getAccessors(Call call, org.eclipse.persistence.internal.sessions.AbstractRecord translationRow, DatabaseQuery query)
getAccessors
in class org.eclipse.persistence.internal.sessions.AbstractSession
public java.lang.Object executeCall(Call call, org.eclipse.persistence.internal.sessions.AbstractRecord translationRow, DatabaseQuery query) throws DatabaseException
executeCall
in class org.eclipse.persistence.internal.sessions.AbstractSession
DatabaseException
public java.lang.Object executeQuery(DatabaseQuery query, java.util.List argumentValues) throws DatabaseException
executeQuery
in interface Session
executeQuery
in class org.eclipse.persistence.internal.sessions.AbstractSession
DatabaseException
public ConnectionPool getConnectionPool(java.lang.String poolName)
getConnectionPool
in interface Server
public java.util.Map<java.lang.String,ConnectionPool> getConnectionPools()
public ConnectionPolicy getDefaultConnectionPolicy()
getDefaultConnectionPolicy
in interface Server
public ConnectionPool getDefaultConnectionPool()
getDefaultConnectionPool
in interface Server
public org.eclipse.persistence.internal.sessions.AbstractSession getExecutionSession(DatabaseQuery query)
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.
getExecutionSession
in class org.eclipse.persistence.internal.sessions.AbstractSession
query
- may store session name or reference class for brokers case
public int getMaxNumberOfNonPooledConnections()
getMaxNumberOfNonPooledConnections
in interface Server
public int getNumberOfNonPooledConnectionsUsed()
protected Login getReadLogin()
getReadLogin
in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
public ConnectionPool getReadConnectionPool()
getReadConnectionPool
in interface Server
Server.setReadConnectionPool(ConnectionPool)
,
Server.useExclusiveReadConnectionPool(int, int)
,
Server.useExternalReadConnectionPool()
,
Server.useReadConnectionPool(int, int)
public boolean isConnected()
isConnected
in interface Session
isConnected
in class org.eclipse.persistence.internal.sessions.AbstractSession
public boolean isServerSession()
isServerSession
in interface Session
isServerSession
in class org.eclipse.persistence.internal.sessions.AbstractSession
public void logout()
logout
in interface DatabaseSession
logout
in class org.eclipse.persistence.internal.sessions.DatabaseSessionImpl
public void releaseInvalidClientSession(ClientSession clientSession) throws DatabaseException
DatabaseException
public void releaseClientSession(ClientSession clientSession) throws DatabaseException
DatabaseException
public void releaseReadConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection)
releaseReadConnection
in class org.eclipse.persistence.internal.sessions.AbstractSession
public void setConnectionPools(java.util.Map<java.lang.String,ConnectionPool> connectionPools)
public void setDefaultConnectionPolicy(ConnectionPolicy defaultConnectionPolicy)
setDefaultConnectionPolicy
in interface Server
public void setDefaultConnectionPool()
public void setMaxNumberOfNonPooledConnections(int maxNumberOfNonPooledConnections)
setMaxNumberOfNonPooledConnections
in interface Server
public void setNumberOfNonPooledConnectionsUsed(int numberOfNonPooledConnectionsUsed)
int
- public void setReadConnectionPool(ConnectionPool readConnectionPool)
setReadConnectionPool
in interface Server
public void setReadConnectionPool(Login readLogin) throws ValidationException
ValidationException
public void setSynchronized(boolean synched)
setSynchronized
in class org.eclipse.persistence.internal.sessions.AbstractSession
protected void updateStandardConnectionPools()
public void useExclusiveReadConnectionPool(int minNumerOfConnections, int maxNumerOfConnections)
useExclusiveReadConnectionPool
in interface Server
Server.getReadConnectionPool()
,
Server.setReadConnectionPool(ConnectionPool)
,
Server.useReadConnectionPool(int, int)
,
Server.useExternalReadConnectionPool()
public void useExclusiveReadConnectionPool(int initialNumberOfConnections, int minNumerOfConnections, int maxNumerOfConnections)
useExclusiveReadConnectionPool
in interface Server
Server.getReadConnectionPool()
,
Server.setReadConnectionPool(ConnectionPool)
,
Server.useReadConnectionPool(int, int)
,
Server.useExternalReadConnectionPool()
public void useExternalReadConnectionPool()
useExternalReadConnectionPool
in interface Server
Server.getReadConnectionPool()
,
Server.setReadConnectionPool(ConnectionPool)
,
Server.useReadConnectionPool(int, int)
,
Server.useExclusiveReadConnectionPool(int, int)
public void useReadConnectionPool(int minNumerOfConnections, int maxNumerOfConnections)
useReadConnectionPool
in interface Server
maxNumerOfConnections
- As multiple readers can use the same connection
concurrently fewer connections are needed.useExclusiveReadConnectionPool(int, int)
public void useReadConnectionPool(int initialNumerOfConnections, int minNumerOfConnections, int maxNumerOfConnections)
useReadConnectionPool
in interface Server
initialNumerOfConnections
- connections connected at startupminNumerOfConnections
- connections that are pooledmaxNumerOfConnections
- As multiple readers can use the same connection
concurrently fewer connections are needed.useExclusiveReadConnectionPool(int, int, int)
public void validateQuery(DatabaseQuery query)
validateQuery
in class org.eclipse.persistence.internal.sessions.AbstractSession
public org.eclipse.persistence.internal.sequencing.SequencingServer getSequencingServer()
|
EclipseLink 2.3.2, build 'v20111125-r10461' API Reference | ||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |