/** * entity id accessor * * @return The entity id */ public final Serializable getId() { if ( id instanceof DelayedPostInsertIdentifier ) { final EntityEntry entry = session.getPersistenceContext().getEntry( instance ); final Serializable eeId = entry == null ? null : entry.getId(); return eeId instanceof DelayedPostInsertIdentifier ? null : eeId; } return id; }
protected static Serializable getOwnerIdOrNull( Object owner, EventSource source ) { EntityEntry ownerEntry = source.getPersistenceContext().getEntry( owner ); return ( ownerEntry == null ? null : ownerEntry.getId() ); }
private void handlePostUpdate(Object entity, EventSource source) { EntityEntry entry = source.getPersistenceContext().getEntry( entity ); // mimic the preUpdate filter if ( Status.DELETED != entry.getStatus()) { callbackRegistry.postUpdate(entity); } }
protected final Serializable getKey() { Serializable finalKey = key; if ( key instanceof DelayedPostInsertIdentifier ) { // need to look it up from the persistence-context finalKey = session.getPersistenceContext().getEntry( collection.getOwner() ).getId(); if ( finalKey == key ) { // we may be screwed here since the collection action is about to execute // and we do not know the final owner key value } } return finalKey; }
private boolean existsInDatabase(Object entity, EventSource source, EntityPersister persister) { EntityEntry entry = source.getPersistenceContext().getEntry( entity ); if ( entry == null ) { Serializable id = persister.getIdentifier( entity, source ); if ( id != null ) { final EntityKey key = source.generateEntityKey( id, persister ); final Object managedEntity = source.getPersistenceContext().getEntity( key ); entry = source.getPersistenceContext().getEntry( managedEntity ); } } return entry != null && entry.isExistsInDatabase(); }
/** * Perform the afterInitialize() step. This needs to be done after the collections have been properly initialized * thus a separate step. * * @param entity The entity being loaded * @param session The Session */ public static void afterInitialize( final Object entity, final SharedSessionContractImplementor session) { final PersistenceContext persistenceContext = session.getPersistenceContext(); final EntityEntry entityEntry = persistenceContext.getEntry( entity ); entityEntry.getPersister().afterInitialize( entity, session ); }
private boolean isInManagedState(Object child, EventSource session) { EntityEntry entry = session.getPersistenceContext().getEntry( child ); return entry != null && ( entry.getStatus() == Status.MANAGED || entry.getStatus() == Status.READ_ONLY || entry.getStatus() == Status.SAVING ); }
private String printEntity(Object entity) { if ( session.getPersistenceContext().getEntry( entity ) != null ) { return MessageHelper.infoString( session.getEntityName( entity ), session.getIdentifier( entity ) ); } // Entity was not found in current persistence context. Use Object#toString() method. return "[" + entity + "]"; } }
@Override public void afterDeserialize(SharedSessionContractImplementor session) { super.afterDeserialize( session ); // IMPL NOTE: non-flushed changes code calls this method with session == null... // guard against NullPointerException if ( session != null ) { final EntityEntry entityEntry = session.getPersistenceContext().getEntry( getInstance() ); this.state = entityEntry.getLoadedState(); } }
/** * Perform the second step of 2-phase load. Fully initialize the entity * instance. * <p/> * After processing a JDBC result set, we "resolve" all the associations * between the entities which were instantiated and had their state * "hydrated" into an array * * @param entity The entity being loaded * @param readOnly Is the entity being loaded as read-only * @param session The Session * @param preLoadEvent The (re-used) pre-load event */ public static void initializeEntity( final Object entity, final boolean readOnly, final SharedSessionContractImplementor session, final PreLoadEvent preLoadEvent) { final PersistenceContext persistenceContext = session.getPersistenceContext(); final EntityEntry entityEntry = persistenceContext.getEntry( entity ); if ( entityEntry == null ) { throw new AssertionFailure( "possible non-threadsafe access to the session" ); } doInitializeEntity( entity, entityEntry, readOnly, session, preLoadEvent ); }
protected static String getAffectedOwnerEntityName(CollectionPersister collectionPersister, Object affectedOwner, EventSource source ) { // collectionPersister should not be null, but we don't want to throw // an exception if it is null String entityName = ( collectionPersister == null ? null : collectionPersister.getOwnerEntityPersister().getEntityName() ); if ( affectedOwner != null ) { EntityEntry ee = source.getPersistenceContext().getEntry( affectedOwner ); if ( ee != null && ee.getEntityName() != null) { entityName = ee.getEntityName(); } } return entityName; }
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); } }
@Override public void lock(Serializable id, Object version, Object object, int timeout, SharedSessionContractImplementor session) { if ( !lockable.isVersioned() ) { throw new OptimisticLockException( object, "[" + lockMode + "] not supported for non-versioned entities [" + lockable.getEntityName() + "]" ); } final EntityEntry entry = session.getPersistenceContext().getEntry( object ); // Register the EntityVerifyVersionProcess action to run just prior to transaction commit. ( (EventSource) session ).getActionQueue().registerProcess( new EntityVerifyVersionProcess( object, entry ) ); }
private void checkLockMode(Object entity, LockMode expectedLockMode, Session session) { final LockMode lockMode = ( (SharedSessionContractImplementor) session ).getPersistenceContext().getEntry( entity ).getLockMode(); assertEquals( expectedLockMode, lockMode ); }
@Override public void lock(Serializable id, Object version, Object object, int timeout, SharedSessionContractImplementor session) { if ( !lockable.isVersioned() ) { throw new HibernateException( "[" + lockMode + "] not supported for non-versioned entities [" + lockable.getEntityName() + "]" ); } final EntityEntry entry = session.getPersistenceContext().getEntry( object ); // Register the EntityIncrementVersionProcess action to run just prior to transaction commit. ( (EventSource) session ).getActionQueue().registerProcess( new EntityIncrementVersionProcess( object, entry ) ); }
@Override public void lock(Serializable id, Object version, Object object, int timeout, SharedSessionContractImplementor session) { if ( !lockable.isVersioned() ) { throw new HibernateException( "[" + lockMode + "] not supported for non-versioned entities [" + lockable.getEntityName() + "]" ); } final EntityEntry entry = session.getPersistenceContext().getEntry( object ); final EntityPersister persister = entry.getPersister(); final Object nextVersion = persister.forceVersionIncrement( entry.getId(), entry.getVersion(), session ); entry.forceLocked( object, nextVersion ); }
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 void checkVersion( ResultSet resultSet, ResultSetProcessingContext context, EntityKey entityKey, Object existing) { final LockMode requestedLockMode = context.resolveLockMode( entityReference ); if ( requestedLockMode != LockMode.NONE ) { final LockMode currentLockMode = context.getSession().getPersistenceContext().getEntry( existing ).getLockMode(); final boolean isVersionCheckNeeded = entityReference.getEntityPersister().isVersioned() && currentLockMode.lessThan( requestedLockMode ); // we don't need to worry about existing version being uninitialized because this block isn't called // by a re-entrant load (re-entrant loads *always* have lock mode NONE) if ( isVersionCheckNeeded ) { //we only check the version when *upgrading* lock modes checkVersion( context.getSession(), resultSet, entityReference.getEntityPersister(), entityReferenceAliases.getColumnAliases(), entityKey, existing ); //we need to upgrade the lock mode to the mode requested context.getSession().getPersistenceContext().getEntry( existing ).setLockMode( requestedLockMode ); } } }
@Override public Object resolve(Object value, SharedSessionContractImplementor session, Object owner, Boolean overridingEager) throws HibernateException { Object resolvedValue = super.resolve(value, session, owner, overridingEager); if ( isLogicalOneToOne && value != null && getPropertyName() != null ) { EntityEntry entry = session.getPersistenceContext().getEntry( owner ); if ( entry != null ) { final Loadable ownerPersister = (Loadable) session.getFactory().getMetamodel().entityPersister( entry.getEntityName() ); EntityUniqueKey entityKey = new EntityUniqueKey( ownerPersister.getEntityName(), getPropertyName(), value, this, ownerPersister.getEntityMode(), session.getFactory() ); session.getPersistenceContext().addEntity( entityKey, owner ); } } return resolvedValue; }
protected interface InclusionChecker { boolean includeProperty(int propertyNumber); }