public void postUpdate(Object obj, Object[] updatedState, Object nextVersion) { this.loadedState = updatedState; setLockMode(LockMode.WRITE); if ( getPersister().isVersioned() ) { this.version = nextVersion; getPersister().setPropertyValue( obj, getPersister().getVersionProperty(), nextVersion, entityMode ); } }
/** * After actually updating the database, update the snapshot information, * and escalate the lock mode */ public void postUpdate(Object entity, Object[] updatedState, Object nextVersion) { this.loadedState = updatedState; setLockMode(LockMode.WRITE); if ( getPersister().isVersioned() ) { this.version = nextVersion; getPersister().setPropertyValue( entity, getPersister().getVersionProperty(), nextVersion, entityMode ); } FieldInterceptionHelper.clearDirty( entity ); }
/** * 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() ); } } }
public void forceFlush(EntityEntry e) throws HibernateException { if ( log.isDebugEnabled() ) { log.debug( "flushing to force deletion of re-saved object: " + MessageHelper.infoString( e.getPersister(), e.getId(), getFactory() ) ); } if ( persistenceContext.getCascadeLevel() > 0 ) { throw new ObjectDeletedException( "deleted object would be re-saved by cascade (remove deleted object from associations)", e.getId(), e.getPersister().getEntityName() ); } flush(); }
private static boolean useMinimalPuts(SessionImplementor session, EntityEntry entityEntry) { return ( session.getFactory().getSettings().isMinimalPutsEnabled() && session.getCacheMode()!=CacheMode.REFRESH ) || ( entityEntry.getPersister().hasLazyProperties() && entityEntry.isLoadedWithLazyPropertiesUnfetched() && entityEntry.getPersister().isLazyPropertiesCacheable() ); }
public void forceFlush(EntityEntry entityEntry) throws HibernateException { errorIfClosed(); if ( log.isDebugEnabled() ) { log.debug( "flushing to force deletion of re-saved object: " + MessageHelper.infoString( entityEntry.getPersister(), entityEntry.getId(), getFactory() ) ); } if ( persistenceContext.getCascadeLevel() > 0 ) { throw new ObjectDeletedException( "deleted object would be re-saved by cascade (remove deleted object from associations)", entityEntry.getId(), entityEntry.getPersister().getEntityName() ); } flush(); }
public void forceLocked(Object entity, Object nextVersion) { version = nextVersion; loadedState[ persister.getVersionProperty() ] = version; setLockMode( LockMode.FORCE ); persister.setPropertyValue( entity, getPersister().getVersionProperty(), nextVersion, entityMode ); }
public boolean isNullifiable(boolean earlyInsert, SessionImplementor session) { return getStatus() == Status.SAVING || ( earlyInsert ? !isExistsInDatabase() : session.getPersistenceContext().getNullifiableEntityKeys() .contains( new EntityKey( getId(), getPersister(), entityMode ) ) ); }
public void setReadOnly(boolean readOnly, Object entity) { if (status!=Status.MANAGED && status!=Status.READ_ONLY) { throw new HibernateException("instance was not in a valid state"); } if (readOnly) { setStatus(Status.READ_ONLY); loadedState = null; } else { setStatus(Status.MANAGED); loadedState = getPersister().getPropertyValues(entity, entityMode); } }
public boolean isNullifiable(boolean earlyInsert, SessionImplementor session) { return getStatus() == Status.SAVING || ( earlyInsert ? !isExistsInDatabase() : session.getPersistenceContext().getNullifiableEntityKeys() .contains( new EntityKey( getId(), getPersister(), entityMode ) ) ); }
public boolean requiresDirtyCheck(Object entity) { boolean isMutableInstance = status != Status.READ_ONLY && persister.isMutable(); return isMutableInstance && ( getPersister().hasMutableProperties() || !FieldInterceptionHelper.isInstrumented( entity ) || FieldInterceptionHelper.extractFieldInterceptor( entity).isDirty() ); }
public String bestGuessEntityName(Object object) { if (object instanceof HibernateProxy) { object = ( (HibernateProxy) object ).getHibernateLazyInitializer().getImplementation(); } EntityEntry entry = persistenceContext.getEntry(object); if (entry==null) { return guessEntityName(object); } else { return entry.getPersister().getEntityName(); } }
/** * Return the existing proxy associated with the given <tt>EntityKey</tt>, or the * argument (the entity associated with the key) if no proxy exists. * (slower than the form above) */ public Object proxyFor(Object impl) throws HibernateException { EntityEntry e = getEntry(impl); EntityPersister p = e.getPersister(); return proxyFor( p, new EntityKey( e.getId(), p, session.getEntityMode() ), impl ); }
/** * Return the existing proxy associated with the given <tt>EntityKey</tt>, or the * argument (the entity associated with the key) if no proxy exists. * (slower than the form above) */ public Object proxyFor(Object impl) throws HibernateException { EntityEntry e = getEntry(impl); EntityPersister p = e.getPersister(); return proxyFor( p, new EntityKey( e.getId(), p, session.getEntityMode() ), impl ); }
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(); }
public String getEntityName(Object object) { if (object instanceof HibernateProxy) { if ( !persistenceContext.containsProxy( object ) ) { throw new TransientObjectException("proxy was not associated with the session"); } object = ( (HibernateProxy) object ).getHibernateLazyInitializer().getImplementation(); } EntityEntry entry = persistenceContext.getEntry(object); if (entry==null) throwTransientObjectException(object); return entry.getPersister().getEntityName(); }
/** * 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 String bestGuessEntityName(Object object) { if (object instanceof HibernateProxy) { LazyInitializer initializer = ( ( HibernateProxy ) object ).getHibernateLazyInitializer(); // it is possible for this method to be called during flush processing, // so make certain that we do not accidently initialize an uninitialized proxy if ( initializer.isUninitialized() ) { return initializer.getEntityName(); } object = initializer.getImplementation(); } EntityEntry entry = persistenceContext.getEntry(object); if (entry==null) { return guessEntityName(object); } else { return entry.getPersister().getEntityName(); } }
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 ); } }
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() ); }