Package org.hibernate.engine.spi

Examples of org.hibernate.engine.spi.CollectionEntry


    }
  }

  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()
        );
      }
    }

    // do the work
    entry.setCurrentPersister( null );
    entry.setCurrentKey( null );
    prepareCollectionForUpdate( coll, entry, session.getFactory() );

  }
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(
              entry.getLoadedPersister(),
              coll,
              entry.getLoadedKey(),
              session
          )
      );
    }

    entry.setCurrentPersister( entry.getLoadedPersister() );
    entry.setCurrentKey( entry.getLoadedKey() );

    prepareCollectionForUpdate( coll, entry, session.getFactory() );

  }
View Full Code Here

      PersistentCollection collection,
      CollectionType type,
      Object entity,
      SessionImplementor session) {
    collection.setOwner( entity );
    final CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( collection );

    if ( ce == null ) {
      // refer to comment in StatefulPersistenceContext.addCollection()
      throw new HibernateException(
          "Found two representations of same collection: " +
          type.getRole()
      );
    }

    // The CollectionEntry.isReached() stuff is just to detect any silly users
    // who set up circular or shared references between/to collections.
    if ( ce.isReached() ) {
      // We've been here before
      throw new HibernateException(
          "Found shared references to a collection: " + type.getRole()
      );
    }
    ce.setReached( true );

    final SessionFactoryImplementor factory = session.getFactory();
    final CollectionPersister persister = factory.getCollectionPersister( type.getRole() );
    ce.setCurrentPersister( persister );
    //TODO: better to pass the id in as an argument?
    ce.setCurrentKey( type.getKeyOfOwner( entity, session ) );

    if ( LOG.isDebugEnabled() ) {
      if ( collection.wasInitialized() ) {
        LOG.debugf(
            "Collection found: %s, was: %s (initialized)",
            MessageHelper.collectionInfoString( persister, collection, ce.getCurrentKey(), session ),
            MessageHelper.collectionInfoString( ce.getLoadedPersister(), collection, ce.getLoadedKey(), session )
        );
      }
      else {
        LOG.debugf(
            "Collection found: %s, was: %s (uninitialized)",
            MessageHelper.collectionInfoString( persister, collection, ce.getCurrentKey(), session ),
            MessageHelper.collectionInfoString( ce.getLoadedPersister(), collection, ce.getLoadedKey(), session )
        );
      }
    }

    prepareCollectionForUpdate( collection, ce, factory );
View Full Code Here

    PersistentCollection collection = (PersistentCollection) pc;
    if ( collection.unsetSession( getSession() ) ) evictCollection(collection);
  }

  private void evictCollection(PersistentCollection collection) {
    CollectionEntry ce = (CollectionEntry) getSession().getPersistenceContext().getCollectionEntries().remove(collection);
    if ( LOG.isDebugEnabled() ) {
      LOG.debugf( "Evicting collection: %s",
          MessageHelper.collectionInfoString( ce.getLoadedPersister(),
              collection,
              ce.getLoadedKey(),
              getSession() ) );
    }
    if (ce.getLoadedPersister() != null && ce.getLoadedPersister().getBatchSize() > 1) {
      getSession().getPersistenceContext().getBatchFetchQueue().removeBatchLoadableCollection(ce);
    }
    if ( ce.getLoadedPersister() != null && ce.getLoadedKey() != null ) {
      //TODO: is this 100% correct?
      getSession().getPersistenceContext().getCollectionsByKey().remove(
          new CollectionKey( ce.getLoadedPersister(), ce.getLoadedKey() )
      );
    }
  }
View Full Code Here

   */
  public void onInitializeCollection(InitializeCollectionEvent event) throws HibernateException {
    PersistentCollection collection = event.getCollection();
    SessionImplementor source = event.getSession();

    CollectionEntry ce = source.getPersistenceContext().getCollectionEntry( collection );
    if ( ce == null ) {
      throw new HibernateException( "collection was evicted" );
    }
    if ( !collection.wasInitialized() ) {
      final boolean traceEnabled = LOG.isTraceEnabled();
      if ( traceEnabled ) {
        LOG.tracev(
            "Initializing collection {0}",
            MessageHelper.collectionInfoString(
                ce.getLoadedPersister(),
                collection,
                ce.getLoadedKey(),
                source
            )
        );
        LOG.trace( "Checking second-level cache" );
      }

      final boolean foundInCache = initializeCollectionFromCache(
          ce.getLoadedKey(),
          ce.getLoadedPersister(),
          collection,
          source
      );

      if ( foundInCache ) {
        if ( traceEnabled ) {
          LOG.trace( "Collection initialized from cache" );
        }
      }
      else {
        if ( traceEnabled ) {
          LOG.trace( "Collection not cached" );
        }
        ce.getLoadedPersister().initialize( ce.getLoadedKey(), source );
        if ( traceEnabled ) {
          LOG.trace( "Collection initialized" );
        }

        if ( source.getFactory().getStatistics().isStatisticsEnabled() ) {
          source.getFactory().getStatisticsImplementor().fetchCollection(
              ce.getLoadedPersister().getRole()
          );
        }
      }
    }
  }
View Full Code Here

      else {
        final boolean isExtraLazy = withTemporarySessionIfNeeded(
            new LazyInitializationWork<Boolean>() {
              @Override
              public Boolean doWork() {
                final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );

                if ( entry != null ) {
                  final CollectionPersister persister = entry.getLoadedPersister();
                  if ( persister.isExtraLazy() ) {
                    if ( hasQueuedOperations() ) {
                      session.flush();
                    }
                    cachedSize = persister.getSize( entry.getLoadedKey(), session );
                    return true;
                  }
                  else {
                    read();
                  }
View Full Code Here

    if ( !initialized ) {
      final Boolean extraLazyExistenceCheck = withTemporarySessionIfNeeded(
          new LazyInitializationWork<Boolean>() {
            @Override
            public Boolean doWork() {
              final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
              final CollectionPersister persister = entry.getLoadedPersister();
              if ( persister.isExtraLazy() ) {
                if ( hasQueuedOperations() ) {
                  session.flush();
                }
                return persister.indexExists( entry.getLoadedKey(), index, session );
              }
              else {
                read();
              }
              return null;
View Full Code Here

    if ( !initialized ) {
      final Boolean extraLazyExistenceCheck = withTemporarySessionIfNeeded(
          new LazyInitializationWork<Boolean>() {
            @Override
            public Boolean doWork() {
              final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
              final CollectionPersister persister = entry.getLoadedPersister();
              if ( persister.isExtraLazy() ) {
                if ( hasQueuedOperations() ) {
                  session.flush();
                }
                return persister.elementExists( entry.getLoadedKey(), element, session );
              }
              else {
                read();
              }
              return null;
View Full Code Here

        private boolean isExtraLazy;
        private Object element;

        @Override
        public Object doWork() {
          final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
          final CollectionPersister persister = entry.getLoadedPersister();
          isExtraLazy = persister.isExtraLazy();
          if ( isExtraLazy ) {
            if ( hasQueuedOperations() ) {
              session.flush();
            }
            element = persister.getElementByIndex( entry.getLoadedKey(), index, session, owner );
          }
          else {
            read();
          }
          return null;
View Full Code Here

  /**
   * Is this the "inverse" end of a bidirectional association?
   */
  @SuppressWarnings({"JavaDoc"})
  private boolean isInverseCollection() {
    final CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this );
    return ce != null && ce.getLoadedPersister().isInverse();
  }
View Full Code Here

TOP

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

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.