java.lang.Object
- org.eclipse.persistence.sessions.server.ConnectionPolicy

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable
```
public class ConnectionPolicy
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable
```
Purpose: Used to specify how a client session's should be allocated.
Description: The ConnectionPolicy is used to indicate how a client session will interact with the internal or external JDBC connection pool/data source. The default ConnectionPolicy is held on the ServerSession but this can be overridden for any specific client session when it is acquired.

See Also:

ServerSession.getDefaultConnectionPolicy(), ServerSession.acquireClientSession(ConnectionPolicy), ServerSession.acquireClientSession(ConnectionPolicy, Map), ClientSession.getConnectionPolicy(), Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`ConnectionPolicy.ExclusiveMode`	Default value Transactional causes creation of ClientSession, the other two values - ExclusiveIsolatedClientSession.

Field Summary

Fields
Modifier and Type	Field	Description
`protected ConnectionPolicy.ExclusiveMode`	`exclusiveMode`	This attribute is used by the ServerSession to determine if a client session with an exclusive connection should be built and how the exclusive connection should be used.
`protected boolean`	`isLazy`	Determines if the write/exclusive connection is acquired only when first requested (lazy, this is the default) or immediately when the client session is acquired.
`protected Login`	`login`	The login information used to create a JDBC connection or acquire one from an external pool/data-source.
`protected java.lang.String`	`poolName`	Name of the pool to be used.
`protected java.util.Map`	`properties`	This attribute will provide a mechanism by which customers will be able to pass connection information to events to enable further customization.

Constructor Summary

Constructors
Constructor	Description
`ConnectionPolicy()`	PUBLIC: A connection policy is used to define how the client session connection should be acquired.
`ConnectionPolicy(java.lang.String poolName)`	PUBLIC: A connection policy is used to define how the client session connection should be acquired.
`ConnectionPolicy(Login login)`	PUBLIC: A connection policy is used to define how the client session connection should be acquired.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`java.lang.Object`	`clone()`	INTERNAL: Clone the query
`void`	`dontUseLazyConnection()`	PUBLIC: A lazy connection only acquires a physical connection when a transaction is started and releases the connection when the transaction completes.
`ConnectionPolicy.ExclusiveMode`	`getExclusiveMode()`	PUBLIC: Returns exclusive mode.
`Login`	`getLogin()`	PUBLIC: Return the login to use for this connection.
`java.lang.String`	`getPoolName()`	PUBLIC: Return the pool name or null if not part of a pool.
`java.util.Map`	`getProperties()`	ADVANCED: This method will return the collection of custom properties set on the Connection policy.
`java.lang.Object`	`getProperty(java.lang.Object object)`	PUBLIC: Returns the property associated with the corresponding key.
`boolean`	`hasLogin()`	PUBLIC: Return if a login is used, only one of login and pool can be used.
`boolean`	`hasProperties()`	PUBLIC: Returns true if properties are available on the Connection Policy
`boolean`	`isExclusive()`	PUBLIC: Indicates whether ExclusiveIsolatedClientSession should be created.
`boolean`	`isExclusiveAlways()`	PUBLIC: Indicates whether exclusiveMode is Always.
`boolean`	`isExclusiveIsolated()`	PUBLIC: Indicates whether exclusiveMode is Isolated.
`boolean`	`isLazy()`	PUBLIC: Return if a lazy connection should be used, a lazy connection only acquire a physical connection when a transaction is started and releases the connection when the transaction completes.
`boolean`	`isPooled()`	INTERNAL: Return if part of a connection pool.
`boolean`	`isUserDefinedConnection()`	INTERNAL: Return if part of a connection pool.
`java.lang.Object`	`removeProperty(java.lang.Object key)`	PUBLIC: This method is used to remove a custom property from the Connection Policy.
`void`	`setExclusiveMode(ConnectionPolicy.ExclusiveMode exclusiveMode)`	PUBLIC: Sets exclusive mode, if null is passed sets the default value.
`void`	`setIsLazy(boolean isLazy)`	PUBLIC: Set if a lazy connection should be used, a lazy connection only acquire a physical connection when a transaction is started and releases the connection when the transaction completes.
`void`	`setLogin(Login login)`	PUBLIC: Set the login to use for this connection.
`void`	`setPoolName(java.lang.String poolName)`	PUBLIC: Set the pool name or null if not part of a pool.
`void`	`setProperty(java.lang.Object key, java.lang.Object property)`	PUBLIC: Use this method to set custom properties on the Connection Policy.
`void`	`setShouldUseExclusiveConnection(boolean useExclusiveConnection)`	Deprecated.
`boolean`	`shouldUseExclusiveConnection()`	Deprecated.
`java.lang.String`	`toString()`	INTERNAL: return a string representation of this ConnectionPolicy
`void`	`useLazyConnection()`	PUBLIC: A lazy connection only acquires a physical connection when a transaction is started and releases the connection when the transaction completes.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - login
```
protected Login login
```
    The login information used to create a JDBC connection or acquire one from an external pool/data-source. Typically this is constant within a single persistence unit but in some advanced usages users can customize connections for each client session.
  - poolName
```
protected java.lang.String poolName
```
    Name of the pool to be used. If neither pool name nor login provided then default pool will be used. If no pool name is provided but there's a login then the login is used to create connection which the ClientSession will use.
  - isLazy
```
protected boolean isLazy
```
    Determines if the write/exclusive connection is acquired only when first requested (lazy, this is the default) or immediately when the client session is acquired. After write/exclusive connection is acquired if isLazy is true and exclusiveMode is Transactional then it's held until transaction is committed or rolled back, otherwise until the client session is released.
  - exclusiveMode
```
protected ConnectionPolicy.ExclusiveMode exclusiveMode
```
    This attribute is used by the ServerSession to determine if a client session with an exclusive connection should be built and how the exclusive connection should be used.
  - properties
```
protected java.util.Map properties
```
    This attribute will provide a mechanism by which customers will be able to pass connection information to events to enable further customization.
- Constructor Detail
  - ConnectionPolicy
```
public ConnectionPolicy()
```
    PUBLIC: A connection policy is used to define how the client session connection should be acquired.
  - ConnectionPolicy
```
public ConnectionPolicy(java.lang.String poolName)
```
    PUBLIC: A connection policy is used to define how the client session connection should be acquired.
  - ConnectionPolicy
```
public ConnectionPolicy(Login login)
```
    PUBLIC: A connection policy is used to define how the client session connection should be acquired.
- Method Detail
  - clone
```
public java.lang.Object clone()
```
    INTERNAL: Clone the query
    
    Overrides:
    
    clone in class java.lang.Object
  - dontUseLazyConnection
```
public void dontUseLazyConnection()
```
    PUBLIC: A lazy connection only acquires a physical connection when a transaction is started and releases the connection when the transaction completes.
  - getLogin
```
public Login getLogin()
```
    PUBLIC: Return the login to use for this connection. Client sessions support using a separate user login for database modification.
  - getPoolName
```
public java.lang.String getPoolName()
```
    PUBLIC: Return the pool name or null if not part of a pool.
  - getProperties
```
public java.util.Map getProperties()
```
    ADVANCED: This method will return the collection of custom properties set on the Connection policy. Note that this will cause the lazy initialization of the HashMap.
  - getProperty
```
public java.lang.Object getProperty(java.lang.Object object)
```
    PUBLIC: Returns the property associated with the corresponding key. These properties will be available to connection events.
  - hasLogin
```
public boolean hasLogin()
```
    PUBLIC: Return if a login is used, only one of login and pool can be used.
  - hasProperties
```
public boolean hasProperties()
```
    PUBLIC: Returns true if properties are available on the Connection Policy
  - isExclusiveIsolated
```
public boolean isExclusiveIsolated()
```
    PUBLIC: Indicates whether exclusiveMode is Isolated.
  - isExclusiveAlways
```
public boolean isExclusiveAlways()
```
    PUBLIC: Indicates whether exclusiveMode is Always.
  - isExclusive
```
public boolean isExclusive()
```
    PUBLIC: Indicates whether ExclusiveIsolatedClientSession should be created.
  - isLazy
```
public boolean isLazy()
```
    PUBLIC: Return if a lazy connection should be used, a lazy connection only acquire a physical connection when a transaction is started and releases the connection when the transaction completes.
  - isPooled
```
public boolean isPooled()
```
    INTERNAL: Return if part of a connection pool.
  - isUserDefinedConnection
```
public boolean isUserDefinedConnection()
```
    INTERNAL: Return if part of a connection pool.
  - removeProperty
```
public java.lang.Object removeProperty(java.lang.Object key)
```
    PUBLIC: This method is used to remove a custom property from the Connection Policy. This method will return the propery removed. If it was not found then null will be returned.
  - setIsLazy
```
public void setIsLazy(boolean isLazy)
```
    PUBLIC: Set if a lazy connection should be used, a lazy connection only acquire a physical connection when a transaction is started and releases the connection when the transaction completes.
  - setLogin
```
public void setLogin(Login login)
```
    PUBLIC: Set the login to use for this connection. Client sessions support using a separate user login for database modification. Pooled connections must use the pool's login and cannot define their own.
  - setPoolName
```
public void setPoolName(java.lang.String poolName)
```
    PUBLIC: Set the pool name or null if not part of a pool.
  - setProperty
```
public void setProperty(java.lang.Object key,
                        java.lang.Object property)
```
    PUBLIC: Use this method to set custom properties on the Connection Policy. These properties will be available from within connection events but have no effect on the connection directly.
  - getExclusiveMode
```
public ConnectionPolicy.ExclusiveMode getExclusiveMode()
```
    PUBLIC: Returns exclusive mode.
  - setExclusiveMode
```
public void setExclusiveMode(ConnectionPolicy.ExclusiveMode exclusiveMode)
```
    PUBLIC: Sets exclusive mode, if null is passed sets the default value.
  - setShouldUseExclusiveConnection
```
public void setShouldUseExclusiveConnection(boolean useExclusiveConnection)
```
    Deprecated.
    
    OBSOLETE: If set to true the acquired client session should acquire an exclusive connection for all database interaction. Currently this is only supported with Isolated data, but required for Oracle VPD support. This method has been replaced with setExclusiveMode method: true corresponds to ExclusiveMode.Isolated, false - to ExclusiveMode.Transactional.
  - shouldUseExclusiveConnection
```
public boolean shouldUseExclusiveConnection()
```
    Deprecated.
    
    OBSOLETE: Returns true if the acquired client session should acquire an exclusive connection for all database interaction. Currently this is only supported with Isolated data, but required for Oracle VPD support. This method has been replaced with isExclusiveIsolated method.
  - toString
```
public java.lang.String toString()
```
    INTERNAL: return a string representation of this ConnectionPolicy
    
    Overrides:
    
    toString in class java.lang.Object
  - useLazyConnection
```
public void useLazyConnection()
```
    PUBLIC: A lazy connection only acquires a physical connection when a transaction is started and releases the connection when the transaction completes.

Class ConnectionPolicy

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

login

poolName

isLazy

exclusiveMode

properties

Constructor Detail

ConnectionPolicy

ConnectionPolicy

ConnectionPolicy

Method Detail

clone

dontUseLazyConnection

getLogin

getPoolName

getProperties

getProperty

hasLogin

hasProperties

isExclusiveIsolated

isExclusiveAlways

isExclusive

isLazy

isPooled

isUserDefinedConnection

removeProperty

setIsLazy

setLogin

setPoolName

setProperty

getExclusiveMode

setExclusiveMode

setShouldUseExclusiveConnection

shouldUseExclusiveConnection

toString

useLazyConnection