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

Class 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:
    Serialized Form

    • Field Detail

      • 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.

      • 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 Detail

      • IdentityMapManager

        protected IdentityMapManager()

      • IdentityMapManager

        public IdentityMapManager​(AbstractSession session)

    • Method Detail

      • 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.

      • 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.

      • 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.

      • 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)

      • 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