Examples of org.hibernate.engine.spi.PersistenceContext

org.hibernate.engine.spi.PersistenceContext
Represents the state of "stuff" Hibernate is tracking, including (not exhaustive):
- entities
- collections
- snapshots
- proxies
Often referred to as the "first level cache". @author Gavin King @author Steve Ebersole

      OgmLoadingContext ogmLoadingContext,
      boolean returnProxies) {




    //TODO handles the read only
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    boolean defaultReadOnlyOrig = persistenceContext.isDefaultReadOnly();
    persistenceContext.beforeLoad();
    List<Object> result;
    try {
      try {
        result = doQuery(
            session,
            qp,
            ogmLoadingContext,
            returnProxies
        );
      }
      finally {
        persistenceContext.afterLoad();
      }
      persistenceContext.initializeNonLazyCollections();
    }
    finally {
      // Restore the original default
      persistenceContext.setDefaultReadOnly( defaultReadOnlyOrig );
    }


    log.debug( "done entity load" );
    return result;
  }

View Full Code Here

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


    final PersistenceContext persistenceContext = session.getPersistenceContext();


    //implement persister.readKey using the grid type (later)
    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.debug(
            "found row of collection: " +
            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.debug(
            "result set contains (possibly empty) collection: " +
            MessageHelper.collectionInfoString( persister, optionalKey, getFactory() )
          );
      }


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


    }

View Full Code Here

        int owner = owners[i];
        if ( owner > -1 ) {
          org.hibernate.engine.spi.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

        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 The collection
   */
  public Object getCollection(Serializable key, SessionImplementor session, Object owner) {


    CollectionPersister persister = getPersister( session );
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final EntityMode entityMode = persister.getOwnerEntityPersister().getEntityMode();


    // check if collection is currently being loaded
    PersistentCollection collection = persistenceContext.getLoadContexts().locateLoadingCollection( persister, key );
    
    if ( collection == null ) {
      
      // check if it is already completely loaded, but unowned
      collection = persistenceContext.useUnownedCollection( new CollectionKey(persister, key, entityMode) );
      
      if ( collection == null ) {
        // create a new collection wrapper, to be initialized later
        collection = instantiate( session, persister, key );
        
        collection.setOwner(owner);
  
        persistenceContext.addUninitializedCollection( persister, collection, key );
  
        // some collections are not lazy:
        if ( initializeImmediately() ) {
          session.initializeCollection( collection, false );
        }
        else if ( !persister.isLazy() ) {
          persistenceContext.addNonLazyCollection( collection );
        }
  
        if ( hasHolder() ) {
          session.getPersistenceContext().addCollectionHolder( collection );
        }

View Full Code Here

  @Override
  public void finishUpRow(ResultSet resultSet, ResultSetProcessingContextImpl context) {


    try {
      // read the collection key for this reference for the current row.
      final PersistenceContext persistenceContext = context.getSession().getPersistenceContext();
      final Serializable collectionRowKey = (Serializable) collectionReference.getCollectionPersister().readKey(
          resultSet,
          aliases.getCollectionColumnAliases().getSuffixedKeyAliases(),
          context.getSession()
      );


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


        if ( log.isDebugEnabled() ) {
          log.debugf(
              "Found row of collection: %s",
              MessageHelper.collectionInfoString(
                  collectionReference.getCollectionPersister(),
                  collectionRowKey,
                  context.getSession().getFactory()
              )
          );
        }


        Object collectionOwner = findCollectionOwner( collectionRowKey, resultSet, context );


        PersistentCollection rowCollection = persistenceContext.getLoadContexts()
            .getCollectionLoadContext( resultSet )
            .getLoadingCollection( collectionReference.getCollectionPersister(), collectionRowKey );


        if ( rowCollection != null ) {
          rowCollection.readFrom(
              resultSet,
              collectionReference.getCollectionPersister(),
              aliases.getCollectionColumnAliases(),
              collectionOwner
          );
        }


      }
      else {
        final Serializable optionalKey = findCollectionOwnerKey( context );
        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(
                    collectionReference.getCollectionPersister(),
                    optionalKey,
                    context.getSession().getFactory()
                )
            );
          }
          // handle empty collection
          persistenceContext.getLoadContexts()
              .getCollectionLoadContext( resultSet )
              .getLoadingCollection( collectionReference.getCollectionPersister(), optionalKey );


        }
      }

View Full Code Here

          collectionPersister().getKeyColumnNames(),
          getFactory().getDialect()
      );


      try {
        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();
        try {
          try {
            doTheLoad( sql, queryParameters, session );
          }
          finally {
            persistenceContext.afterLoad();
          }
          persistenceContext.initializeNonLazyCollections();
        }
        finally {
          // Restore the original default
          persistenceContext.setDefaultReadOnly( defaultReadOnlyOrig );
        }
      }
      catch ( SQLException e ) {
        throw getFactory().getSQLExceptionHelper().convert(
            e,

View Full Code Here

      QueryParameters queryParameters,
      LoadQueryDetails loadQueryDetails,
      boolean returnProxies,
      ResultTransformer forcedResultTransformer,
      List<AfterLoadAction> afterLoadActions) throws SQLException {
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final 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();
    try {
      List results = null;
      final String sql = loadQueryDetails.getSqlStatement();
      SqlStatementWrapper wrapper = null;
      try {
        wrapper = executeQueryStatement( sql, queryParameters, false, afterLoadActions, session );
        results = loadQueryDetails.getResultSetProcessor().extractResults(
            wrapper.getResultSet(),
            session,
            queryParameters,
            new NamedParameterContext() {
              @Override
              public int[] getNamedParameterLocations(String name) {
                return AbstractLoadPlanBasedLoader.this.getNamedParameterLocs( name );
              }
            },
            returnProxies,
            queryParameters.isReadOnly(),
            forcedResultTransformer,
            afterLoadActions
        );
      }
      finally {
        if ( wrapper != null ) {
          session.getTransactionCoordinator().getJdbcCoordinator().release(
              wrapper.getResultSet(),
              wrapper.getStatement()
          );
          session.getTransactionCoordinator().getJdbcCoordinator().release( wrapper.getStatement() );
        }
        persistenceContext.afterLoad();
      }
      persistenceContext.initializeNonLazyCollections();
      return results;
    }
    finally {
      // Restore the original default
      persistenceContext.setDefaultReadOnly( defaultReadOnlyOrig );
    }
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

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

org.hibernate.action.internal.EntityDeleteAction

org.hibernate.engine.internal.Collections

org.hibernate.engine.internal.TwoPhaseLoad

org.hibernate.event.internal.AbstractFlushingEventListener

org.hibernate.event.internal.DefaultDeleteEventListener

org.hibernate.event.internal.DefaultEvictEventListener

org.hibernate.event.internal.DefaultFlushEventListener

org.hibernate.event.internal.DefaultInitializeCollectionEventListener

org.hibernate.event.internal.DefaultLoadEventListener

org.hibernate.event.internal.WrapVisitor

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.