## org.hibernate.engine.spi
Interface PersistenceContext.NaturalIdHelper

Enclosing interface:
  PersistenceContext

    public static interface PersistenceContext.NaturalIdHelper

Provides centralized access to natural-id-related functionality.

Field Summary
`static Serializable` `INVALID_NATURAL_ID_REFERENCE`

Method Summary
`void` `cacheNaturalIdCrossReferenceFromLoad(EntityPersister persister, Serializable id, Object[] naturalIdValues)` Performs processing related to creating natural-id cross-reference entries on load.
`void` `cleanupFromSynchronizations()` The clean up process of `handleSynchronization(org.hibernate.persister.entity.EntityPersister, java.io.Serializable, java.lang.Object)`.
`Object[]` `extractNaturalIdValues(Object[] state, EntityPersister persister)` Given an array of "full entity state", extract the portions that represent the natural id
`Object[]` `extractNaturalIdValues(Object entity, EntityPersister persister)` Given an entity instance, extract the values that represent the natural id
`Object[]` `findCachedNaturalId(EntityPersister persister, Serializable pk)` Given a persister and primary key, find the corresponding cross-referenced natural id values.
`Serializable` `findCachedNaturalIdResolution(EntityPersister persister, Object[] naturalIdValues)` Given a persister and natural-id values, find the corresponding cross-referenced primary key.
`Collection<Serializable>` `getCachedPkResolutions(EntityPersister persister)` Find all the locally cached primary key cross-reference entries for the given persister.
`void` `handleSynchronization(EntityPersister persister, Serializable pk, Object entity)` Part of the "load synchronization process".
`void` `manageLocalNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] state, Object[] previousState, CachedNaturalIdValueSource source)` Creates necessary local cross-reference entries.
`void` `manageSharedNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] state, Object[] previousState, CachedNaturalIdValueSource source)` Creates necessary shared (second level cache) cross-reference entries.
`Object[]` `removeLocalNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] state)` Cleans up local cross-reference entries.
`void` `removeSharedNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] naturalIdValues)` Cleans up local cross-reference entries.

Field Detail

### INVALID_NATURAL_ID_REFERENCE

    static final Serializable INVALID_NATURAL_ID_REFERENCE

Method Detail

### extractNaturalIdValues

    Object[] extractNaturalIdValues(Object[] state,
                                    EntityPersister persister)

  Given an array of "full entity state", extract the portions that represent the natural id

  Parameters:
    `state` - The attribute state array
    `persister` - The persister representing the entity type.
  Returns:
    The extracted natural id values

### extractNaturalIdValues

    Object[] extractNaturalIdValues(Object entity,
                                    EntityPersister persister)

  Given an entity instance, extract the values that represent the natural id

  Parameters:
    `entity` - The entity instance
    `persister` - The persister representing the entity type.
  Returns:
    The extracted natural id values

### cacheNaturalIdCrossReferenceFromLoad

    void cacheNaturalIdCrossReferenceFromLoad(EntityPersister persister,
                                              Serializable id,
                                              Object[] naturalIdValues)

  Performs processing related to creating natural-id cross-reference entries on load. Handles both the local (transactional) and shared (second-level) caches.

  Parameters:
    `persister` - The persister representing the entity type.
    `id` - The primary key value
    `naturalIdValues` - The natural id values

### manageLocalNaturalIdCrossReference

    void manageLocalNaturalIdCrossReference(EntityPersister persister,
                                            Serializable id,
                                            Object[] state,
                                            Object[] previousState,
                                            CachedNaturalIdValueSource source)

  Creates necessary local cross-reference entries.

  Parameters:
    `persister` - The persister representing the entity type.
    `id` - The primary key value
    `state` - Generally the "full entity state array", though could also be the natural id values array
    `previousState` - Generally the "full entity state array", though could also be the natural id values array. Specifically represents the previous values on update, and so is only used with `CachedNaturalIdValueSource.UPDATE`
    `source` - Enumeration representing how these values are coming into cache.

### removeLocalNaturalIdCrossReference

    Object[] removeLocalNaturalIdCrossReference(EntityPersister persister,
                                                Serializable id,
                                                Object[] state)

  Cleans up local cross-reference entries.

  Parameters:
    `persister` - The persister representing the entity type.
    `id` - The primary key value
    `state` - Generally the "full entity state array", though could also be the natural id values array
  Returns:
    The local cached natural id values (could be different from given values).

### manageSharedNaturalIdCrossReference

    void manageSharedNaturalIdCrossReference(EntityPersister persister,
                                             Serializable id,
                                             Object[] state,
                                             Object[] previousState,
                                             CachedNaturalIdValueSource source)

  Creates necessary shared (second level cache) cross-reference entries.

  Parameters:
    `persister` - The persister representing the entity type.
    `id` - The primary key value
    `state` - Generally the "full entity state array", though could also be the natural id values array
    `previousState` - Generally the "full entity state array", though could also be the natural id values array. Specifically represents the previous values on update, and so is only used with `CachedNaturalIdValueSource.UPDATE`
    `source` - Enumeration representing how these values are coming into cache.

### removeSharedNaturalIdCrossReference

    void removeSharedNaturalIdCrossReference(EntityPersister persister,
                                             Serializable id,
                                             Object[] naturalIdValues)

  Cleans up local cross-reference entries.

  Parameters:
    `persister` - The persister representing the entity type.
    `id` - The primary key value
    `naturalIdValues` - The natural id values array

### findCachedNaturalId

    Object[] findCachedNaturalId(EntityPersister persister,
                                 Serializable pk)

  Given a persister and primary key, find the corresponding cross-referenced natural id values.

  Parameters:
    `persister` - The persister representing the entity type.
    `pk` - The primary key value
  Returns:
    The cross-referenced natural-id values, or `null`

### findCachedNaturalIdResolution

    Serializable findCachedNaturalIdResolution(EntityPersister persister,
                                               Object[] naturalIdValues)

  Given a persister and natural-id values, find the corresponding cross-referenced primary key. Will return `INVALID_NATURAL_ID_REFERENCE` if the given natural ids are known to be invalid.

  Parameters:
    `persister` - The persister representing the entity type.
    `naturalIdValues` - The natural id value(s)
  Returns:
    The corresponding cross-referenced primary key, `INVALID_NATURAL_ID_REFERENCE`, or `null`.

### getCachedPkResolutions

    Collection<Serializable> getCachedPkResolutions(EntityPersister persister)

  Find all the locally cached primary key cross-reference entries for the given persister.

  Parameters:
    `persister` - The persister representing the entity type.
  Returns:
    The primary keys

### handleSynchronization

    void handleSynchronization(EntityPersister persister,
                               Serializable pk,
                               Object entity)

  Part of the "load synchronization process". Responsible for maintaining cross-reference entries when natural-id values were found to have changed. Also responsible for tracking the old values as no longer valid until the next flush because otherwise going to the database would just re-pull the old values as valid. In this last responsibility, `cleanupFromSynchronizations()` is the inverse process called after flush to clean up those entries.

  Parameters:
    `persister` - The persister representing the entity type.
    `pk` - The primary key
    `entity` - The entity instance
  See Also:
    `cleanupFromSynchronizations()`

### cleanupFromSynchronizations

    void cleanupFromSynchronizations()

  The clean up process of `handleSynchronization(org.hibernate.persister.entity.EntityPersister, java.io.Serializable, java.lang.Object)`. Responsible for cleaning up the tracking of old values as no longer valid.

Copyright © 2001-2012 Red Hat, Inc. All Rights Reserved.