Package org.hibernate.engine.spi

Examples of org.hibernate.engine.spi.PersistenceContext


      final Object entity,
      final SessionImplementor session,
      final PostLoadEvent postLoadEvent) {
   
    if ( session.isEventSource() ) {
      final PersistenceContext persistenceContext
          = session.getPersistenceContext();
      final EntityEntry entityEntry = persistenceContext.getEntry(entity);
      final Serializable id = entityEntry.getId();
     
      postLoadEvent.setEntity( entity ).setId( entityEntry.getId() )
          .setPersister( entityEntry.getPersister() );
View Full Code Here


   */
  protected void postFlush(SessionImplementor session) throws HibernateException {

    LOG.trace( "Post flush" );

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    persistenceContext.getCollectionsByKey().clear();
   
    // the database has changed now, so the subselect results need to be invalidated
    // the batch fetching queues should also be cleared - especially the collection batch fetching one
    persistenceContext.getBatchFetchQueue().clear();

    for ( Map.Entry<PersistentCollection, CollectionEntry> me : IdentityMap.concurrentEntries( persistenceContext.getCollectionEntries() ) ) {
      CollectionEntry collectionEntry = me.getValue();
      PersistentCollection persistentCollection = me.getKey();
      collectionEntry.postFlush(persistentCollection);
      if ( collectionEntry.getLoadedPersister() == null ) {
        //if the collection is dereferenced, remove from the session cache
        //iter.remove(); //does not work, since the entrySet is not backed by the set
        persistenceContext.getCollectionEntries()
            .remove(persistentCollection);
      }
      else {
        //otherwise recreate the mapping between the collection and its key
        CollectionKey collectionKey = new CollectionKey(
            collectionEntry.getLoadedPersister(),
            collectionEntry.getLoadedKey()
        );
        persistenceContext.getCollectionsByKey().put(collectionKey, persistentCollection);
      }
    }

  }
View Full Code Here

      final SessionImplementor session,
      final QueryParameters queryParameters,
      final boolean returnProxies,
      final ResultTransformer forcedResultTransformer)
      throws HibernateException, SQLException {
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    boolean defaultReadOnlyOrig = persistenceContext.isDefaultReadOnly();
    if ( queryParameters.isReadOnlyInitialized() ) {
      // The read-only/modifiable mode for the query was explicitly set.
      // Temporarily set the default read-only/modifiable setting to the query's setting.
      persistenceContext.setDefaultReadOnly( queryParameters.isReadOnly() );
    }
    else {
      // The read-only/modifiable setting for the query was not initialized.
      // Use the default read-only/modifiable from the persistence context instead.
      queryParameters.setReadOnly( persistenceContext.isDefaultReadOnly() );
    }
    persistenceContext.beforeLoad();
    List result;
    try {
      try {
        result = doQuery( session, queryParameters, returnProxies, forcedResultTransformer );
      }
      finally {
        persistenceContext.afterLoad();
      }
      persistenceContext.initializeNonLazyCollections();
    }
    finally {
      // Restore the original default
      persistenceContext.setDefaultReadOnly( defaultReadOnlyOrig );
    }
    return result;
  }
View Full Code Here

        int owner = owners[i];
        if ( owner > -1 ) {
          EntityKey ownerKey = keys[owner];
          if ( keys[i] == null && ownerKey != null ) {

            final PersistenceContext persistenceContext = session.getPersistenceContext();

            /*final boolean isPrimaryKey;
            final boolean isSpecialOneToOne;
            if ( ownerAssociationTypes == null || ownerAssociationTypes[i] == null ) {
              isPrimaryKey = true;
              isSpecialOneToOne = false;
            }
            else {
              isPrimaryKey = ownerAssociationTypes[i].getRHSUniqueKeyPropertyName()==null;
              isSpecialOneToOne = ownerAssociationTypes[i].getLHSPropertyName()!=null;
            }*/

            //TODO: can we *always* use the "null property" approach for everything?
            /*if ( isPrimaryKey && !isSpecialOneToOne ) {
              persistenceContext.addNonExistantEntityKey(
                  new EntityKey( ownerKey.getIdentifier(), persisters[i], session.getEntityMode() )
              );
            }
            else if ( isSpecialOneToOne ) {*/
            boolean isOneToOneAssociation = ownerAssociationTypes!=null &&
                ownerAssociationTypes[i]!=null &&
                ownerAssociationTypes[i].isOneToOne();
            if ( isOneToOneAssociation ) {
              persistenceContext.addNullProperty( ownerKey,
                  ownerAssociationTypes[i].getPropertyName() );
            }
            /*}
            else {
              persistenceContext.addNonExistantEntityUniqueKey( new EntityUniqueKey(
View Full Code Here

      final CollectionAliases descriptor,
      final ResultSet rs,
      final SessionImplementor session)
  throws HibernateException, SQLException {

    final PersistenceContext persistenceContext = session.getPersistenceContext();

    final Serializable collectionRowKey = (Serializable) persister.readKey(
        rs,
        descriptor.getSuffixedKeyAliases(),
        session
      );

    if ( collectionRowKey != null ) {
      // we found a collection element in the result set

      if ( LOG.isDebugEnabled() ) {
        LOG.debugf( "Found row of collection: %s",
            MessageHelper.collectionInfoString( persister, collectionRowKey, getFactory() ) );
      }

      Object owner = optionalOwner;
      if ( owner == null ) {
        owner = persistenceContext.getCollectionOwner( collectionRowKey, persister );
        if ( owner == null ) {
          //TODO: This is assertion is disabled because there is a bug that means the
          //    original owner of a transient, uninitialized collection is not known
          //    if the collection is re-referenced by a different object associated
          //    with the current Session
          //throw new AssertionFailure("bug loading unowned collection");
        }
      }

      PersistentCollection rowCollection = persistenceContext.getLoadContexts()
          .getCollectionLoadContext( rs )
          .getLoadingCollection( persister, collectionRowKey );

      if ( rowCollection != null ) {
        rowCollection.readFrom( rs, persister, descriptor, owner );
      }

    }
    else if ( optionalKey != null ) {
      // we did not find a collection element in the result set, so we
      // ensure that a collection is created with the owner's identifier,
      // since what we have is an empty collection

      if ( LOG.isDebugEnabled() ) {
        LOG.debugf( "Result set contains (possibly empty) collection: %s",
            MessageHelper.collectionInfoString( persister, optionalKey, getFactory() ) );
      }

      persistenceContext.getLoadContexts()
          .getCollectionLoadContext( rs )
          .getLoadingCollection( persister, optionalKey ); // handle empty collection

    }
View Full Code Here

              resultTypes[0].isEntityType() &&
              getEntityPersister( EntityType.class.cast( resultTypes[0] ) )
                  .getEntityMetamodel()
                  .hasImmutableNaturalId();

      final PersistenceContext persistenceContext = session.getPersistenceContext();
      boolean defaultReadOnlyOrig = persistenceContext.isDefaultReadOnly();
      if ( queryParameters.isReadOnlyInitialized() ) {
        // The read-only/modifiable mode for the query was explicitly set.
        // Temporarily set the default read-only/modifiable setting to the query's setting.
        persistenceContext.setDefaultReadOnly( queryParameters.isReadOnly() );
      }
      else {
        // The read-only/modifiable setting for the query was not initialized.
        // Use the default read-only/modifiable from the persistence context instead.
        queryParameters.setReadOnly( persistenceContext.isDefaultReadOnly() );
      }
      try {
        result = queryCache.get(
            key,
            key.getResultTransformer().getCachedResultTypes( resultTypes ),
            isImmutableNaturalKeyLookup,
            querySpaces,
            session
        );
      }
      finally {
        persistenceContext.setDefaultReadOnly( defaultReadOnlyOrig );
      }

      if ( factory.getStatistics().isStatisticsEnabled() ) {
        if ( result == null ) {
          factory.getStatisticsImplementor()
View Full Code Here

      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

      return false;
    }

    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

   * @param event The flush event to be handled.
   * @throws HibernateException
   */
  public void onFlush(FlushEvent event) throws HibernateException {
    final EventSource source = event.getSession();
    final PersistenceContext persistenceContext = source.getPersistenceContext();

    if ( persistenceContext.getNumberOfManagedEntities() > 0 ||
        persistenceContext.getCollectionEntries().size() > 0 ) {

      try {
        source.getEventListenerManager().flushStart();

        flushEverythingToExecutions( event );
View Full Code Here

    if ( object == null ) {
      throw new NullPointerException( "null passed to Session.evict()" );
    }

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

    if ( object instanceof HibernateProxy ) {
      final LazyInitializer li = ( (HibernateProxy) object ).getHibernateLazyInitializer();
      final Serializable id = li.getIdentifier();
      if ( id == null ) {
        throw new IllegalArgumentException( "Could not determine identifier of proxy passed to evict()" );
      }

      final EntityPersister persister = source.getFactory().getEntityPersister( li.getEntityName() );
      final EntityKey key = source.generateEntityKey( id, persister );
      persistenceContext.removeProxy( key );

      if ( !li.isUninitialized() ) {
        final Object entity = persistenceContext.removeEntity( key );
        if ( entity != null ) {
          EntityEntry e = persistenceContext.removeEntry( entity );
          doEvict( entity, key, e.getPersister(), event.getSession() );
        }
      }
      li.unsetSession();
    }
    else {
      EntityEntry e = persistenceContext.removeEntry( object );
      if ( e != null ) {
        persistenceContext.removeEntity( e.getEntityKey() );
        doEvict( object, e.getEntityKey(), e.getPersister(), source );
      }
      else {
        // see if the passed object is even an entity, and if not throw an exception
        //     this is different than legacy Hibernate behavior, but what JPA 2.1 is calling for
        //    with EntityManager.detach
        EntityPersister persister = null;
        final String entityName = persistenceContext.getSession().guessEntityName( object );
        if ( entityName != null ) {
          try {
            persister = persistenceContext.getSession().getFactory().getEntityPersister( entityName );
          }
          catch (Exception ignore) {
          }
        }
        if ( persister == null ) {
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.