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() ); }
if ( requestedLockMode.greaterThan( entry.getLockMode() ) ) { if ( entry.getStatus() != Status.MANAGED ) { throw new ObjectDeletedException( "attempted to lock a deleted instance", entry.getId(), entry.getPersister().getEntityName() ); final EntityPersister persister = entry.getPersister(); MessageHelper.infoString( persister, entry.getId(), source.getFactory() ) + " in mode: " + requestedLockMode if ( persister.hasCache() ) { ck = new CacheKey( entry.getId(), persister.getIdentifierType(), persister.getRootEntityName(), source.getFactory() ); lock = persister.getCache().lock( ck, entry.getVersion() ); persister.lock( entry.getId(), entry.getVersion(), object, requestedLockMode, source ); entry.setLockMode(requestedLockMode);
final EntityPersister persister, final boolean disableVersionIncrement) { EntityEntry e = new EntityEntry( status, loadedState,
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); } }
final EventSource session = event.getSession(); final Object entity = event.getEntity(); final Status status = entry.getStatus(); final EntityMode entityMode = session.getEntityMode(); final EntityPersister persister = entry.getPersister(); final Object[] values = event.getPropertyValues(); log.trace( "Updating deleted entity: " + MessageHelper.infoString( persister, entry.getId(), session.getFactory() ) ); log.trace( "Updating entity: " + MessageHelper.infoString( persister, entry.getId(), session.getFactory() ) ); if ( !entry.isBeingReplicated() ) { entry.getId(), values, dirtyProperties, event.hasDirtyCollection(), entry.getLoadedState(), entry.getVersion(), nextVersion, entity, entry.getRowId(), persister,
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 Object[] getValues( Object entity, EntityEntry entry, EntityMode entityMode, boolean mightBeDirty, SessionImplementor session ) { final Object[] loadedState = entry.getLoadedState(); final Status status = entry.getStatus(); final EntityPersister persister = entry.getPersister(); final Object[] values; if ( status == Status.DELETED ) { //grab its state saved at deletion values = entry.getDeletedState(); } else if ( !mightBeDirty && loadedState!=null ) { values = loadedState; } else { checkId( entity, persister, entry.getId(), entityMode ); // grab its current state values = persister.getPropertyValues( entity, entityMode ); checkNaturalId( persister, entry.getId(), values, loadedState, entityMode, session ); } return values; }
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(); }
private boolean invokeInterceptor(FlushEntityEvent event) { SessionImplementor session = event.getSession(); EntityEntry entry = event.getEntityEntry(); EntityPersister persister = entry.getPersister(); Object entity = event.getEntity(); final boolean intercepted = session.getInterceptor().onFlushDirty( entity, entry.getId(), values, entry.getLoadedState(), persister.getPropertyNames(), persister.getPropertyTypes() dirtyProperties = persister.findDirty( values, entry.getLoadedState(), entity, session );
/** * 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() ); } } }
if ( entityEntry.getStatus() == Status.DELETED ) { throw new AssertionFailure("entity was deleted"); savedId = entityEntry.getId(); final boolean isEqual = !entityEntry.getPersister().getIdentifierType() .isEqual( requestedId, entityEntry.getId(), event.getSession().getEntityMode(), factory ); MessageHelper.infoString( entityEntry.getPersister(), requestedId, factory ) ); log.trace( "object already associated with session: " + MessageHelper.infoString( entityEntry.getPersister(), savedId, factory ) );
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(); }
"deleting " + MessageHelper.infoString( persister, entityEntry.getId(), session.getFactory() ) ); final Object version = entityEntry.getVersion(); if ( entityEntry.getLoadedState() == null ) { //ie. the entity came in from update() currentState = persister.getPropertyValues( entity, session.getEntityMode() ); currentState = entityEntry.getLoadedState(); session ); entityEntry.setDeletedState(deletedState); entityEntry.getId(), deletedState, persister.getPropertyNames(), EntityKey key = new EntityKey( entityEntry.getId(), persister, session.getEntityMode() ); entityEntry.setDeletedState(null); persistenceContext.setNullifiableEntityKeys(oldNullifiables); log.debug("deletion vetoed by onDelete()"); entityEntry.setDeletedState(null); persistenceContext.setNullifiableEntityKeys(oldNullifiables); throw ce; .nullifyTransientReferences( entityEntry.getDeletedState(), propTypes );
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();
EntityPersister persister = entry.getPersister(); if ( persister.isVersioned() ) { if ( entry.isBeingReplicated() ) { return Versioning.getVersion(values, persister); int[] dirtyProperties = event.getDirtyProperties(); final boolean isVersionIncrementRequired = entry.getStatus()!=Status.DELETED && ( dirtyProperties==null || Versioning.isVersionIncrementRequired( Versioning.increment( entry.getVersion(), persister.getVersionType() ) : entry.getVersion(); //use the current version
log.trace( "refreshing " + MessageHelper.infoString( e.getPersister(), e.getId(), source.getFactory() ) ); if ( !e.isExistsInDatabase() ) { throw new HibernateException( "this instance does not yet exist as a row in the database" ); persister = e.getPersister(); id = e.getId();
protected final Serializable getId() { if ( id instanceof DelayedPostInsertIdentifier ) { return session.getPersistenceContext().getEntry( instance ).getId(); } return id; }
version = persister.getVersion( entity, source.getEntityMode() ); 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();
throw new AssertionFailure( "possible non-threadsafe access to the session" ); EntityPersister persister = entityEntry.getPersister(); Serializable id = entityEntry.getId(); Object[] hydratedState = entityEntry.getLoadedState(); hydratedState, persister, entityEntry.isLoadedWithLazyPropertiesUnfetched(), version, session, entityEntry.isLoadedWithLazyPropertiesUnfetched(), session );