Package org.eclipse.persistence.internal.sessions

Class IsolatedClientSessionIdentityMapAccessor

  • All Implemented Interfaces:
    Serializable, IdentityMapAccessor
    public class IsolatedClientSessionIdentityMapAccessor
extends IdentityMapAccessor
    INTERNAL: Internal subclass that provides access to identity maps through the session. Implements the IdentityMapAccessor interface which provides all publicly available identity map functionality to users. This is the main class that should be used to access identity maps. In general, any function that accesses the identity map manager should go through this class Any session specific functionality appears in subclasses
    See Also:
    Serialized Form

    • Field Detail

      • objectsLockedForClone

        protected Map objectsLockedForClone

    • Constructor Detail

      • IsolatedClientSessionIdentityMapAccessor

        public IsolatedClientSessionIdentityMapAccessor​(AbstractSession session)
        INTERNAL: An IdentityMapAccessor sits between the session and the identityMapManager It needs references in both directions

    • Method Detail

      • acquireDeferredLock

        public CacheKey acquireDeferredLock​(Object primaryKey,
                                    Class javaClass,
                                    ClassDescriptor descriptor,
                                    boolean isCacheCheckComplete)
        INTERNAL: Deferred lock the identity map for the object, this is used for avoiding deadlock The return cacheKey should be used to release the deferred lock
        Overrides:
        acquireDeferredLock in class IdentityMapAccessor

      • acquireLock

        public CacheKey acquireLock​(Object primaryKey,
                            Class domainClass,
                            boolean forMerge,
                            ClassDescriptor descriptor,
                            boolean isCacheCheckComplete)
        INTERNAL: 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.
        Overrides:
        acquireLock in class IdentityMapAccessor

      • acquireLockNoWait

        public CacheKey acquireLockNoWait​(Object primaryKey,
                                  Class domainClass,
                                  boolean forMerge,
                                  ClassDescriptor descriptor)
        INTERNAL: 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.
        Overrides:
        acquireLockNoWait in class IdentityMapAccessor

      • acquireLockWithWait

        public CacheKey acquireLockWithWait​(Object primaryKey,
                                    Class domainClass,
                                    boolean forMerge,
                                    ClassDescriptor descriptor,
                                    int wait)
        INTERNAL: 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.
        Overrides:
        acquireLockWithWait in class IdentityMapAccessor

      • 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.
        Overrides:
        acquireReadLockOnCacheKey in class IdentityMapAccessor

      • 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.
        Overrides:
        acquireReadLockOnCacheKeyNoWait in class IdentityMapAccessor

      • acquireWriteLock

        public boolean acquireWriteLock()
        INTERNAL: 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.
        Overrides:
        acquireWriteLock in class IdentityMapAccessor

      • getAllFromIdentityMap

        public Vector getAllFromIdentityMap​(Expression selectionCriteria,
                                    Class theClass,
                                    Record translationRow,
                                    int valueHolderPolicy,
                                    boolean shouldReturnInvalidatedObjects)
                             throws QueryException
        ADVANCED: Query the cache in-memory. If the expression is too complex an exception will be thrown. Only return objects that are invalid in the cache if specified.
        Specified by:
        getAllFromIdentityMap in interface IdentityMapAccessor
        Overrides:
        getAllFromIdentityMap in class IdentityMapAccessor
        Parameters:
        selectionCriteria - Expression selecting the Objects to be returned
        theClass - Class to be considered
        translationRow - Record
        valueHolderPolicy - see InMemoryQueryIndirectionPolicy
        shouldReturnInvalidatedObjects - boolean - true if only invalid Objects should be returned
        Returns:
        Vector of Objects
        Throws:
        QueryException

      • getCacheKeyForObject

        public CacheKey getCacheKeyForObject​(Object primaryKey,
                                     Class myClass,
                                     ClassDescriptor descriptor,
                                     boolean forMerge)
        INTERNAL: Retrieve the cache key for the given identity information.
        Overrides:
        getCacheKeyForObject in class IdentityMapAccessor
        Parameters:
        primaryKey - the primary key of the cache key to be retrieved.
        myClass - the class of the cache key to be retrieved.

      • getCacheKeyForObjectForLock

        public CacheKey getCacheKeyForObjectForLock​(Object primaryKey,
                                            Class myClass,
                                            ClassDescriptor descriptor)
        INTERNAL: Retrieve the cache key for the given identity information.
        Overrides:
        getCacheKeyForObjectForLock in class IdentityMapAccessor
        Parameters:
        primaryKey - the primary key of the cache key to be retrieved.
        myClass - the class of the cache key to be retrieved.

      • getAndCloneCacheKeyFromParent

        protected Object getAndCloneCacheKeyFromParent​(Object primaryKey,
                                               Object objectToClone,
                                               Class theClass,
                                               boolean shouldReturnInvalidatedObjects,
                                               ClassDescriptor descriptor)

      • getFromLocalIdentityMap

        public Object getFromLocalIdentityMap​(Object primaryKey,
                                      Class theClass,
                                      boolean shouldReturnInvalidatedObjects,
                                      ClassDescriptor descriptor)
        INTERNAL: Return the object from the local identity map with the primary and class. This avoids checking the parent cache for the unit of work.
        Overrides:
        getFromLocalIdentityMap in class IdentityMapAccessor

      • getFromIdentityMap

        public Object getFromIdentityMap​(Expression selectionCriteria,
                                 Class theClass,
                                 Record translationRow,
                                 int valueHolderPolicy,
                                 boolean conforming,
                                 boolean shouldReturnInvalidatedObjects,
                                 ClassDescriptor descriptor)
        INTERNAL: Query the cache in-memory. If the object is not found null is returned. If the expression is too complex an exception will be thrown.
        Overrides:
        getFromIdentityMap in class IdentityMapAccessor

      • getIdentityMapManager

        public IdentityMapManager getIdentityMapManager()
        INTERNAL: Get the IdentityMapManager for this IdentityMapAccessor This method should be used for all IdentityMapManager access since it may be overridden in sub classes.
        Overrides:
        getIdentityMapManager in class IdentityMapAccessor

      • getQueryResult

        public Object getQueryResult​(ReadQuery query,
                             List parameters,
                             boolean checkExpiry)
        INTERNAL: 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.
        Overrides:
        getQueryResult in class IdentityMapAccessor

      • getWrapper

        public Object getWrapper​(Object primaryKey,
                         Class theClass)
        INTERNAL: Get the wrapper object from the cache key associated with the given primary key, this is used for EJB.
        Overrides:
        getWrapper in class IdentityMapAccessor

      • initializeAllIdentityMaps

        public void initializeAllIdentityMaps()
        PUBLIC: Reset the entire object cache.

        NOTE: be careful using this method. This method blows away both this session's and its parents caches, this includes the server cache or any other cache. This throws away any objects that have been read in. Extream caution should be used before doing this because object identity will no longer be maintained for any objects currently read in. This should only be called if the application knows that it no longer has references to object held in the cache.

        Specified by:
        initializeAllIdentityMaps in interface IdentityMapAccessor
        Overrides:
        initializeAllIdentityMaps in class IdentityMapAccessor

      • initializeIdentityMap

        public void initializeIdentityMap​(Class theClass)
        PUBLIC: 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. Caution must be used in doing this to ensure that the objects within the identity map are not referenced from other objects of other classes or from the application.
        Specified by:
        initializeIdentityMap in interface IdentityMapAccessor
        Overrides:
        initializeIdentityMap in class IdentityMapAccessor
        Parameters:
        theClass - Class

      • initializeIdentityMaps

        public void initializeIdentityMaps()
        PUBLIC: Reset the entire local object cache. This throws away any objects that have been read in. Extreme caution should be used before doing this because object identity will no longer be maintained for any objects currently read in. This should only be called if the application knows that it no longer has references to object held in the cache.
        Specified by:
        initializeIdentityMaps in interface IdentityMapAccessor
        Overrides:
        initializeIdentityMaps in class IdentityMapAccessor

      • putQueryResult

        public void putQueryResult​(ReadQuery query,
                           List parameters,
                           Object results)
        INTERNAL: 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.
        Overrides:
        putQueryResult in class IdentityMapAccessor

      • internalPutInIdentityMap

        public CacheKey internalPutInIdentityMap​(Object domainObject,
                                         Object key,
                                         Object writeLockValue,
                                         long readTime,
                                         ClassDescriptor descriptor)
        ADVANCED: 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.
        Overrides:
        internalPutInIdentityMap in class IdentityMapAccessor

      • invalidateObjects

        public void invalidateObjects​(Expression selectionCriteria,
                              Class theClass,
                              Record translationRow,
                              boolean shouldInvalidateOnException)
        ADVANCED: Queries the cache in-memory with the passed in criteria and invalidates matching Objects. If the expression is too complex either all or none object of theClass invalidated (depending on shouldInvalidateOnException value).
        Specified by:
        invalidateObjects in interface IdentityMapAccessor
        Overrides:
        invalidateObjects in class IdentityMapAccessor
        Parameters:
        selectionCriteria - Expression selecting the Objects to be returned
        theClass - Class to be considered
        translationRow - Record
        shouldInvalidateOnException - boolean indicates weather to invalidate the object if conform threw exception.

      • releaseWriteLock

        public void releaseWriteLock()
        INTERNAL: 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.
        Overrides:
        releaseWriteLock in class IdentityMapAccessor

      • setWrapper

        public void setWrapper​(Object primaryKey,
                       Class theClass,
                       Object wrapper)
        INTERNAL: Update the wrapper object the cache key associated with the given primary key, this is used for EJB.
        Overrides:
        setWrapper in class IdentityMapAccessor