Class IsolatedClientSessionIdentityMapAccessor

java.lang.Object
org.eclipse.persistence.internal.sessions.IdentityMapAccessor
org.eclipse.persistence.internal.sessions.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:
  • Field Details

    • objectsLockedForClone

      protected Map objectsLockedForClone
  • Constructor Details

    • IsolatedClientSessionIdentityMapAccessor

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

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

      public boolean containsObjectInIdentityMap(Object primaryKey, Class<?> theClass, ClassDescriptor descriptor)
      ADVANCED: Return if their is an object for the primary key.
      Overrides:
      containsObjectInIdentityMap in class IdentityMapAccessor
    • getClassesRegistered

      public Vector getClassesRegistered()
      INTERNAL: This method is used to get a list of those classes with IdentityMaps in the Session.
      Overrides:
      getClassesRegistered in class IdentityMapAccessor
    • getAllFromIdentityMap

      public Vector getAllFromIdentityMap(Expression selectionCriteria, Class<?> theClass, DataRecord 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.
    • getFromIdentityMap

      public Object getFromIdentityMap(Object primaryKey, Object object, Class<?> theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)
      ADVANCED: Return the object from the identity with the primary and class.
      Overrides:
      getFromIdentityMap in class IdentityMapAccessor
    • 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, DataRecord 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
    • getFromIdentityMapWithDeferredLock

      public Object getFromIdentityMapWithDeferredLock(Object primaryKey, Class<?> theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor)
      INTERNAL: Return the object from the identity with the primary and class. Only return invalidated objects if requested
      Overrides:
      getFromIdentityMapWithDeferredLock 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
    • getIdentityMap

      public IdentityMap getIdentityMap(ClassDescriptor descriptor, boolean returnNullIfMissing)
      INTERNAL: Get the identity map for the given class from the IdentityMapManager
      Overrides:
      getIdentityMap 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
    • getSession

      public AbstractSession getSession()
      INTERNAL: get the session associated with this IdentityMapAccessor
      Overrides:
      getSession 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
    • getWriteLockManager

      public WriteLockManager getWriteLockManager()
      INTERNAL: Returns the single write Lock manager for this session
      Overrides:
      getWriteLockManager in class IdentityMapAccessor
    • getWriteLockValue

      public Object getWriteLockValue(Object primaryKey, Class<?> theClass, ClassDescriptor descriptor)
      ADVANCED: Extract the write lock value from the identity map.
      Overrides:
      getWriteLockValue 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
    • 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.
      Specified by:
      invalidateQueryCache in interface IdentityMapAccessor
      Overrides:
      invalidateQueryCache in class IdentityMapAccessor
    • 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
    • putCacheKeyByIndex

      public void putCacheKeyByIndex(CacheIndex index, CacheId indexValues, CacheKey cacheKey, ClassDescriptor descriptor)
      Index the cache key by the index values.
      Overrides:
      putCacheKeyByIndex in class IdentityMapAccessor
    • 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.
      Overrides:
      getCacheKeyByIndex in class IdentityMapAccessor
    • printIdentityMap

      public void printIdentityMap(Class<?> businessClass)
      PUBLIC: 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.
      Specified by:
      printIdentityMap in interface IdentityMapAccessor
      Overrides:
      printIdentityMap in class IdentityMapAccessor
    • printIdentityMaps

      public void printIdentityMaps()
      PUBLIC: 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.
      Specified by:
      printIdentityMaps in interface IdentityMapAccessor
      Overrides:
      printIdentityMaps in class IdentityMapAccessor
    • printIdentityMapLocks

      public void printIdentityMapLocks()
      PUBLIC: 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.
      Specified by:
      printIdentityMapLocks in interface IdentityMapAccessor
      Overrides:
      printIdentityMapLocks 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, DataRecord 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
    • removeFromIdentityMap

      public Object removeFromIdentityMap(Object key, Class<?> theClass, ClassDescriptor descriptor, Object object)
      ADVANCED: Remove the object from the object cache.
      Overrides:
      removeFromIdentityMap in class IdentityMapAccessor
    • setIdentityMapManager

      public void setIdentityMapManager(IdentityMapManager identityMapManager)
      INTERNAL: Set the IdentityMapManager for this IdentityMapAccessor
      Overrides:
      setIdentityMapManager 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
    • updateWriteLockValue

      public void updateWriteLockValue(Object primaryKey, Class<?> theClass, Object writeLockValue)
      ADVANCED: Update the write lock value in the identity map.
      Specified by:
      updateWriteLockValue in interface IdentityMapAccessor
      Overrides:
      updateWriteLockValue in class IdentityMapAccessor