/** * 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.handlingTransientEntity(); if ( transientEntities.contains( entity ) ) { LOG.trace( "Already handled transient entity; skipping" ); return; } transientEntities.add( entity ); cascadeBeforeDelete( session, persister, entity, null, transientEntities ); cascadeAfterDelete( session, persister, entity, transientEntities ); }
/** * Handle the given delete event. * * @param event The delete event to be handled. * * @throws HibernateException */ public void onDelete(DeleteEvent event) throws HibernateException { onDelete( event, new IdentitySet() ); }
/** * 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) { if ( jpaBootstrap ) { disallowDeletionOfDetached( 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 }
deleteTransientEntity( source, entity, event.isCascadeDeleteEnabled(), persister, transientEntities ); performDetachedEntityDeletionCheck( event ); if ( invokeDeleteLifecycle( source, entity, persister ) ) { return; deleteEntity( source, entity,
final Object[] deletedState = createDeletedState( persister, currentState, session ); entityEntry.setDeletedState( deletedState ); final EntityKey key = session.generateEntityKey( entityEntry.getId(), persister ); cascadeBeforeDelete( session, persister, entity, entityEntry, transientEntities ); cascadeAfterDelete( session, persister, entity, transientEntities );
new DefaultDeleteEventListener(), listenerArray );
@Override protected boolean invokeDeleteLifecycle(EventSource session, Object entity, EntityPersister persister) { callbackHandler.preRemove( entity ); return super.invokeDeleteLifecycle( session, entity, persister ); }
deleteTransientEntity( source, entity, event.isCascadeDeleteEnabled(), persister, transientEntities ); performDetachedEntityDeletionCheck( event ); if ( invokeDeleteLifecycle( source, entity, persister ) ) { return; deleteEntity( source, entity, entityEntry, event.isCascadeDeleteEnabled(), persister, transientEntities );
final Object[] deletedState = createDeletedState( persister, currentState, session ); entityEntry.setDeletedState( deletedState ); final EntityKey key = session.generateEntityKey( entityEntry.getId(), persister ); cascadeBeforeDelete( session, persister, entity, entityEntry, transientEntities ); cascadeAfterDelete( session, persister, entity, transientEntities );
deleteTransientEntity( source, entity, event.isCascadeDeleteEnabled(), persister, transientEntities ); performDetachedEntityDeletionCheck( event ); if ( invokeDeleteLifecycle( source, entity, persister ) ) { return; deleteEntity( source, entity, entityEntry, event.isCascadeDeleteEnabled(), persister, transientEntities );
final Object[] deletedState = createDeletedState( persister, currentState, session ); entityEntry.setDeletedState( deletedState ); final EntityKey key = session.generateEntityKey( entityEntry.getId(), persister ); cascadeBeforeDelete( session, persister, entity, entityEntry, transientEntities ); cascadeAfterDelete( session, persister, entity, transientEntities );
/** * 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.handlingTransientEntity(); if ( transientEntities.contains( entity ) ) { LOG.trace( "Already handled transient entity; skipping" ); return; } transientEntities.add( entity ); cascadeBeforeDelete( session, persister, entity, null, transientEntities ); cascadeAfterDelete( session, persister, entity, transientEntities ); }
/** * Handle the given delete event. * * @param event The delete event to be handled. * * @throws HibernateException */ public void onDelete(DeleteEvent event) throws HibernateException { onDelete( event, new IdentitySet() ); }
new DefaultDeleteEventListener(), workMap );
/** * 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) { if ( jpaBootstrap ) { disallowDeletionOfDetached( 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 }
deleteTransientEntity( source, entity, event.isCascadeDeleteEnabled(), descriptor, transientEntities ); performDetachedEntityDeletionCheck( event ); if ( invokeDeleteLifecycle( source, entity, descriptor ) ) { return; deleteEntity( source, entity,
final Object[] deletedState = createDeletedState( entityDescriptor, currentState, session ); entityEntry.setDeletedState( deletedState ); final EntityKey key = session.generateEntityKey( entityEntry.getId(), entityDescriptor ); cascadeBeforeDelete( session, entityDescriptor, entity, entityEntry, transientEntities ); cascadeAfterDelete( session, entityDescriptor, entity, transientEntities );
/** * 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 descriptor The entity descriptor * @param transientEntities A cache of already visited transient entities * (to avoid infinite recursion). */ protected void deleteTransientEntity( EventSource session, Object entity, boolean cascadeDeleteEnabled, EntityTypeDescriptor descriptor, Set transientEntities) { LOG.handlingTransientEntity(); if ( transientEntities.contains( entity ) ) { LOG.trace( "Already handled transient entity; skipping" ); return; } transientEntities.add( entity ); cascadeBeforeDelete( session, descriptor, entity, null, transientEntities ); cascadeAfterDelete( session, descriptor, entity, transientEntities ); }
/** * Handle the given delete event. * * @param event The delete event to be handled. * * @throws HibernateException */ public void onDelete(DeleteEvent event) throws HibernateException { onDelete( event, new IdentitySet() ); }