Module org.eclipse.persistence.core
Package org.eclipse.persistence.internal.identitymaps

Class IdentityMapManager

java.lang.Object
org.eclipse.persistence.internal.identitymaps.IdentityMapManager
All Implemented Interfaces:
Serializable, Cloneable
public class IdentityMapManager extends Object implements Serializable, Cloneable

Purpose: Maintain identity maps for domain classes mapped with EclipseLink.

Responsibilities:

  • Build new identity maps lazily using info from the descriptor
  • Insert objects into appropriate identity map
  • Get object from appropriate identity map using object or primary key with class
  • Get and Set write lock values for cached objects
Since:
TOPLink/Java 1.0
See Also:

  • Field Details

    • MONITOR_PREFIX

      protected static final String MONITOR_PREFIX
      See Also:

    • identityMaps

      protected Map<Class<?>,IdentityMap> identityMaps
      A table of identity maps with the key being the domain Class.

    • queryResults

      protected Map<Object,IdentityMap> queryResults
      A table of identity maps with the key being the query

    • queryResultsInvalidationsByClass

      protected Map<Class<?>,Set> queryResultsInvalidationsByClass
      A map of class to list of queries that need to be invalidated when that class changes.

    • cacheIndexes

      protected Map<CacheIndex,IdentityMap> cacheIndexes
      A map of indexes on the cache.

    • session

      protected AbstractSession session
      A reference to the session owning this manager.

    • cacheMutex

      protected transient ConcurrencyManager cacheMutex
      Ensure mutual exclusion depending on the cache isolation.

    • lastAccessedIdentityMap

      protected IdentityMap lastAccessedIdentityMap
      PERF: Optimize the object retrieval from the identity map.

    • writeLockManager

      protected transient WriteLockManager writeLockManager
      Used to store the write lock manager used for merging.

    • isCacheAccessPreCheckRequired

      protected boolean isCacheAccessPreCheckRequired
      PERF: Used to avoid readLock and profiler checks to improve performance.

  • Constructor Details

    • IdentityMapManager

      protected IdentityMapManager()

    • IdentityMapManager

      public IdentityMapManager(AbstractSession session)

  • Method Details

    • acquireDeferredLock

      public CacheKey acquireDeferredLock(Object primaryKey, Class<?> domainClass, ClassDescriptor descriptor, boolean isCacheCheckComplete)
      Provides access for setting a deferred lock on an object in the IdentityMap.

    • acquireLock

      public CacheKey acquireLock(Object primaryKey, Class<?> domainClass, boolean forMerge, ClassDescriptor descriptor, boolean isCacheCheckComplete)
      Provides access for setting a concurrency lock on an object in the IdentityMap. called with true from the merge process, if true then the refresh will not refresh the object.

    • acquireLockNoWait

      public CacheKey acquireLockNoWait(Object primaryKey, Class<?> domainClass, boolean forMerge, ClassDescriptor descriptor)
      Provides access for setting a concurrency lock on an object in the IdentityMap. called with true from the merge process, if true then the refresh will not refresh the object.

    • acquireLockWithWait

      public CacheKey acquireLockWithWait(Object primaryKey, Class<?> domainClass, boolean forMerge, ClassDescriptor descriptor, int wait)
      Provides access for setting a concurrency lock on an object in the IdentityMap. called with true from the merge process, if true then the refresh will not refresh the object.

    • checkIsCacheAccessPreCheckRequired

      public void checkIsCacheAccessPreCheckRequired()
      PERF: Used to micro optimize cache access. Avoid the readLock and profile checks if not required.

    • acquireReadLock

      public void acquireReadLock()
      Provides access for setting a concurrency lock on an IdentityMap.

    • acquireReadLockOnCacheKey

      public CacheKey acquireReadLockOnCacheKey(Object primaryKey, Class<?> domainClass, ClassDescriptor descriptor)
      INTERNAL: Find the cachekey for the provided primary key and place a readlock on it. This will allow multiple users to read the same object but prevent writes to the object while the read lock is held.

    • acquireReadLockOnCacheKeyNoWait

      public CacheKey acquireReadLockOnCacheKeyNoWait(Object primaryKey, Class<?> domainClass, ClassDescriptor descriptor)
      INTERNAL: Find the cachekey for the provided primary key and place a readlock on it. This will allow multiple users to read the same object but prevent writes to the object while the read lock is held. If no readlock can be acquired then do not wait but return null.

    • acquireWriteLock

      public boolean acquireWriteLock()
      Lock the entire cache if the cache isolation requires. By default concurrent reads and writes are allowed. By write, unit of work merge is meant.

    • buildNewIdentityMap

      public IdentityMap buildNewIdentityMap(ClassDescriptor descriptor)
      INTERNAL: (Public to allow testing to access) Return a new empty identity map to cache instances of the class.

    • buildNewIdentityMap

      protected <T extends IdentityMap> IdentityMap buildNewIdentityMap(Class<T> identityMapClass, int size, ClassDescriptor descriptor, boolean isIsolated) throws DescriptorException
      INTERNAL: Return a new empty identity map of the class type.
      Throws:
      DescriptorException

    • clearLastAccessedIdentityMap

      public void clearLastAccessedIdentityMap()
      INTERNAL: Clear the the lastAccessedIdentityMap and the lastAccessedIdentityMapClass

    • clone

      public Object clone()
      INTERNAL: Clones itself, used for uow commit and resume on failure.
      Overrides:
      clone in class Object

    • clearQueryCache

      public void clearQueryCache()
      Clear all the query caches.

    • clearCacheIndexes

      public void clearCacheIndexes()
      Clear all index caches.

    • clearQueryCache

      public void clearQueryCache(ReadQuery query)
      Remove the cache key related to a query. Note this method is not synchronized and care should be taken to ensure there are no other threads accessing the cache key. This is used to clean up cached clones of queries.

    • invalidateQueryCache

      public void invalidateQueryCache(Class<?> classThatChanged)
      Invalidate/remove any results for the class from the query cache. This is used to invalidate the query cache on any change.

    • containsKey

      public boolean containsKey(Object key, Class<?> theClass, ClassDescriptor descriptor)
      Return true if an CacheKey with the primary key is in the map. User API.
      Parameters:
      key - is the primary key for the object to search for.

    • getAllFromIdentityMap

      public Vector getAllFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, int valueHolderPolicy, boolean shouldReturnInvalidatedObjects)
      Query the cache in-memory.

    • getAllFromIdentityMapWithEntityPK

      public Map<Object,Object> getAllFromIdentityMapWithEntityPK(Object[] pkList, ClassDescriptor descriptor, AbstractSession session)
      ADVANCED: Using a list of Entity PK this method will attempt to bulk load the entire list from the cache. In certain circumstances this can have large performance improvements over loading each item individually.
      Parameters:
      pkList - List of Entity PKs to extract from the cache
      descriptor - Descriptor type to be retrieved.
      Returns:
      Map of Entity PKs associated to the Entities that were retrieved

    • getAllCacheKeysFromIdentityMapWithEntityPK

      public Map<Object,CacheKey> getAllCacheKeysFromIdentityMapWithEntityPK(Object[] pkList, ClassDescriptor descriptor, AbstractSession session)
      ADVANCED: Using a list of Entity PK this method will attempt to bulk load the entire list from the cache. In certain circumstances this can have large performance improvements over loading each item individually.
      Parameters:
      pkList - List of Entity PKs to extract from the cache
      descriptor - Descriptor type to be retrieved.
      Returns:
      Map of Entity PKs associated to the Entities that were retrieved

    • invalidateObjects

      public void invalidateObjects(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, boolean shouldInvalidateOnException)
      Invalidate objects meeting selectionCriteria.

    • getCacheKeyForObjectForLock

      public CacheKey getCacheKeyForObjectForLock(Object primaryKey, Class<?> theClass, ClassDescriptor descriptor)
      Retrieve the cache key for the given identity information.

    • getCacheKeyForObject

      public CacheKey getCacheKeyForObject(Object primaryKey, Class<?> theClass, ClassDescriptor descriptor, boolean forMerge)
      Retrieve the cache key for the given identity information.

    • getCacheMutex

      public ConcurrencyManager getCacheMutex()
      Return the cache mutex. This allows for the entire cache to be locked. This is done for transaction isolations on merges, although never locked by default.

    • getClassesRegistered

      public Vector getClassesRegistered()
      This method is used to get a list of those classes with IdentityMaps in the Session.

    • getFromIdentityMap

      public Object getFromIdentityMap(Object object)
      Get the object from the identity map which has the same identity information as the given object.

    • getFromIdentityMap

      public Object getFromIdentityMap(Object key, Class<?> theClass, ClassDescriptor descriptor)
      Get the object from the identity map which has the given primary key and class.

    • getFromIdentityMap

      public Object getFromIdentityMap(Object key, Class<?> theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)
      Get the object from the identity map which has the given primary key and class. Only return the object if it has not been invalidated.

    • getFromIdentityMap

      public Object getFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord translationRow, int valueHolderPolicy, boolean conforming, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)

    • getFromIdentityMapWithDeferredLock

      public Object getFromIdentityMapWithDeferredLock(Object key, Class<?> theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)
      Get the object from the cache with the given primary key and class. Do not return the object if it was invalidated.

    • getIdentityMap

      public IdentityMap getIdentityMap(ClassDescriptor descriptor)
      INTERNAL: Return the identity map for the class, if missing create a new one.

    • getIdentityMap

      public IdentityMap getIdentityMap(ClassDescriptor descriptor, boolean returnNullIfNoMap)
      INTERNAL: Return the identity map for the class.
      Parameters:
      returnNullIfNoMap - if true return null if no map, otherwise create one.

    • getIdentityMaps

      protected Map<Class<?>,IdentityMap> getIdentityMaps()

    • getIdentityMapClasses

      public Iterator getIdentityMapClasses()
      Return an iterator of the classes in the identity map.

    • getQueryResult

      public Object getQueryResult(ReadQuery query, List parameters, boolean shouldCheckExpiry)
      Get the cached results associated with a query. Results are cached by the values of the parameters to the query so different parameters will have different cached results.

    • getCacheKeyByIndex

      public CacheKey getCacheKeyByIndex(CacheIndex index, CacheId indexValues, boolean shouldCheckExpiry, ClassDescriptor descriptor)
      Return the cache key for the cache index or null if not found.

    • putCacheKeyByIndex

      public void putCacheKeyByIndex(CacheIndex index, CacheId indexValues, CacheKey cacheKey, ClassDescriptor descriptor)
      Index the cache key by the index values.

    • getSession

      protected AbstractSession getSession()

    • getWrapper

      public Object getWrapper(Object primaryKey, Class<?> theClass)
      Get the wrapper object from the cache key associated with the given primary key, this is used for EJB.

    • getWriteLockManager

      public WriteLockManager getWriteLockManager()
      Returns the single write Lock manager for this session

    • getWriteLockValue

      public Object getWriteLockValue(Object primaryKey, Class<?> domainClass, ClassDescriptor descriptor)
      Retrieve the write lock value of the cache key associated with the given primary key,

    • initializeIdentityMap

      public void initializeIdentityMap(Class<?> theClass) throws EclipseLinkException
      Reset the identity map for only the instances of the class. For inheritance the user must make sure that they only use the root class.
      Throws:
      EclipseLinkException

    • initializeIdentityMaps

      public void initializeIdentityMaps()

    • printIdentityMap

      public void printIdentityMap(Class<?> businessClass)
      Used to print all the objects in the identity map of the passed in class. The output of this method will be logged to this session's SessionLog at SEVERE level.

    • printIdentityMaps

      public void printIdentityMaps()
      Used to print all the objects in every identity map in this session. The output of this method will be logged to this session's SessionLog at SEVERE level.

    • printLocks

      public void printLocks()
      Used to print all the Locks in every identity map in this session. The output of this method will be logged to this session's SessionLog at FINEST level.

    • printLocks

      public void printLocks(Class<?> theClass)
      Used to print all the Locks in the specified identity map in this session. The output of this method will be logged to this session's SessionLog at FINEST level.

    • putInIdentityMap

      public CacheKey putInIdentityMap(Object domainObject, Object keys, Object writeLockValue, long readTime, ClassDescriptor descriptor)
      Register the object with the identity map. The object must always be registered with its version number if optimistic locking is used. The readTime may also be included in the cache key as it is constructed

    • putQueryResult

      public void putQueryResult(ReadQuery query, List parameters, Object results)
      Set the results for a query. Query results are cached based on the parameter values provided to the query different parameter values access different caches.

    • releaseReadLock

      protected void releaseReadLock()
      Read-release the local-map and the entire cache.

    • releaseWriteLock

      public void releaseWriteLock()
      Lock the entire cache if the cache isolation requires. By default concurrent reads and writes are allowed. By write, unit of work merge is meant.

    • removeFromIdentityMap

      public Object removeFromIdentityMap(Object key, Class<?> domainClass, ClassDescriptor descriptor, Object objectToRemove)
      Remove the object from the object cache.

    • setCacheMutex

      protected void setCacheMutex(ConcurrencyManager cacheMutex)
      Set the cache mutex. This allows for the entire cache to be locked. This is done for transaction isolations on merges, although never locked by default.

    • setIdentityMaps

      public void setIdentityMaps(ConcurrentMap identityMaps)

    • setSession

      protected void setSession(AbstractSession session)

    • setWrapper

      public void setWrapper(Object primaryKey, Class<?> theClass, Object wrapper)
      Update the wrapper object the cache key associated with the given primary key, this is used for EJB.

    • setWriteLockValue

      public void setWriteLockValue(Object primaryKey, Class<?> theClass, Object writeLockValue)
      Update the write lock value of the cache key associated with the given primary key,

    • checkForInheritance

      protected Object checkForInheritance(Object domainObject, Class<?> superClass, ClassDescriptor descriptor)
      This method is used to resolve the inheritance issues arisen when conforming from the identity map 1. Avoid reading the unintended subclass during in-memory query(e.g. when querying on large project, do not want to check small project, both are inherited from the project, and stored in the same identity map). 2. EJB container-generated classes broke the inheritance hierarchy. Need to use associated descriptor to track the relationship. CR4005-2612426, King-Sept-18-2002