Examples of org.hibernate.engine.PersistenceContext

org.hibernate.engine.PersistenceContext
Holds the state of the persistence context, including the first-level cache, entries, snapshots, proxies, etc. @author Gavin King

    
    //postDelete:
    // After actually deleting a row, record the fact that the instance no longer 
    // exists on the database (needed for identity-column key generation), and
    // remove it from the session cache
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    EntityEntry entry = persistenceContext.removeEntry( instance );
    if ( entry == null ) {
      throw new AssertionFailure( "possible nonthreadsafe access to session" );
    }
    entry.postDelete();


    persistenceContext.removeEntity( entry.getEntityKey() );
    persistenceContext.removeProxy( entry.getEntityKey() );
    
    if ( persister.hasCache() ) persister.getCacheAccessStrategy().remove( ck );


    postDelete();

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;
      }
      else {
        performDetachedEntityDeletionCheck( event );
      }


      id = persister.getIdentifier( entity, source.getEntityMode() );


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


      EntityKey key = new EntityKey( id, persister, source.getEntityMode() );


      persistenceContext.checkUniqueness( key, entity );


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


      version = persister.getVersion( entity, source.getEntityMode() );


      entityEntry = persistenceContext.addEntity(
          entity,
          Status.MANAGED,
          persister.getPropertyValues( entity, source.getEntityMode() ),
          key,
          version,

View Full Code Here

          "deleting " +
              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, session.getEntityMode() );
    }
    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 );
    EntityKey key = new EntityKey( entityEntry.getId(), persister, session.getEntityMode() );


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


    // Ensures that containing deletions happen before sub-deletions
    session.getActionQueue().addAction(
        new EntityDeleteAction(
            entityEntry.getId(),

View Full Code Here

    if ( !persister.hasProxy() ) {
      // this class has no proxies (so do a shortcut)
      return load(event, persister, keyToLoad, options);
    }
    else {
      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 );
      }
      else {
        if ( options.isAllowProxyCreation() ) {

View Full Code Here

      );


    Object version = Versioning.getVersion( values, subclassPersister );
    if ( log.isTraceEnabled() ) log.trace( "Cached Version: " + version );


    final PersistenceContext persistenceContext = session.getPersistenceContext();
    persistenceContext.addEntry(
        result,
        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

   * @return The collection
   */
  public Object getCollection(Serializable key, SessionImplementor session, Object owner) {


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


    if (entityMode==EntityMode.DOM4J && !isEmbeddedInXML) {
      return UNFETCHED_COLLECTION;
    }
    
    // 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( entityMode ) ) {
          session.initializeCollection( collection, false );
        }
        else if ( !persister.isLazy() ) {
          persistenceContext.addNonLazyCollection( collection );
        }
  
        if ( hasHolder( entityMode ) ) {
          session.getPersistenceContext().addCollectionHolder( collection );
        }

View Full Code Here


    log.trace("flushing session");
    
    EventSource session = event.getSession();
    
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    session.getInterceptor().preFlush( new LazyIterator( persistenceContext.getEntitiesByKey() ) );


    prepareEntityFlushes(session);
    // we could move this inside if we wanted to
    // tolerate collection initializations during
    // collection dirty checking:
    prepareCollectionFlushes(session);
    // now, any collections that are initialized
    // inside this block do not get updated - they
    // are ignored until the next flush
        
    persistenceContext.setFlushing(true);
    try {
      flushEntities(event);
      flushCollections(session);
    }
    finally {
      persistenceContext.setFlushing(false);
    }


    //some statistics
    if ( log.isDebugEnabled() ) {
      log.debug( "Flushed: " +
          session.getActionQueue().numberOfInsertions() + " insertions, " +
          session.getActionQueue().numberOfUpdates() + " updates, " +
          session.getActionQueue().numberOfDeletions() + " deletions to " +
          persistenceContext.getEntityEntries().size() + " objects"
        );
      log.debug( "Flushed: " +
          session.getActionQueue().numberOfCollectionCreations() + " (re)creations, " +
          session.getActionQueue().numberOfCollectionUpdates() + " updates, " +
          session.getActionQueue().numberOfCollectionRemovals() + " removals to " +
          persistenceContext.getCollectionEntries().size() + " collections"
        );
      new Printer( session.getFactory() ).toString( 
          persistenceContext.getEntitiesByKey().values().iterator(), 
          session.getEntityMode() 
        );
    }
  }

View Full Code Here

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


    log.trace( "post flush" );


    final PersistenceContext persistenceContext = session.getPersistenceContext();
    persistenceContext.getCollectionsByKey().clear();
    persistenceContext.getBatchFetchQueue()
        .clearSubselects(); //the database has changed now, so the subselect results need to be invalidated


    Iterator iter = persistenceContext.getCollectionEntries().entrySet().iterator();
    while ( iter.hasNext() ) {
      Map.Entry me = (Map.Entry) iter.next();
      CollectionEntry collectionEntry = (CollectionEntry) me.getValue();
      PersistentCollection 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(), 
            session.getEntityMode() 
          );
        persistenceContext.getCollectionsByKey()
            .put(collectionKey, persistentCollection);
      }
    }
    
    session.getInterceptor().postFlush( new LazyIterator( persistenceContext.getEntitiesByKey() ) );


  }

View Full Code Here

   */
  private List doQueryAndInitializeNonLazyCollections(
      final SessionImplementor session,
      final QueryParameters queryParameters,
      final boolean returnProxies) 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 );
      }
      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

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hibernate.engine.PersistenceContext

org.hibernate.action.EntityDeleteAction

org.hibernate.action.internal.EntityDeleteAction

org.hibernate.event.def.AbstractFlushingEventListener

org.hibernate.event.def.DefaultDeleteEventListener

org.hibernate.event.def.DefaultEvictEventListener

org.hibernate.event.def.DefaultInitializeCollectionEventListener

org.hibernate.event.def.DefaultLoadEventListener

org.hibernate.event.def.WrapVisitor

org.hibernate.loader.Loader

org.hibernate.ogm.loader.OgmLoader

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.