Open Source Repository

Home /hibernate/hibernate-3.2.7.ga | Repository Home


org/hibernate/event/def/DefaultDeleteEventListener.java
//$Id: DefaultDeleteEventListener.java 10949 2006-12-07 21:53:41Z [email protected] $
package org.hibernate.event.def;

import java.io.Serializable;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.hibernate.CacheMode;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.TransientObjectException;
import org.hibernate.util.IdentitySet;
import org.hibernate.action.EntityDeleteAction;
import org.hibernate.classic.Lifecycle;
import org.hibernate.engine.Cascade;
import org.hibernate.engine.CascadingAction;
import org.hibernate.engine.EntityEntry;
import org.hibernate.engine.EntityKey;
import org.hibernate.engine.ForeignKeys;
import org.hibernate.engine.Nullability;
import org.hibernate.engine.PersistenceContext;
import org.hibernate.engine.Status;
import org.hibernate.event.DeleteEvent;
import org.hibernate.event.DeleteEventListener;
import org.hibernate.event.EventSource;
import org.hibernate.persister.entity.EntityPersister;
import org.hibernate.pretty.MessageHelper;
import org.hibernate.type.Type;
import org.hibernate.type.TypeFactory;


/**
 * Defines the default delete event listener used by hibernate for deleting entities
 * from the datastore in response to generated delete events.
 *
 @author Steve Ebersole
 */
public class DefaultDeleteEventListener implements DeleteEventListener {

  private static final Log log = LogFactory.getLogDefaultDeleteEventListener.class );

  /**
   * Handle the given delete event.
   *
   @param event The delete event to be handled.
   *
   @throws HibernateException
   */
  public void onDelete(DeleteEvent eventthrows HibernateException {
    onDeleteevent, new IdentitySet() );
  }

  /**
   * Handle the given delete event.  This is the cascaded form.
   *
   @param event The delete event.
   @param transientEntities The cache of entities already deleted
   *
   @throws HibernateException
   */
  public void onDelete(DeleteEvent event, Set transientEntitiesthrows HibernateException {

    final EventSource source = event.getSession();

    final PersistenceContext persistenceContext = source.getPersistenceContext();
    Object entity = persistenceContext.unproxyAndReassociateevent.getObject() );

    EntityEntry entityEntry = persistenceContext.getEntryentity );
    final EntityPersister persister;
    final Serializable id;
    final Object version;

    if entityEntry == null ) {
      log.trace"entity was not persistent in delete processing" );

      persister = source.getEntityPersisterevent.getEntityName(), entity );

      if ForeignKeys.isTransientpersister.getEntityName(), entity, null, source ) ) {
        deleteTransientEntitysource, entity, event.isCascadeDeleteEnabled(), persister, transientEntities );
        // EARLY EXIT!!!
        return;
      }
      else {
        performDetachedEntityDeletionCheckevent );
      }

      id = persister.getIdentifierentity, source.getEntityMode() );

      if id == null ) {
        throw new TransientObjectException(
            "the detached instance passed to delete() had a null identifier"
        );
      }

      EntityKey key = new EntityKeyid, persister, source.getEntityMode() );

      persistenceContext.checkUniquenesskey, entity );

      new OnUpdateVisitorsource, id, entity ).processentity, persister );

      version = persister.getVersionentity, source.getEntityMode() );

      entityEntry = persistenceContext.addEntity(
          entity,
          Status.MANAGED,
          persister.getPropertyValuesentity, source.getEntityMode() ),
          key,
          version,
          LockMode.NONE,
          true,
          persister,
          false,
          false
      );
    }
    else {
      log.trace"deleting a persistent instance" );

      if entityEntry.getStatus() == Status.DELETED || entityEntry.getStatus() == Status.GONE ) {
        log.trace"object was already deleted" );
        return;
      }
      persister = entityEntry.getPersister();
      id = entityEntry.getId();
      version = entityEntry.getVersion();
    }

    /*if ( !persister.isMutable() ) {
      throw new HibernateException(
          "attempted to delete an object of immutable class: " +
          MessageHelper.infoString(persister)
        );
    }*/

    if invokeDeleteLifecyclesource, entity, persister ) ) {
      return;
    }

    deleteEntitysource, entity, entityEntry, event.isCascadeDeleteEnabled(), persister, transientEntities );

    if source.getFactory().getSettings().isIdentifierRollbackEnabled() ) {
      persister.resetIdentifierentity, id, version, source.getEntityMode() );
    }
  }

  /**
   * Called when we have recognized an attempt to delete a detached entity.
   <p/>
   * This is perfectly valid in Hibernate usage; JPA, however, forbids this.
   * Thus, this is a hook for HEM to affect this behavior.
   *
   @param event The event.
   */
  protected void performDetachedEntityDeletionCheck(DeleteEvent event) {
    // ok in normal Hibernate usage to delete a detached entity; JPA however
    // forbids it, thus this is a hook for HEM to affect this behavior
  }

  /**
   * We encountered a delete request on a transient instance.
   <p/>
   * This is a deviation from historical Hibernate (pre-3.2) behavior to
   * align with the JPA spec, which states that transient entities can be
   * passed to remove operation in which case cascades still need to be
   * performed.
   *
   @param session The session which is the source of the event
   @param entity The entity being delete processed
   @param cascadeDeleteEnabled Is cascading of deletes enabled
   @param persister The entity persister
   @param transientEntities A cache of already visited transient entities
   * (to avoid infinite recursion).
   */
  protected void deleteTransientEntity(
      EventSource session,
      Object entity,
      boolean cascadeDeleteEnabled,
      EntityPersister persister,
      Set transientEntities) {
    log.info"handling transient entity in delete processing" );
    if transientEntities.containsentity ) ) {
      log.trace"already handled transient entity; skipping" );
      return;
    }
    transientEntities.addentity );
    cascadeBeforeDeletesession, persister, entity, null, transientEntities );
    cascadeAfterDeletesession, persister, entity, transientEntities );
  }

  /**
   * Perform the entity deletion.  Well, as with most operations, does not
   * really perform it; just schedules an action/execution with the
   {@link org.hibernate.engine.ActionQueue} for execution during flush.
   *
   @param session The originating session
   @param entity The entity to delete
   @param entityEntry The entity's entry in the {@link PersistenceContext}
   @param isCascadeDeleteEnabled Is delete cascading enabled?
   @param persister The entity persister.
   @param transientEntities A cache of already deleted entities.
   */
  protected final void deleteEntity(
      final EventSource session,
      final Object entity,
      final EntityEntry entityEntry,
      final boolean isCascadeDeleteEnabled,
      final EntityPersister persister,
      final Set transientEntities) {

    if log.isTraceEnabled() ) {
      log.trace(
          "deleting " +
              MessageHelper.infoStringpersister, entityEntry.getId(), session.getFactory() )
      );
    }

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final Type[] propTypes = persister.getPropertyTypes();
    final Object version = entityEntry.getVersion();

    final Object[] currentState;
    if entityEntry.getLoadedState() == null ) { //ie. the entity came in from update()
      currentState = persister.getPropertyValuesentity, session.getEntityMode() );
    }
    else {
      currentState = entityEntry.getLoadedState();
    }

    final Object[] deletedState = createDeletedStatepersister, currentState, session );
    entityEntry.setDeletedStatedeletedState );

    session.getInterceptor().onDelete(
        entity,
        entityEntry.getId(),
        deletedState,
        persister.getPropertyNames(),
        propTypes
    );

    // before any callbacks, etc, so subdeletions see that this deletion happened first
    persistenceContext.setEntryStatusentityEntry, Status.DELETED );
    EntityKey key = new EntityKeyentityEntry.getId(), persister, session.getEntityMode() );

    cascadeBeforeDeletesession, persister, entity, entityEntry, transientEntities );

    new ForeignKeys.Nullifierentity, true, false, session )
        .nullifyTransientReferencesentityEntry.getDeletedState(), propTypes );
    new Nullabilitysession ).checkNullabilityentityEntry.getDeletedState(), persister, true );
    persistenceContext.getNullifiableEntityKeys().addkey );

    // Ensures that containing deletions happen before sub-deletions
    session.getActionQueue().addAction(
        new EntityDeleteAction(
            entityEntry.getId(),
            deletedState,
            version,
            entity,
            persister,
            isCascadeDeleteEnabled,
            session
        )
    );

    cascadeAfterDeletesession, persister, entity, transientEntities );

    // the entry will be removed after the flush, and will no longer
    // override the stale snapshot
    // This is now handled by removeEntity() in EntityDeleteAction
    //persistenceContext.removeDatabaseSnapshot(key);
  }

  private Object[] createDeletedState(EntityPersister persister, Object[] currentState, EventSource session) {
    Type[] propTypes = persister.getPropertyTypes();
    final Object[] deletedState = new Object[propTypes.length];
//    TypeFactory.deepCopy( currentState, propTypes, persister.getPropertyUpdateability(), deletedState, session );
    boolean[] copyability = new boolean[propTypes.length];
    java.util.Arrays.fillcopyability, true );
    TypeFactory.deepCopycurrentState, propTypes, copyability, deletedState, session );
    return deletedState;
  }

  protected boolean invokeDeleteLifecycle(EventSource session, Object entity, EntityPersister persister) {
    if persister.implementsLifecyclesession.getEntityMode() ) ) {
      log.debug"calling onDelete()" );
      if ( ( ( Lifecycle entity ).onDeletesession ) ) {
        log.debug"deletion vetoed by onDelete()" );
        return true;
      }
    }
    return false;
  }

  protected void cascadeBeforeDelete(
      EventSource session,
      EntityPersister persister,
      Object entity,
      EntityEntry entityEntry,
      Set transientEntitiesthrows HibernateException {

    CacheMode cacheMode = session.getCacheMode();
    session.setCacheModeCacheMode.GET );
    session.getPersistenceContext().incrementCascadeLevel();
    try {
      // cascade-delete to collections BEFORE the collection owner is deleted
      new CascadeCascadingAction.DELETE, Cascade.AFTER_INSERT_BEFORE_DELETE, session )
          .cascadepersister, entity, transientEntities );
    }
    finally {
      session.getPersistenceContext().decrementCascadeLevel();
      session.setCacheModecacheMode );
    }
  }

  protected void cascadeAfterDelete(
      EventSource session,
      EntityPersister persister,
      Object entity,
      Set transientEntitiesthrows HibernateException {

    CacheMode cacheMode = session.getCacheMode();
    session.setCacheModeCacheMode.GET );
    session.getPersistenceContext().incrementCascadeLevel();
    try {
      // cascade-delete to many-to-one AFTER the parent was deleted
      new CascadeCascadingAction.DELETE, Cascade.BEFORE_INSERT_AFTER_DELETE, session )
          .cascadepersister, entity, transientEntities );
    }
    finally {
      session.getPersistenceContext().decrementCascadeLevel();
      session.setCacheModecacheMode );
    }
  }

}