public class ServerSession extends org.eclipse.persistence.internal.sessions.DatabaseSessionImpl implements Server
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 Form| 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 |
connectedTime, databaseEventListener, isLoggedIn, sequencingHome, serverPlatform, tuneraccessors, activeCommandThreads, attributeGroups, broker, commandManager, commitManager, defaultReferenceMode, deferredEvents, descriptors, eventManager, exceptionHandler, externalTransactionController, identityMapAccessor, injectionManager, 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, queryTimeoutUnitDefault, serializer, sessionLog, shouldCheckWriteLock, shouldOptimizeResultSetAccess, shouldPropagateChanges, staticMetamodelClasses, tablePerTenantDescriptors, tablePerTenantQueries, tolerateInvalidJPQL, transactionMutex, wasJTSTransactionInternallyStartedLOG_DEBUG, LOG_ERROR, LOG_INFO, LOG_WARNING| 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.
|
| 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.
|
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, writeAllObjectsacquireNonSynchronizedUnitOfWork, acquireNonSynchronizedUnitOfWork, acquireRepeatableWriteUnitOfWork, acquireUnitOfWork, addAlias, addJPAQuery, addJPATablePerTenantQuery, addMultitenantContextProperty, addQuery, addQuery, addQuery, addStaticMetamodelClass, addTablePerTenantDescriptor, addTablePerTenantQuery, basicBeginTransaction, basicBeginTransaction, basicCommitTransaction, basicExecuteCall, basicRollbackTransaction, beginExternalTransaction, beginTransaction, buildDefaultQueryBuilder, checkAndRefreshInvalidObject, checkHierarchyForDescriptor, cleanUpInjectionManager, clearDescriptors, clearIntegrityChecker, clearLastDescriptorAccessed, clearProfile, clone, commitExternalTransaction, commitTransaction, compareObjects, compareObjectsDontMatch, config, containsQuery, copy, copy, copyDescriptorNamedQueries, copyDescriptorsFromProject, copyInternal, copyObject, copyObject, copyReadOnlyClasses, createCloneQueryValueHolder, createCloneTransformationValueHolder, createInjectionManager, 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, getEventManager, getExceptionHandler, getExceptionHandlerClass, getExternalTransactionController, getId, getIdentityMapAccessor, getIdentityMapAccessorInstance, getInjectionManager, 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, getQueryTimeoutUnitDefault, 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, setEventManager, setExceptionHandler, setExternalTransactionController, setInjectionManager, setIntegrityChecker, setIsConcurrent, setIsFinalizersEnabled, setIsInBroker, setIsInProfile, setJPAQueriesProcessed, setLog, setLoggingOff, setLogin, setLogin, setLogLevel, setName, setNumberOfActiveUnitsOfWork, setPartitioningPolicy, setPessimisticLockTimeoutDefault, setProfiler, setProject, setProperties, setProperty, setQueries, setQueryBuilder, setQueryTimeoutDefault, setQueryTimeoutUnitDefault, setRefreshMetadataListener, setSerializer, setSessionLog, setShouldOptimizeResultSetAccess, setShouldPropagateChanges, setTolerateInvalidJPQL, setTransactionMutex, setWasJTSTransactionInternallyStarted, severe, shouldDisplayData, shouldLog, shouldLogMessages, shouldLogMessages, shouldOptimizeResultSetAccess, shouldPropagateChanges, shouldTolerateInvalidJPQL, startOperationProfile, startOperationProfile, toString, unwrapObject, updateObject, updateProfile, updateTablePerTenantDescriptors, validateCache, verifyDelete, warning, wasJTSTransactionInternallyStarted, wrapObject, writeAllObjectsWithChangeSet, writeObject, writesCompletedequals, getClass, hashCode, notify, notifyAll, wait, wait, waitsetDatasourceLoginaddDescriptor, 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, writeObjectacquireUnitOfWork, 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, setQueryTimeoutUnitDefault, setSerializer, setSessionLog, shouldLog, shouldLogMessages, validateCacheprotected 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
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)
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)
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)
public ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy, Login readLogin)
public ServerSession(Project project, ConnectionPolicy defaultConnectionPolicy, Login readLogin, Login sequenceLogin)
public void acquireClientConnection(ClientSession clientSession) throws DatabaseException, ConcurrencyException
public ClientSession acquireClientSession() throws DatabaseException
acquireClientSession in interface ServerDatabaseExceptionpublic ClientSession acquireClientSession(java.util.Map properties) throws DatabaseException
DatabaseExceptionpublic ClientSession acquireClientSession(java.lang.String poolName) throws DatabaseException
acquireClientSession in interface ServerDatabaseExceptionpublic ClientSession acquireClientSession(java.lang.String poolName, java.util.Map properties) throws DatabaseException
DatabaseExceptionpublic ClientSession acquireClientSession(Login login) throws DatabaseException
acquireClientSession in interface ServerDatabaseExceptionpublic ClientSession acquireClientSession(Login login, java.util.Map properties) throws DatabaseException
DatabaseExceptionpublic ClientSession acquireClientSession(ConnectionPolicy connectionPolicy) throws DatabaseException, ValidationException
acquireClientSession in interface ServerDatabaseExceptionValidationExceptionpublic ClientSession acquireClientSession(ConnectionPolicy connectionPolicy, java.util.Map properties) throws DatabaseException, ValidationException
DatabaseExceptionValidationExceptionpublic Session acquireHistoricalSession(AsOfClause clause) throws ValidationException
acquireHistoricalSession in interface SessionacquireHistoricalSession in class org.eclipse.persistence.internal.sessions.AbstractSessionclause - 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),
HistoryPolicypublic org.eclipse.persistence.internal.sessions.UnitOfWorkImpl acquireUnitOfWork()
acquireUnitOfWork in interface SessionacquireUnitOfWork in class org.eclipse.persistence.internal.sessions.AbstractSessionUnitOfWorkImplpublic void addConnectionPool(java.lang.String poolName,
Login login,
int minNumberOfConnections,
int maxNumberOfConnections)
throws ValidationException
addConnectionPool in interface ServerValidationExceptionpublic void addConnectionPool(ConnectionPool pool)
addConnectionPool in interface Serverpublic org.eclipse.persistence.internal.databaseaccess.Accessor allocateReadConnection()
public void connect()
connect in class org.eclipse.persistence.internal.sessions.DatabaseSessionImplpublic void disconnect()
throws DatabaseException
disconnect in class org.eclipse.persistence.internal.sessions.DatabaseSessionImplDatabaseExceptionpublic 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.AbstractSessionpublic 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.AbstractSessionDatabaseExceptionpublic void releaseConnectionAfterCall(DatabaseQuery query)
releaseConnectionAfterCall in class org.eclipse.persistence.internal.sessions.AbstractSessionquery - public java.lang.Object executeQuery(DatabaseQuery query, java.util.List argumentValues) throws DatabaseException
executeQuery in interface SessionexecuteQuery in class org.eclipse.persistence.internal.sessions.AbstractSessionDatabaseExceptionpublic ConnectionPool getConnectionPool(java.lang.String poolName)
getConnectionPool in interface Serverpublic java.util.Map<java.lang.String,ConnectionPool> getConnectionPools()
public ConnectionPolicy getDefaultConnectionPolicy()
getDefaultConnectionPolicy in interface Serverpublic ConnectionPool getDefaultConnectionPool()
getDefaultConnectionPool in interface Serverpublic 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.AbstractSessionquery - may store session name or reference class for brokers casepublic int getMaxNumberOfNonPooledConnections()
getMaxNumberOfNonPooledConnections in interface Serverpublic int getNumberOfNonPooledConnectionsUsed()
protected Login getReadLogin()
getReadLogin in class org.eclipse.persistence.internal.sessions.DatabaseSessionImplpublic ConnectionPool getReadConnectionPool()
public boolean isConnected()
isConnected in interface SessionisConnected in class org.eclipse.persistence.internal.sessions.AbstractSessionpublic boolean isServerSession()
isServerSession in interface SessionisServerSession in class org.eclipse.persistence.internal.sessions.AbstractSessionpublic void logout()
logout in interface DatabaseSessionlogout in class org.eclipse.persistence.internal.sessions.DatabaseSessionImplpublic void releaseInvalidClientSession(ClientSession clientSession) throws DatabaseException
DatabaseExceptionpublic void releaseClientSession(ClientSession clientSession) throws DatabaseException
DatabaseExceptionpublic void releaseReadConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection)
releaseReadConnection in class org.eclipse.persistence.internal.sessions.AbstractSessionpublic void setConnectionPools(java.util.Map<java.lang.String,ConnectionPool> connectionPools)
public void setDefaultConnectionPolicy(ConnectionPolicy defaultConnectionPolicy)
setDefaultConnectionPolicy in interface Serverpublic void setDefaultConnectionPool()
public void setMaxNumberOfNonPooledConnections(int maxNumberOfNonPooledConnections)
setMaxNumberOfNonPooledConnections in interface Serverpublic void setNumberOfNonPooledConnectionsUsed(int numberOfNonPooledConnectionsUsed)
numberOfNonPooledConnectionsUsed - public void setReadConnectionPool(ConnectionPool readConnectionPool)
setReadConnectionPool in interface Serverpublic void setReadConnectionPool(Login readLogin) throws ValidationException
ValidationExceptionpublic void setSynchronized(boolean synched)
setSynchronized in class org.eclipse.persistence.internal.sessions.AbstractSessionprotected void updateStandardConnectionPools()
public void useExclusiveReadConnectionPool(int minNumerOfConnections,
int maxNumerOfConnections)
public void useExclusiveReadConnectionPool(int initialNumberOfConnections,
int minNumerOfConnections,
int maxNumerOfConnections)
public void useExternalReadConnectionPool()
public void useReadConnectionPool(int minNumerOfConnections,
int maxNumerOfConnections)
useReadConnectionPool in interface ServermaxNumerOfConnections - 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 ServerinitialNumerOfConnections - 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.AbstractSessionpublic org.eclipse.persistence.internal.sequencing.SequencingServer getSequencingServer()