private void handlePostUpdate(Object entity, EventSource source) { EntityEntry entry = (EntityEntry) source.getPersistenceContext() .getEntityEntries().get(entity); // mimic the preUpdate filter if (Status.DELETED != entry.getStatus()) { callbackHandler.postUpdate(entity); } }
private void throwObjectDeletedIfNecessary(LoadEvent event, EntityEntry oldEntry) { Status status = oldEntry.getStatus(); if ( status == Status.DELETED || status == Status.GONE ) { throw new ObjectDeletedException( "The object with that id was deleted", event.getEntityId(), event.getEntityClassName() ); } }
/** * process cascade save/update at the start of a flush to discover * any newly referenced entity that must be passed to saveOrUpdate(), * and also apply orphan delete */ private void prepareEntityFlushes(SessionImplementor session) throws HibernateException { log.debug("processing flush-time cascades"); final Map.Entry[] list = IdentityMap.concurrentEntries( session.getPersistenceContext().getEntityEntries() ); //safe from concurrent modification because of how entryList() is implemented on IdentityMap final int size = list.length; for ( int i=0; i<size; i++ ) { Map.Entry me = list[i]; EntityEntry entry = (EntityEntry) me.getValue(); Status status = entry.getStatus(); if ( status == Status.MANAGED || status == Status.SAVING ) { cascadeOnFlush( session, entry.getPersister(), me.getKey() ); } } }
private boolean isVersionIncrementRequired( FlushEntityEvent event, EntityEntry entry, EntityPersister persister, int[] dirtyProperties ) { final boolean isVersionIncrementRequired = entry.getStatus()!=Status.DELETED && ( dirtyProperties==null || Versioning.isVersionIncrementRequired( dirtyProperties, event.hasDirtyCollection(), persister.getPropertyVersionability() ) ); return isVersionIncrementRequired; }
public boolean isNullifiable(boolean earlyInsert, SessionImplementor session) { return getStatus() == Status.SAVING || ( earlyInsert ? !isExistsInDatabase() : session.getPersistenceContext().getNullifiableEntityKeys() .contains( new EntityKey( getId(), getPersister(), entityMode ) ) ); }
/** * process cascade save/update at the start of a flush to discover * any newly referenced entity that must be passed to saveOrUpdate(), * and also apply orphan delete */ private void prepareEntityFlushes(EventSource session) throws HibernateException { log.debug("processing flush-time cascades"); final Map.Entry[] list = IdentityMap.concurrentEntries( session.getPersistenceContext().getEntityEntries() ); //safe from concurrent modification because of how entryList() is implemented on IdentityMap final int size = list.length; final Object anything = getAnything(); for ( int i=0; i<size; i++ ) { Map.Entry me = list[i]; EntityEntry entry = (EntityEntry) me.getValue(); Status status = entry.getStatus(); if ( status == Status.MANAGED || status == Status.SAVING ) { cascadeOnFlush( session, entry.getPersister(), me.getKey(), anything ); } } }
public boolean isNullifiable(boolean earlyInsert, SessionImplementor session) { return getStatus() == Status.SAVING || ( earlyInsert ? !isExistsInDatabase() : session.getPersistenceContext().getNullifiableEntityKeys() .contains( new EntityKey( getId(), getPersister(), entityMode ) ) ); }
@Override protected boolean invokeInterceptor( SessionImplementor session, Object entity, EntityEntry entry, Object[] values, EntityPersister persister ) { boolean isDirty = false; if ( entry.getStatus() != Status.DELETED ) { if ( callbackHandler.preUpdate( entity ) ) { isDirty = copyState( entity, persister.getPropertyTypes(), values, session.getFactory() ); } } return super.invokeInterceptor( session, entity, entry, values, persister ) || isDirty; }
@Override protected boolean invokeInterceptor( SessionImplementor session, Object entity, EntityEntry entry, Object[] values, EntityPersister persister ) { boolean isDirty = false; if ( entry.getStatus() != Status.DELETED ) { if ( callbackHandler.preUpdate( entity ) ) { isDirty = copyState( entity, persister.getPropertyTypes(), values, session.getFactory() ); } } return super.invokeInterceptor( session, entity, entry, values, persister ) || isDirty; }
protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event) { // this implementation is supposed to tolerate incorrect unsaved-value // mappings, for the purpose of backward-compatibility EntityEntry entry = event.getSession().getPersistenceContext().getEntry( event.getEntity() ); if ( entry!=null && entry.getStatus() != Status.DELETED ) { return entityIsPersistent(event); } else { return entityIsTransient(event); } }
protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event) { // this implementation is supposed to tolerate incorrect unsaved-value // mappings, for the purpose of backward-compatibility EntityEntry entry = event.getSession().getPersistenceContext().getEntry( event.getEntity() ); if ( entry!=null && entry.getStatus() != Status.DELETED ) { return entityIsPersistent(event); } else { return entityIsTransient(event); } }
public LockMode getCurrentLockMode(Object object) throws HibernateException { if ( object == null ) throw new NullPointerException( "null object passed to getCurrentLockMode()" ); if ( object instanceof HibernateProxy ) { object = ( (HibernateProxy) object ).getHibernateLazyInitializer().getImplementation(this); if ( object == null ) return LockMode.NONE; } EntityEntry e = persistenceContext.getEntry(object); if ( e == null ) throw new TransientObjectException( "Given object not associated with the session" ); if ( e.getStatus() != Status.MANAGED ) throw new ObjectDeletedException( "The given object was deleted", e.getId(), e.getPersister().getEntityName() ); return e.getLockMode(); }
/** * Handle the given save event. * * @param event The save event to be handled. * @throws HibernateException */ protected Serializable entityIsTransient(SaveOrUpdateEvent event) throws HibernateException { log.trace("saving transient instance"); final EventSource source = event.getSession(); EntityEntry entityEntry = event.getEntry(); if ( entityEntry != null ) { if ( entityEntry.getStatus() == Status.DELETED ) { source.forceFlush(entityEntry); } else { throw new AssertionFailure("entity was persistent"); } } Serializable id = saveWithGeneratedOrRequestedId(event); source.getPersistenceContext().reassociateProxy( event.getObject(), id ); return id; }
/** * Handle the given save event. * * @param event The save event to be handled. * @throws HibernateException */ protected Serializable entityIsTransient(SaveOrUpdateEvent event) throws HibernateException { log.trace("saving transient instance"); final SessionImplementor source = event.getSession(); EntityEntry entityEntry = event.getEntry(); if ( entityEntry != null ) { if ( entityEntry.getStatus() == Status.DELETED ) { source.forceFlush(entityEntry); } else { throw new AssertionFailure("entity was persistent"); } } Serializable id = saveWithGeneratedOrRequestedId(event); source.getPersistenceContext().reassociateProxy( event.getObject(), id ); return id; }
/** * Performs all necessary checking to determine if an entity needs an SQL update * to synchronize its state to the database. Modifies the event by side-effect! * Note: this method is quite slow, avoid calling if possible! */ protected final boolean isUpdateNecessary(FlushEntityEvent event) throws HibernateException { EntityPersister persister = event.getEntityEntry().getPersister(); Status status = event.getEntityEntry().getStatus(); if ( !event.isDirtyCheckPossible() ) { return true; } else { int[] dirtyProperties = event.getDirtyProperties(); if ( dirtyProperties!=null && dirtyProperties.length!=0 ) { return true; //TODO: suck into event class } else { return hasDirtyCollections( event, persister, status ); } } }
public Void doInHibernate(Session session) throws HibernateException, SQLException { if (canModifyReadWriteState(session, target)) { SessionImplementor sessionImpl = (SessionImplementor) session; EntityEntry ee = sessionImpl.getPersistenceContext().getEntry(target); if (ee != null && ee.getStatus() == Status.READ_ONLY) { Object actualTarget = target; if (target instanceof HibernateProxy) { actualTarget = ((HibernateProxy)target).getHibernateLazyInitializer().getImplementation(); } session.setReadOnly(actualTarget, false); session.setFlushMode(FlushMode.AUTO); incrementVersion(target); } } return null; } });
protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event) { // this implementation is supposed to tolerate incorrect unsaved-value // mappings, for the purpose of backward-compatibility EntityEntry entry = event.getSession().getPersistenceContext().getEntry( event.getEntity() ); if ( entry!=null ) { if ( entry.getStatus()==Status.DELETED ) { throw new ObjectDeletedException( "deleted instance passed to update()", null, event.getEntityName() ); } else { return entityIsPersistent(event); } } else { entityIsDetached(event); return null; } }
private boolean isUpdateNecessary(final FlushEntityEvent event, final boolean mightBeDirty) { final Status status = event.getEntityEntry().getStatus(); if ( mightBeDirty || status==Status.DELETED ) { // compare to cached state (ignoring collections unless versioned) dirtyCheck(event); if ( isUpdateNecessary(event) ) { return true; } else { FieldInterceptionHelper.clearDirty( event.getEntity() ); return false; } } else { return hasDirtyCollections( event, event.getEntityEntry().getPersister(), status ); } }
protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event) { // this implementation is supposed to tolerate incorrect unsaved-value // mappings, for the purpose of backward-compatibility EntityEntry entry = event.getSession().getPersistenceContext().getEntry( event.getEntity() ); if ( entry!=null ) { if ( entry.getStatus()==Status.DELETED ) { throw new ObjectDeletedException( "deleted instance passed to update()", null, event.getEntityName() ); } else { return entityIsPersistent(event); } } else { entityIsDetached(event); return null; } }
public void replaceDelayedEntityIdentityInsertKeys(EntityKey oldKey, Serializable generatedId) { Object entity = entitiesByKey.remove( oldKey ); EntityEntry oldEntry = ( EntityEntry ) entityEntries.remove( entity ); EntityKey newKey = new EntityKey( generatedId, oldEntry.getPersister(), getSession().getEntityMode() ); addEntity( newKey, entity ); addEntry( entity, oldEntry.getStatus(), oldEntry.getLoadedState(), oldEntry.getRowId(), generatedId, oldEntry.getVersion(), oldEntry.getLockMode(), oldEntry.isExistsInDatabase(), oldEntry.getPersister(), oldEntry.isBeingReplicated(), oldEntry.isLoadedWithLazyPropertiesUnfetched() ); }