Interface PersistenceContext

  • public interface PersistenceContext
    Represents the state of "stuff" Hibernate is tracking, including (not exhaustive):
    • entities
    • collections
    • snapshots
    • proxies

    Often referred to as the "first level cache".

    • Field Detail

      • NO_ROW

        static final Object NO_ROW
        Marker object used to indicate (via reference checking) that no row was returned.
    • Method Detail

      • isStateless

        boolean isStateless()
      • getLoadContexts

        org.hibernate.engine.loading.internal.LoadContexts getLoadContexts()
        Retrieve this persistence context's managed load context.
        The load context
      • addUnownedCollection

        void addUnownedCollection​(CollectionKey key,
                                  PersistentCollection collection)
        Add a collection which has no owner loaded
        key - The collection key under which to add the collection
        collection - The collection to add
      • useUnownedCollection

        PersistentCollection useUnownedCollection​(CollectionKey key)
        Take ownership of a previously unowned collection, if one. This method returns null if no such collection was previously added () or was previously removed.

        This should indicate the owner is being loaded and we are ready to "link" them.

        key - The collection key for which to locate a collection collection
        The unowned collection, or null
      • getBatchFetchQueue

        BatchFetchQueue getBatchFetchQueue()
        Get the BatchFetchQueue, instantiating one if necessary.
        The batch fetch queue in effect for this persistence context
      • clear

        void clear()
        Clear the state of the persistence context
      • hasNonReadOnlyEntities

        boolean hasNonReadOnlyEntities()
        false if we know for certain that all the entities are read-only
      • setEntryStatus

        void setEntryStatus​(EntityEntry entry,
                            Status status)
        Set the status of an entry
        entry - The entry for which to set the status
        status - The new status
      • afterTransactionCompletion

        void afterTransactionCompletion()
        Called after transactions end
      • getNaturalIdSnapshot

        Object[] getNaturalIdSnapshot​(Serializable id,
                                      EntityPersister persister)
        Get the values of the natural id fields as known to the underlying database, or null if the entity has no natural id or there is no corresponding row.
        id - The identifier of the entity for which to grab a snapshot
        persister - The persister of the entity.
        The current (non-cached) snapshot of the entity's natural id state.
      • addEntity

        void addEntity​(EntityKey key,
                       Object entity)
        Add a canonical mapping from entity key to entity instance
        key - The key under which to add an entity
        entity - The entity instance to add
      • getEntity

        Object getEntity​(EntityKey key)
        Get the entity instance associated with the given key
        key - The key under which to look for an entity
        The matching entity, or null
      • containsEntity

        boolean containsEntity​(EntityKey key)
        Is there an entity with the given key in the persistence context
        key - The key under which to look for an entity
        true indicates an entity was found; otherwise false
      • removeEntity

        Object removeEntity​(EntityKey key)
        Remove an entity. Also clears up all other state associated with the entity aside from the EntityEntry
        key - The key whose matching entity should be removed
        The matching entity
      • addEntity

        void addEntity​(EntityUniqueKey euk,
                       Object entity)
        Add an entity to the cache by unique key
        euk - The unique (non-primary) key under which to add an entity
        entity - The entity instance
      • getEntity

        Object getEntity​(EntityUniqueKey euk)
        Get an entity cached by unique key
        euk - The unique (non-primary) key under which to look for an entity
        The located entity
      • getEntry

        EntityEntry getEntry​(Object entity)
        Retrieve the EntityEntry representation of the given entity.
        entity - The entity instance for which to locate the corresponding entry
        The entry
      • removeEntry

        EntityEntry removeEntry​(Object entity)
        Remove an entity entry from the session cache
        entity - The entity instance for which to remove the corresponding entry
        The matching entry
      • isEntryFor

        boolean isEntryFor​(Object entity)
        Is there an EntityEntry registration for this entity instance?
        entity - The entity instance for which to check for an entry
        true indicates a matching entry was found.
      • getCollectionEntry

        CollectionEntry getCollectionEntry​(PersistentCollection coll)
        Get the collection entry for a persistent collection
        coll - The persistent collection instance for which to locate the collection entry
        The matching collection entry
      • containsCollection

        boolean containsCollection​(PersistentCollection collection)
        Is the given collection associated with this persistence context?
      • containsProxy

        boolean containsProxy​(Object proxy)
        Is the given proxy associated with this persistence context?
      • reassociateIfUninitializedProxy

        boolean reassociateIfUninitializedProxy​(Object value)
                                         throws MappingException
        Takes the given object and, if it represents a proxy, reassociates it with this event source.
        value - The possible proxy to be reassociated.
        Whether the passed value represented an actual proxy which got initialized.
      • unproxy

        Object unproxy​(Object maybeProxy)
                throws HibernateException
        Get the entity instance underlying the given proxy, throwing an exception if the proxy is uninitialized. If the given object is not a proxy, simply return the argument.
      • unproxyAndReassociate

        Object unproxyAndReassociate​(Object maybeProxy)
                              throws HibernateException
        Possibly unproxy the given reference and reassociate it with the current session.
        maybeProxy - The reference to be unproxied if it currently represents a proxy.
        The unproxied instance.
      • checkUniqueness

        void checkUniqueness​(EntityKey key,
                             Object object)
                      throws HibernateException
        Attempts to check whether the given key represents an entity already loaded within the current session.
        object - The entity reference against which to perform the uniqueness check.
      • narrowProxy

        Object narrowProxy​(Object proxy,
                           EntityPersister persister,
                           EntityKey key,
                           Object object)
                    throws HibernateException
        If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy and overwrite the registration of the old one. This breaks == and occurs only for "class" proxies rather than "interface" proxies. Also init the proxy to point to the given target implementation if necessary.
        proxy - The proxy instance to be narrowed.
        persister - The persister for the proxied entity.
        key - The internal cache key for the proxied entity.
        object - (optional) the actual proxied entity instance.
        An appropriately narrowed instance.
      • proxyFor

        Object proxyFor​(Object impl)
                 throws HibernateException
        Return the existing proxy associated with the given EntityKey, or the argument (the entity associated with the key) if no proxy exists. (slower than the form above)
      • getLoadedCollectionOwnerOrNull

        Object getLoadedCollectionOwnerOrNull​(PersistentCollection collection)
        Get the entity that owned this persistent collection when it was loaded
        collection - The persistent collection
        the owner if its entity ID is available from the collection's loaded key and the owner entity is in the persistence context; otherwise, returns null
      • getLoadedCollectionOwnerIdOrNull

        Serializable getLoadedCollectionOwnerIdOrNull​(PersistentCollection collection)
        Get the ID for the entity that owned this persistent collection when it was loaded
        collection - The persistent collection
        the owner ID if available from the collection's loaded key; otherwise, returns null
      • addNonLazyCollection

        void addNonLazyCollection​(PersistentCollection collection)
        Register a collection for non-lazy loading at the end of the two-phase load
      • initializeNonLazyCollections

        void initializeNonLazyCollections()
                                   throws HibernateException
        Force initialization of all non-lazy collections encountered during the current two-phase load (actually, this is a no-op, unless this is the "outermost" load)
      • getCollectionHolder

        PersistentCollection getCollectionHolder​(Object array)
        Get the PersistentCollection object for an array
      • addCollectionHolder

        void addCollectionHolder​(PersistentCollection holder)
        Register a PersistentCollection object for an array. Associates a holder with an array - MUST be called after loading array, since the array instance is not created until endLoad().
      • removeCollectionHolder

        PersistentCollection removeCollectionHolder​(Object array)
        Remove the mapping of collection to holder during eviction of the owning entity
      • getCollectionEntryOrNull

        CollectionEntry getCollectionEntryOrNull​(Object collection)
        Get the collection entry for a collection passed to filter, which might be a collection wrapper, an array, or an unwrapped collection. Return null if there is no entry.
      • getProxy

        Object getProxy​(EntityKey key)
        Get an existing proxy by key
      • addProxy

        void addProxy​(EntityKey key,
                      Object proxy)
        Add a proxy to the session cache
      • removeProxy

        Object removeProxy​(EntityKey key)
        Remove a proxy from the session cache.

        Additionally, ensure that any load optimization references such as batch or subselect loading get cleaned up as well.

        key - The key of the entity proxy to be removed
        The proxy reference.
      • getEntitiesByKey

        Map getEntitiesByKey()
        this will be removed: it provides too wide access, making it hard to optimise the internals for specific access needs. Consider using #iterateEntities instead.
        Get the mapping from key value to entity instance
      • reentrantSafeEntityEntries

        Map.Entry<Object,​EntityEntry>[] reentrantSafeEntityEntries()
        Provides access to the entity/EntityEntry combos associated with the persistence context in a manner that is safe from reentrant access. Specifically, it is safe from additions/removals while iterating.
      • getNumberOfManagedEntities

        int getNumberOfManagedEntities()
      • forEachCollectionEntry

        void forEachCollectionEntry​(BiConsumer<PersistentCollection,​CollectionEntry> action,
                                    boolean concurrent)
        Execute some action on each entry of the collectionEntries map, optionally iterating on a defensive copy.
        action - the lambda to apply on each PersistentCollection,CollectionEntry map entry of the PersistenceContext.
        concurrent - set this to false for improved efficiency, but that would make it illegal to make changes to the underlying collectionEntries map.
      • getCollectionsByKey

        Map getCollectionsByKey()
        this method should be removed; alternative methods are available that better express the intent, allowing for better optimisations. Not aggressively removing this as it's an SPI, but also useful for testing and other contexts which are not performance sensitive. N.B. This might return an immutable map: do not use for mutations!
        Get the mapping from collection key to collection instance
      • getCascadeLevel

        int getCascadeLevel()
        How deep are we cascaded?
      • incrementCascadeLevel

        int incrementCascadeLevel()
        Called before cascading
      • decrementCascadeLevel

        int decrementCascadeLevel()
        Called after cascading
      • isFlushing

        boolean isFlushing()
        Is a flush cycle currently in process?
      • setFlushing

        void setFlushing​(boolean flushing)
        Called before and after the flush cycle
      • beforeLoad

        void beforeLoad()
        Call this before beginning a two-phase load
      • afterLoad

        void afterLoad()
        Call this after finishing a two-phase load
      • isLoadFinished

        boolean isLoadFinished()
        Is in a two-phase load?
      • toString

        String toString()
        Returns a string representation of the object.
        toString in class Object
        a string representation of the object.
      • getOwnerId

        Serializable getOwnerId​(String entityName,
                                String propertyName,
                                Object childEntity,
                                Map mergeMap)
        Search this persistence context for an associated entity instance which is considered the "owner" of the given childEntity, and return that owner's id value. This is performed in the scenario of a uni-directional, non-inverse one-to-many collection (which means that the collection elements do not maintain a direct reference to the owner).

        As such, the processing here is basically to loop over every entity currently associated with this persistence context and for those of the correct entity (sub) type to extract its collection role property value and see if the child is contained within that collection. If so, we have found the owner; if not, we go on.

        Also need to account for mergeMap which acts as a local copy cache managed for the duration of a merge operation. It represents a map of the detached entity instances pointing to the corresponding managed instance.

        entityName - The entity name for the entity type which would own the child
        propertyName - The name of the property on the owning entity type which would name this child association.
        childEntity - The child entity instance for which to locate the owner instance id.
        mergeMap - A map of non-persistent instances from an on-going merge operation (possibly null).
        The id of the entityName instance which is said to own the child; null if an appropriate owner not located.
      • getIndexInOwner

        Object getIndexInOwner​(String entity,
                               String property,
                               Object childObject,
                               Map mergeMap)
        Search the persistence context for an index of the child object, given a collection role
      • addNullProperty

        void addNullProperty​(EntityKey ownerKey,
                             String propertyName)
        Record the fact that the association belonging to the keyed entity is null.
      • isPropertyNull

        boolean isPropertyNull​(EntityKey ownerKey,
                               String propertyName)
        Is the association property belonging to the keyed entity null?
      • isDefaultReadOnly

        boolean isDefaultReadOnly()
        Will entities and proxies that are loaded into this persistence context be made read-only by default? To determine the read-only/modifiable setting for a particular entity or proxy:
        true, loaded entities/proxies will be made read-only by default; false, loaded entities/proxies will be made modifiable by default.
        See Also:
        isReadOnly(Object), Session.isReadOnly(Object), Session.isDefaultReadOnly()
      • setDefaultReadOnly

        void setDefaultReadOnly​(boolean readOnly)
        Change the default for entities and proxies loaded into this persistence context from modifiable to read-only mode, or from modifiable to read-only mode. Read-only entities are not dirty-checked and snapshots of persistent state are not maintained. Read-only entities can be modified, but changes are not persisted. When a proxy is initialized, the loaded entity will have the same read-only/modifiable setting as the uninitialized proxy has, regardless of the persistence context's current setting. To change the read-only/modifiable setting for a particular entity or proxy that is already in this session: + * @see PersistenceContext#setReadOnly(Object,boolean)
        readOnly - true, the default for loaded entities/proxies is read-only; false, the default for loaded entities/proxies is modifiable
        See Also:
        To override this session's read-only/modifiable setting for entities and proxies loaded by a Query:, Query.setReadOnly(boolean), Session.setDefaultReadOnly(boolean)
      • isReadOnly

        boolean isReadOnly​(Object entityOrProxy)
        Is the entity or proxy read-only?

        To determine the default read-only/modifiable setting used for entities and proxies that are loaded into the session use Session.isDefaultReadOnly()

        entityOrProxy - an entity or proxy
        true if the object is read-only; otherwise false to indicate that the object is modifiable.
      • setReadOnly

        void setReadOnly​(Object entityOrProxy,
                         boolean readOnly)
        Set an unmodified persistent object to read-only mode, or a read-only object to modifiable mode. Read-only entities are not dirty-checked and snapshots of persistent state are not maintained. Read-only entities can be modified, but changes are not persisted. When a proxy is initialized, the loaded entity will have the same read-only/modifiable setting as the uninitialized proxy has, regardless of the session's current setting. If the entity or proxy already has the specified read-only/modifiable setting, then this method does nothing.
        entityOrProxy - an entity or proxy
        readOnly - if true, the entity or proxy is made read-only; otherwise, the entity or proxy is made modifiable.
        See Also:
        Session.setDefaultReadOnly(boolean), Session.setReadOnly(java.lang.Object, boolean), Query.setReadOnly(boolean)
      • replaceDelayedEntityIdentityInsertKeys

        void replaceDelayedEntityIdentityInsertKeys​(EntityKey oldKey,
                                                    Serializable generatedId)
      • addChildParent

        void addChildParent​(Object child,
                            Object parent)
        Add a child/parent relation to cache for cascading op
        child - The child of the relationship
        parent - The parent of the relationship
      • removeChildParent

        void removeChildParent​(Object child)
        Remove child/parent relation from cache
        child - The child to be removed.
      • registerInsertedKey

        void registerInsertedKey​(EntityPersister persister,
                                 Serializable id)
        Register keys inserted during the current transaction
        persister - The entity persister
        id - The id
      • wasInsertedDuringTransaction

        boolean wasInsertedDuringTransaction​(EntityPersister persister,
                                             Serializable id)
        Allows callers to check to see if the identified entity was inserted during the current transaction.
        persister - The entity persister
        id - The id
        True if inserted during this transaction, false otherwise.
      • getCollectionEntriesSize

        int getCollectionEntriesSize()
        The size of the internal map storing all collection entries. (The map is not exposed directly, but the size is often useful)
        the size
      • clearCollectionsByKey

        void clearCollectionsByKey()
        Remove all state of the collections-by-key map.
      • addCollectionByKey

        PersistentCollection addCollectionByKey​(CollectionKey collectionKey,
                                                PersistentCollection persistentCollection)
        Adds a collection in the collections-by-key map.
        collectionKey -
        persistentCollection -
        the previous collection, it the key was already mapped.
      • removeCollectionByKey

        void removeCollectionByKey​(CollectionKey collectionKey)
        Remove a collection-by-key mapping.
        collectionKey - the key to clear
      • managedEntitiesIterator

        Iterator managedEntitiesIterator()
        A read-only iterator on all entities managed by this persistence context
      • getNaturalIdHelper

        PersistenceContext.NaturalIdHelper getNaturalIdHelper()
        Access to the natural-id helper for this persistence context
        This persistence context's natural-id helper