Package org.hibernate.engine.spi

Examples of org.hibernate.engine.spi.PersistenceContext


      return null;
    }
    else {
      CollectionPersister persister = session.getFactory().getCollectionPersister( collectionType.getRole() );

      final PersistenceContext persistenceContext = session.getPersistenceContext();
      //TODO: move into collection type, so we can use polymorphism!
      if ( collectionType.hasHolder() ) {

        if ( collection == CollectionType.UNFETCHED_COLLECTION ) {
          return null;
        }

        PersistentCollection ah = persistenceContext.getCollectionHolder( collection );
        if ( ah == null ) {
          ah = collectionType.wrap( session, collection );
          persistenceContext.addNewCollection( persister, ah );
          persistenceContext.addCollectionHolder( ah );
        }
        return null;
      }
      else {

        PersistentCollection persistentCollection = collectionType.wrap( session, collection );
        persistenceContext.addNewCollection( persister, persistentCollection );

        if ( LOG.isTraceEnabled() ) {
          LOG.tracev( "Wrapped collection in role: {0}", collectionType.getRole() );
        }
View Full Code Here


    CollectionCacheEntry cacheEntry = (CollectionCacheEntry) persister.getCacheEntryStructure().destructure(
        ce,
        factory
    );

    final PersistenceContext persistenceContext = source.getPersistenceContext();
    cacheEntry.assemble( collection, persister, persistenceContext.getCollectionOwner( id, persister ) );
    persistenceContext.getCollectionEntry( collection ).postInitialize( collection );
    // addInitializedCollection(collection, persister, id);
    return true;
  }
View Full Code Here

      processDereferencedCollection( coll, session );
    }
  }

  private static void processDereferencedCollection(PersistentCollection coll, SessionImplementor session) {
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final CollectionEntry entry = persistenceContext.getCollectionEntry( coll );
    final CollectionPersister loadedPersister = entry.getLoadedPersister();

    if ( loadedPersister != null && LOG.isDebugEnabled() ) {
      LOG.debugf(
          "Collection dereferenced: %s",
          MessageHelper.collectionInfoString( loadedPersister,
              coll, entry.getLoadedKey(), session
          )
      );
    }

    // do a check
    final boolean hasOrphanDelete = loadedPersister != null && loadedPersister.hasOrphanDelete();
    if ( hasOrphanDelete ) {
      Serializable ownerId = loadedPersister.getOwnerEntityPersister().getIdentifier( coll.getOwner(), session );
      if ( ownerId == null ) {
        // the owning entity may have been deleted and its identifier unset due to
        // identifier-rollback; in which case, try to look up its identifier from
        // the persistence context
        if ( session.getFactory().getSettings().isIdentifierRollbackEnabled() ) {
          final EntityEntry ownerEntry = persistenceContext.getEntry( coll.getOwner() );
          if ( ownerEntry != null ) {
            ownerId = ownerEntry.getId();
          }
        }
        if ( ownerId == null ) {
          throw new AssertionFailure( "Unable to determine collection owner identifier for orphan-delete processing" );
        }
      }
      final EntityKey key = session.generateEntityKey( ownerId, loadedPersister.getOwnerEntityPersister() );
      final Object owner = persistenceContext.getEntity( key );
      if ( owner == null ) {
        throw new AssertionFailure(
            "collection owner not associated with session: " +
            loadedPersister.getRole()
        );
      }
      final EntityEntry e = persistenceContext.getEntry( owner );
      //only collections belonging to deleted entities are allowed to be dereferenced in the case of orphan delete
      if ( e != null && e.getStatus() != Status.DELETED && e.getStatus() != Status.GONE ) {
        throw new HibernateException(
            "A collection with cascade=\"all-delete-orphan\" was no longer referenced by the owning entity instance: " +
            loadedPersister.getRole()
View Full Code Here

  }

  private static void processNeverReferencedCollection(PersistentCollection coll, SessionImplementor session)
      throws HibernateException {
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final CollectionEntry entry = persistenceContext.getCollectionEntry( coll );

    if ( LOG.isDebugEnabled() ) {
      LOG.debugf(
          "Found collection with unloaded owner: %s",
          MessageHelper.collectionInfoString(
View Full Code Here

    if ( !isSubselectLoadable() ) {
      return null;
    }

    final PersistenceContext persistenceContext = session.getPersistenceContext();

    SubselectFetch subselect = persistenceContext.getBatchFetchQueue()
        .getSubselect( session.generateEntityKey( key, getOwnerEntityPersister() ) );

    if ( subselect == null ) {
      return null;
    }
    else {

      // Take care of any entities that might have
      // been evicted!
      Iterator iter = subselect.getResult().iterator();
      while ( iter.hasNext() ) {
        if ( !persistenceContext.containsEntity( (EntityKey) iter.next() ) ) {
          iter.remove();
        }
      }

      // Run a subquery loader
View Full Code Here

   */
  public void onDelete(DeleteEvent event, Set transientEntities) throws HibernateException {

    final EventSource source = event.getSession();

    final PersistenceContext persistenceContext = source.getPersistenceContext();
    Object entity = persistenceContext.unproxyAndReassociate( event.getObject() );

    EntityEntry entityEntry = persistenceContext.getEntry( entity );
    final EntityPersister persister;
    final Serializable id;
    final Object version;

    if ( entityEntry == null ) {
      LOG.trace( "Entity was not persistent in delete processing" );

      persister = source.getEntityPersister( event.getEntityName(), entity );

      if ( ForeignKeys.isTransient( persister.getEntityName(), entity, null, source ) ) {
        deleteTransientEntity( source, entity, event.isCascadeDeleteEnabled(), persister, transientEntities );
        // EARLY EXIT!!!
        return;
      }
      performDetachedEntityDeletionCheck( event );

      id = persister.getIdentifier( entity, source );

      if ( id == null ) {
        throw new TransientObjectException(
            "the detached instance passed to delete() had a null identifier"
        );
      }

      final EntityKey key = source.generateEntityKey( id, persister );

      persistenceContext.checkUniqueness( key, entity );

      new OnUpdateVisitor( source, id, entity ).process( entity, persister );

      version = persister.getVersion( entity );

      entityEntry = persistenceContext.addEntity(
          entity,
          (persister.isMutable() ? Status.MANAGED : Status.READ_ONLY),
          persister.getPropertyValues( entity ),
          key,
          version,
View Full Code Here

          "Deleting {0}",
          MessageHelper.infoString( persister, entityEntry.getId(), session.getFactory() )
      );
    }

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final Type[] propTypes = persister.getPropertyTypes();
    final Object version = entityEntry.getVersion();

    final Object[] currentState;
    if ( entityEntry.getLoadedState() == null ) {
      //ie. the entity came in from update()
      currentState = persister.getPropertyValues( entity );
    }
    else {
      currentState = entityEntry.getLoadedState();
    }

    final Object[] deletedState = createDeletedState( persister, currentState, session );
    entityEntry.setDeletedState( deletedState );

    session.getInterceptor().onDelete(
        entity,
        entityEntry.getId(),
        deletedState,
        persister.getPropertyNames(),
        propTypes
    );

    // before any callbacks, etc, so subdeletions see that this deletion happened first
    persistenceContext.setEntryStatus( entityEntry, Status.DELETED );
    final EntityKey key = session.generateEntityKey( entityEntry.getId(), persister );

    cascadeBeforeDelete( session, persister, entity, entityEntry, transientEntities );

    new ForeignKeys.Nullifier( entity, true, false, session )
        .nullifyTransientReferences( entityEntry.getDeletedState(), propTypes );
    new Nullability( session ).checkNullability( entityEntry.getDeletedState(), persister, true );
    persistenceContext.getNullifiableEntityKeys().add( key );

    if ( isOrphanRemovalBeforeUpdates ) {
      // TODO: The removeOrphan concept is a temporary "hack" for HHH-6484.  This should be removed once action/task
      // ordering is improved.
      session.getActionQueue().addAction(
View Full Code Here

    // this class has no proxies (so do a shortcut)
    if ( !persister.hasProxy() ) {
      return load( event, persister, keyToLoad, options );
    }

    final PersistenceContext persistenceContext = event.getSession().getPersistenceContext();

    // look for a proxy
    Object proxy = persistenceContext.getProxy( keyToLoad );
    if ( proxy != null ) {
      return returnNarrowedProxy( event, persister, keyToLoad, options, persistenceContext, proxy );
    }

    if ( options.isAllowProxyCreation() ) {
View Full Code Here

        entry.areLazyPropertiesUnfetched(),
        entry.getVersion(),
        session
    );

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final Object[] values;
    final Object version;
    final boolean isReadOnly;
    if ( entry.isReferenceEntry() ) {
      values = null;
      version = null;
      isReadOnly = true;
    }
    else {
      final Type[] types = subclassPersister.getPropertyTypes();
      // initializes the entity by (desired) side-effect
      values = ( (StandardCacheEntryImpl) entry ).assemble(
          entity, entityId, subclassPersister, session.getInterceptor(), session
      );
      if ( ( (StandardCacheEntryImpl) entry ).isDeepCopyNeeded() ) {
        TypeHelper.deepCopy(
            values,
            types,
            subclassPersister.getPropertyUpdateability(),
            values,
            session
        );
      }
      version = Versioning.getVersion( values, subclassPersister );
      LOG.tracef( "Cached Version : %s", version );

      final Object proxy = persistenceContext.getProxy( entityKey );
      if ( proxy != null ) {
        // there is already a proxy for this impl
        // only set the status to read-only if the proxy is read-only
        isReadOnly = ( (HibernateProxy) proxy ).getHibernateLazyInitializer().isReadOnly();
      }
      else {
        isReadOnly = session.isDefaultReadOnly();
      }
    }

    persistenceContext.addEntry(
        entity,
        ( isReadOnly ? Status.READ_ONLY : Status.MANAGED ),
        values,
        null,
        entityId,
        version,
        LockMode.NONE,
        true,
        subclassPersister,
        false,
        entry.areLazyPropertiesUnfetched()
    );
    subclassPersister.afterInitialize( entity, entry.areLazyPropertiesUnfetched(), session );
    persistenceContext.initializeNonLazyCollections();

    //PostLoad is needed for EJB3
    PostLoadEvent postLoadEvent = new PostLoadEvent( session )
        .setEntity( entity )
        .setId( entityId )
View Full Code Here

    );

    Object version = Versioning.getVersion( values, subclassPersister );
    LOG.tracev( "Cached Version: {0}", version );

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    boolean isReadOnly = session.isDefaultReadOnly();
    if ( persister.isMutable() ) {
      Object proxy = persistenceContext.getProxy( entityKey );
      if ( proxy != null ) {
        // there is already a proxy for this impl
        // only set the status to read-only if the proxy is read-only
        isReadOnly = ( (HibernateProxy) proxy ).getHibernateLazyInitializer().isReadOnly();
      }
    }
    else {
      isReadOnly = true;
    }
    persistenceContext.addEntry(
        result,
        ( isReadOnly ? Status.READ_ONLY : Status.MANAGED ),
        values,
        null,
        id,
        version,
        LockMode.NONE,
        true,
        subclassPersister,
        false,
        entry.areLazyPropertiesUnfetched()
    );
    subclassPersister.afterInitialize( result, entry.areLazyPropertiesUnfetched(), session );
    persistenceContext.initializeNonLazyCollections();
    // upgrade the lock if necessary:
    //lock(result, lockMode);

    //PostLoad is needed for EJB3
    //TODO: reuse the PostLoadEvent...
View Full Code Here

TOP

Related Classes of org.hibernate.engine.spi.PersistenceContext

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.