Package org.hibernate.persister.entity

Examples of org.hibernate.persister.entity.EntityPersister


    if ( keySubgraphMap == null ) {
      keySubgraphMap = new HashMap<Class, Subgraph>();
    }

    final AssociationType indexAssociationType = (AssociationType) indexType;
    final EntityPersister indexEntityPersister = (EntityPersister) indexAssociationType.getAssociatedJoinable( sessionFactory() );

    if ( type == null ) {
      type = indexEntityPersister.getMappedClass();
    }
    else {
      if ( !isTreatableAs( indexEntityPersister, type ) ) {
        throw new IllegalArgumentException(
            String.format(
                "Map key [%s] cannot be treated as requested type [%s] : %s",
                getAttributeName(),
                type.getName(),
                indexEntityPersister.getMappedClass().getName()
            )
        );
      }
    }
View Full Code Here


    // let the interceptor inspect the instance to decide
    Boolean isUnsaved = session.getInterceptor().isTransient(entity);
    if (isUnsaved!=null) return isUnsaved.booleanValue();
   
    // let the persister inspect the instance to decide
    EntityPersister persister = session.getEntityPersister(entityName, entity);
    isUnsaved = persister.isTransient(entity, session);
    if (isUnsaved!=null) return isUnsaved.booleanValue();

    // we use the assumed value, if there is one, to avoid hitting
    // the database
    if (assumed!=null) return assumed.booleanValue();
   
    // hit the database, after checking the session cache for a snapshot
    Object[] snapshot = session.getPersistenceContext()
            .getDatabaseSnapshot( persister.getIdentifier( entity, session.getEntityMode() ), persister );
    return snapshot==null;

  }
View Full Code Here

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    EntityEntry entityEntry = persistenceContext.getEntry(entity);
    if ( entityEntry == null ) {
      throw new AssertionFailure( "possible non-threadsafe access to the session" );
    }
    EntityPersister persister = entityEntry.getPersister();
    Serializable id = entityEntry.getId();
    Object[] hydratedState = entityEntry.getLoadedState();
 
    if ( log.isDebugEnabled() )
      log.debug(
          "resolving associations for " +
          MessageHelper.infoString(persister, id, session.getFactory())
        );
 
    Type[] types = persister.getPropertyTypes();
    for ( int i = 0; i < hydratedState.length; i++ ) {
      final Object value = hydratedState[i];
      if ( value!=LazyPropertyInitializer.UNFETCHED_PROPERTY && value!=BackrefPropertyAccessor.UNKNOWN ) {
        hydratedState[i] = types[i].resolve( value, session, entity );
      }
    }
 
    //Must occur after resolving identifiers!
    if ( session.isEventSource() ) {
      preLoadEvent.setEntity(entity).setState(hydratedState).setId(id).setPersister(persister);
      PreLoadEventListener[] listeners = session.getListeners().getPreLoadEventListeners();
      for ( int i = 0; i < listeners.length; i++ ) {
        listeners[i].onPreLoad(preLoadEvent);
      }
    }
 
    persister.setPropertyValues( entity, hydratedState, session.getEntityMode() );
 
    final SessionFactoryImplementor factory = session.getFactory();
    if ( persister.hasCache() && session.getCacheMode().isPutEnabled() ) {
     
      if ( log.isDebugEnabled() )
        log.debug(
            "adding entity to second-level cache: " +
            MessageHelper.infoString( persister, id, session.getFactory() )
          );

      Object version = Versioning.getVersion(hydratedState, persister);
      CacheEntry entry = new CacheEntry(
          hydratedState,
          persister,
          entityEntry.isLoadedWithLazyPropertiesUnfetched(),
          version,
          session,
          entity
      );
      CacheKey cacheKey = new CacheKey(
          id,
          persister.getIdentifierType(),
          persister.getRootEntityName(),
          session.getEntityMode(),
          session.getFactory()
      );
      boolean put = persister.getCacheAccessStrategy().putFromLoad(
          cacheKey,
          persister.getCacheEntryStructure().structure( entry ),
          session.getTimestamp(),
          version,
          useMinimalPuts( session, entityEntry )
      );

      if ( put && factory.getStatistics().isStatisticsEnabled() ) {
        factory.getStatisticsImplementor().secondLevelCachePut( persister.getCacheAccessStrategy().getRegion().getName() );
      }
    }
 
    if ( readOnly || !persister.isMutable() ) {
      //no need to take a snapshot - this is a
      //performance optimization, but not really
      //important, except for entities with huge
      //mutable property values
      persistenceContext.setEntryStatus(entityEntry, Status.READ_ONLY);
    }
    else {
      //take a snapshot
      TypeFactory.deepCopy(
          hydratedState,
          persister.getPropertyTypes(),
          persister.getPropertyUpdateability(),
          hydratedState,  //after setting values to object, entityMode
          session
        );
      persistenceContext.setEntryStatus(entityEntry, Status.MANAGED);
    }
   
    persister.afterInitialize(
        entity,
        entityEntry.isLoadedWithLazyPropertiesUnfetched(),
        session
      );
   
    if ( session.isEventSource() ) {
      postLoadEvent.setEntity(entity).setId(id).setPersister(persister);
      PostLoadEventListener[] listeners = session.getListeners().getPostLoadEventListeners();
      for ( int i = 0; i < listeners.length; i++ ) {
        listeners[i].onPostLoad(postLoadEvent);
      }
    }
   
    if ( log.isDebugEnabled() )
      log.debug(
          "done materializing entity " +
          MessageHelper.infoString( persister, id, session.getFactory() )
        );
   
    if ( factory.getStatistics().isStatisticsEnabled() ) {
      factory.getStatisticsImplementor().loadEntity( persister.getEntityName() );
    }
 
  }
View Full Code Here

    final EventSource source = event.getSession();
   
    //TODO: check that entry.getIdentifier().equals(requestedId)
   
    final Object entity = source.getPersistenceContext().unproxy( event.getObject() );
    final EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );
   
    if ( createCache.put(entity, entity)==null ) {
      //TODO: merge into one method!
      cascadeBeforeSave(source, persister, entity, createCache);
      cascadeAfterSave(source, persister, entity, createCache);
View Full Code Here

    delayedEntityKey = isDelayed ? generateDelayedEntityKey() : null;
  }

  public void execute() throws HibernateException {
   
    final EntityPersister persister = getPersister();
    final SessionImplementor session = getSession();
    final Object instance = getInstance();
   
    boolean veto = preInsert();

    // Don't need to lock the cache here, since if someone
    // else inserted the same pk first, the insert would fail

    if ( !veto ) {
      generatedId = persister.insert( state, instance, session );
      if ( persister.hasInsertGeneratedProperties() ) {
        persister.processInsertGeneratedProperties( generatedId, instance, state, session );
      }
      //need to do that here rather than in the save event listener to let
      //the post insert events to have a id-filled entity when IDENTITY is used (EJB3)
      persister.setIdentifier( instance, generatedId, session.getEntityMode() );
    }


    //TODO: this bit actually has to be called after all cascades!
    //      but since identity insert is called *synchronously*,
 
View Full Code Here

    }
    return customReturns;
  }

  private SQLLoadable getSQLLoadable(String entityName) throws MappingException {
    EntityPersister persister = factory.getEntityPersister( entityName );
    if ( !(persister instanceof SQLLoadable) ) {
      throw new MappingException( "class persister is not SQLLoadable: " + entityName );
    }
    return (SQLLoadable) persister;
  }
View Full Code Here

    this.rowId = rowId;
  }

  public void execute() throws HibernateException {
    Serializable id = getId();
    EntityPersister persister = getPersister();
    SessionImplementor session = getSession();
    Object instance = getInstance();

    boolean veto = preUpdate();

    final SessionFactoryImplementor factory = getSession().getFactory();
    Object previousVersion = this.previousVersion;
    if ( persister.isVersionPropertyGenerated() ) {
      // we need to grab the version value from the entity, otherwise
      // we have issues with generated-version entities that may have
      // multiple actions queued during the same flush
      previousVersion = persister.getVersion( instance, session.getEntityMode() );
    }
   
    final CacheKey ck;
    if ( persister.hasCache() ) {
      ck = new CacheKey(
          id,
          persister.getIdentifierType(),
          persister.getRootEntityName(),
          session.getEntityMode(),
          session.getFactory()
      );
      lock = persister.getCacheAccessStrategy().lockItem( ck, previousVersion );
    }
    else {
      ck = null;
    }

    if ( !veto ) {
      persister.update(
          id,
          state,
          dirtyFields,
          hasDirtyCollection,
          previousState,
          previousVersion,
          instance,
          rowId,
          session
      );
    }

    EntityEntry entry = getSession().getPersistenceContext().getEntry( instance );
    if ( entry == null ) {
      throw new AssertionFailure( "possible nonthreadsafe access to session" );
    }
   
    if ( entry.getStatus()==Status.MANAGED || persister.isVersionPropertyGenerated() ) {
      // get the updated snapshot of the entity state by cloning current state;
      // it is safe to copy in place, since by this time no-one else (should have)
      // has a reference  to the array
      TypeFactory.deepCopy(
          state,
          persister.getPropertyTypes(),
          persister.getPropertyCheckability(),
          state,
          session
      );
      if ( persister.hasUpdateGeneratedProperties() ) {
        // this entity defines proeprty generation, so process those generated
        // values...
        persister.processUpdateGeneratedProperties( id, instance, state, session );
        if ( persister.isVersionPropertyGenerated() ) {
          nextVersion = Versioning.getVersion( state, persister );
        }
      }
      // have the entity entry perform post-update processing, passing it the
      // update state and the new version (if one).
      entry.postUpdate( instance, state, nextVersion );
    }

    if ( persister.hasCache() ) {
      if ( persister.isCacheInvalidationRequired() || entry.getStatus()!=Status.MANAGED ) {
        persister.getCacheAccessStrategy().remove( ck );
      }
      else {
        //TODO: inefficient if that cache is just going to ignore the updated state!
        CacheEntry ce = new CacheEntry(
            state,
            persister,
            persister.hasUninitializedLazyProperties( instance, session.getEntityMode() ),
            nextVersion,
            getSession(),
            instance
        );
        cacheEntry = persister.getCacheEntryStructure().structure( ce );
        boolean put = persister.getCacheAccessStrategy().update( ck, cacheEntry, nextVersion, previousVersion );
        if ( put && factory.getStatistics().isStatisticsEnabled() ) {
          factory.getStatisticsImplementor().secondLevelCachePut( getPersister().getCacheAccessStrategy().getRegion().getName() );
        }
      }
    }
View Full Code Here

      log.trace("already refreshed");
      return;
    }

    final EntityEntry e = source.getPersistenceContext().getEntry( object );
    final EntityPersister persister;
    final Serializable id;
   
    if ( e == null ) {
      persister = source.getEntityPersister(null, object); //refresh() does not pass an entityName
      id = persister.getIdentifier( object, event.getSession().getEntityMode() );
      if ( log.isTraceEnabled() ) {
        log.trace(
            "refreshing transient " +
            MessageHelper.infoString( persister, id, source.getFactory() )
          );
      }
      EntityKey key = new EntityKey( id, persister, source.getEntityMode() );
      if ( source.getPersistenceContext().getEntry(key) != null ) {
        throw new PersistentObjectException(
            "attempted to refresh transient instance when persistent instance was already associated with the Session: " +
            MessageHelper.infoString(persister, id, source.getFactory() )
          );
      }
    }
    else {
      if ( log.isTraceEnabled() ) {
        log.trace(
            "refreshing " +
            MessageHelper.infoString( e.getPersister(), e.getId(), source.getFactory()  )
          );
      }
      if ( !e.isExistsInDatabase() ) {
        throw new HibernateException( "this instance does not yet exist as a row in the database" );
      }

      persister = e.getPersister();
      id = e.getId();
    }

    // cascade the refresh prior to refreshing this entity
    refreshedAlready.put(object, object);
    new Cascade(CascadingAction.REFRESH, Cascade.BEFORE_REFRESH, source)
        .cascade( persister, object, refreshedAlready );

    if ( e != null ) {
      EntityKey key = new EntityKey( id, persister, source.getEntityMode() );
      source.getPersistenceContext().removeEntity(key);
      if ( persister.hasCollections() ) new EvictVisitor( source ).process(object, persister);
    }

    if ( persister.hasCache() ) {
      final CacheKey ck = new CacheKey(
          id,
          persister.getIdentifierType(),
          persister.getRootEntityName(),
          source.getEntityMode(),
          source.getFactory()
      );
      persister.getCacheAccessStrategy().evict( ck );
    }
   
    evictCachedCollections( persister, id, source.getFactory() );
   
    String previousFetchProfile = source.getFetchProfile();
    source.setFetchProfile("refresh");
    Object result = persister.load( id, object, event.getLockMode(), source );
    source.setFetchProfile(previousFetchProfile);
   
    UnresolvableObjectException.throwIfNull( result, id, persister.getEntityName() );

  }
View Full Code Here

    }
    return veto;
  }

  public void afterTransactionCompletion(boolean success) throws CacheException {
    EntityPersister persister = getPersister();
    if ( persister.hasCache() ) {
     
      final CacheKey ck = new CacheKey(
          getId(),
          persister.getIdentifierType(),
          persister.getRootEntityName(),
          getSession().getEntityMode(),
          getSession().getFactory()
        );
     
      if ( success && cacheEntry!=null /*!persister.isCacheInvalidationRequired()*/ ) {
        boolean put = persister.getCacheAccessStrategy().afterUpdate( ck, cacheEntry, nextVersion, previousVersion, lock );
       
        if ( put && getSession().getFactory().getStatistics().isStatisticsEnabled() ) {
          getSession().getFactory().getStatisticsImplementor().secondLevelCachePut( getPersister().getCacheAccessStrategy().getRegion().getName() );
        }
      }
      else {
        persister.getCacheAccessStrategy().unlockItem( ck, lock );
      }
    }
    postCommitUpdate();
  }
View Full Code Here

    this.state = state;
  }

  public void execute() throws HibernateException {
    Serializable id = getId();
    EntityPersister persister = getPersister();
    SessionImplementor session = getSession();
    Object instance = getInstance();

    boolean veto = preDelete();

    Object version = this.version;
    if ( persister.isVersionPropertyGenerated() ) {
      // we need to grab the version value from the entity, otherwise
      // we have issues with generated-version entities that may have
      // multiple actions queued during the same flush
      version = persister.getVersion( instance, session.getEntityMode() );
    }

    final CacheKey ck;
    if ( persister.hasCache() ) {
      ck = new CacheKey(
          id,
          persister.getIdentifierType(),
          persister.getRootEntityName(),
          session.getEntityMode(),
          session.getFactory()
        );
      lock = persister.getCacheAccessStrategy().lockItem( ck, version );
    }
    else {
      ck = null;
    }

    if ( !isCascadeDeleteEnabled && !veto ) {
      persister.delete( id, version, instance, session );
    }
   
    //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();

    EntityKey key = new EntityKey( entry.getId(), entry.getPersister(), session.getEntityMode() );
    persistenceContext.removeEntity(key);
    persistenceContext.removeProxy(key);
   
    if ( persister.hasCache() ) persister.getCacheAccessStrategy().remove( ck );

    postDelete();

    if ( getSession().getFactory().getStatistics().isStatisticsEnabled() && !veto ) {
      getSession().getFactory().getStatisticsImplementor()
View Full Code Here

TOP

Related Classes of org.hibernate.persister.entity.EntityPersister

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.