Package org.hibernate.persister.entity

Examples of org.hibernate.persister.entity.EntityPersister


    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()
      );
      if ( session.wasInsertedDuringTransaction( persister, id ) ) {
        persister.getCacheAccessStrategy().update(cacheKey, persister.getCacheEntryStructure().structure(entry),version,version);
      } else{
        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


    if ( foreignKeyPropertyName == null ) {
      ownerId = key;
    }
    else {
      Type keyType = getPersister( session ).getKeyType();
      EntityPersister ownerPersister = getPersister( session ).getOwnerEntityPersister();
      // TODO: Fix this so it will work for non-POJO entity mode
      Class ownerMappedClass = ownerPersister.getMappedClass( session.getEntityMode() );
      if ( ownerMappedClass.isAssignableFrom( keyType.getReturnedClass() ) &&
          keyType.getReturnedClass().isInstance( key ) ) {
        // the key is the owning entity itself, so get the ID from the key
        ownerId = ownerPersister.getIdentifier( key, session.getEntityMode() );
      }
      else {
        // TODO: check if key contains the owner ID
      }
    }
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

      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

          accessStrategy = entityRegion.buildAccessStrategy( accessType );
          entityAccessStrategies.put( cacheRegionName, accessStrategy );
          allCacheRegions.put( cacheRegionName, entityRegion );
        }
      }
      EntityPersister cp = PersisterFactory.createClassPersister( model, accessStrategy, this, mapping );
      entityPersisters.put( model.getEntityName(), cp );
      classMeta.put( model.getEntityName(), cp.getClassMetadata() );
    }
    classMetadata = Collections.unmodifiableMap(classMeta);

    Map tmpEntityToCollectionRoleMap = new HashMap();
    collectionPersisters = new HashMap();
    Iterator collections = cfg.getCollectionMappings();
    while ( collections.hasNext() ) {
      Collection model = (Collection) collections.next();
      final String cacheRegionName = cacheRegionPrefix + model.getCacheRegionName();
      final AccessType accessType = AccessType.parse( model.getCacheConcurrencyStrategy() );
      CollectionRegionAccessStrategy accessStrategy = null;
      if ( accessType != null && settings.isSecondLevelCacheEnabled() ) {
        log.trace( "Building cache for collection data [" + model.getRole() + "]" );
        CollectionRegion collectionRegion = settings.getRegionFactory().buildCollectionRegion( cacheRegionName, properties, CacheDataDescriptionImpl.decode( model ) );
        accessStrategy = collectionRegion.buildAccessStrategy( accessType );
        entityAccessStrategies.put( cacheRegionName, accessStrategy );
        allCacheRegions.put( cacheRegionName, collectionRegion );
      }
      CollectionPersister persister = PersisterFactory.createCollectionPersister( cfg, model, accessStrategy, this) ;
      collectionPersisters.put( model.getRole(), persister.getCollectionMetadata() );
      Type indexType = persister.getIndexType();
      if ( indexType != null && indexType.isAssociationType() && !indexType.isAnyType() ) {
        String entityName = ( ( AssociationType ) indexType ).getAssociatedEntityName( this );
        Set roles = ( Set ) tmpEntityToCollectionRoleMap.get( entityName );
        if ( roles == null ) {
          roles = new HashSet();
          tmpEntityToCollectionRoleMap.put( entityName, roles );
        }
        roles.add( persister.getRole() );
      }
      Type elementType = persister.getElementType();
      if ( elementType.isAssociationType() && !elementType.isAnyType() ) {
        String entityName = ( ( AssociationType ) elementType ).getAssociatedEntityName( this );
        Set roles = ( Set ) tmpEntityToCollectionRoleMap.get( entityName );
        if ( roles == null ) {
          roles = new HashSet();
          tmpEntityToCollectionRoleMap.put( entityName, roles );
        }
        roles.add( persister.getRole() );
      }
    }
    collectionMetadata = Collections.unmodifiableMap(collectionPersisters);
    Iterator itr = tmpEntityToCollectionRoleMap.entrySet().iterator();
    while ( itr.hasNext() ) {
      final Map.Entry entry = ( Map.Entry ) itr.next();
      entry.setValue( Collections.unmodifiableSet( ( Set ) entry.getValue() ) );
    }
    collectionRolesByEntityParticipant = Collections.unmodifiableMap( tmpEntityToCollectionRoleMap );

    //Named Queries:
    namedQueries = new HashMap( cfg.getNamedQueries() );
    namedSqlQueries = new HashMap( cfg.getNamedSQLQueries() );
    sqlResultSetMappings = new HashMap( cfg.getSqlResultSetMappings() );
    imports = new HashMap( cfg.getImports() );

    // after *all* persisters and named queries are registered
    Iterator iter = entityPersisters.values().iterator();
    while ( iter.hasNext() ) {
      final EntityPersister persister = ( ( EntityPersister ) iter.next() );
      persister.postInstantiate();
      registerEntityNameResolvers( persister );

    }
    iter = collectionPersisters.values().iterator();
    while ( iter.hasNext() ) {
      final CollectionPersister persister = ( ( CollectionPersister ) iter.next() );
      persister.postInstantiate();
    }

    //JNDI + Serialization:

    name = settings.getSessionFactoryName();
View Full Code Here

    }
    return currentSessionContext.currentSession();
  }

  public EntityPersister getEntityPersister(String entityName) throws MappingException {
    EntityPersister result = (EntityPersister) entityPersisters.get(entityName);
    if (result==null) {
      throw new MappingException( "Unknown entity: " + entityName );
    }
    return result;
  }
View Full Code Here

    ArrayList results = new ArrayList();
    Iterator iter = entityPersisters.values().iterator();
    while ( iter.hasNext() ) {
      //test this entity to see if we must query it
      EntityPersister testPersister = (EntityPersister) iter.next();
      if ( testPersister instanceof Queryable ) {
        Queryable testQueryable = (Queryable) testPersister;
        String testClassName = testQueryable.getEntityName();
        boolean isMappedClass = className.equals(testClassName);
        if ( testQueryable.isExplicitPolymorphism() ) {
View Full Code Here

    isClosed = true;

    Iterator iter = entityPersisters.values().iterator();
    while ( iter.hasNext() ) {
      EntityPersister p = (EntityPersister) iter.next();
      if ( p.hasCache() ) {
        p.getCacheAccessStrategy().getRegion().destroy();
      }
    }

    iter = collectionPersisters.values().iterator();
    while ( iter.hasNext() ) {
      CollectionPersister p = (CollectionPersister) iter.next();
      if ( p.hasCache() ) {
        p.getCacheAccessStrategy().getRegion().destroy();
      }
    }

    if ( settings.isQueryCacheEnabled() )  {
      queryCache.destroy();
View Full Code Here

    observer.sessionFactoryClosed( this );
    eventListeners.destroyListeners();
  }

  public void evictEntity(String entityName, Serializable id) throws HibernateException {
    EntityPersister p = getEntityPersister( entityName );
    if ( p.hasCache() ) {
      if ( log.isDebugEnabled() ) {
        log.debug( "evicting second-level cache: " + MessageHelper.infoString(p, id, this) );
      }
      CacheKey cacheKey = new CacheKey( id, p.getIdentifierType(), p.getRootEntityName(), EntityMode.POJO, this );
      p.getCacheAccessStrategy().evict( cacheKey );
    }
  }
View Full Code Here

      p.getCacheAccessStrategy().evict( cacheKey );
    }
  }

  public void evictEntity(String entityName) throws HibernateException {
    EntityPersister p = getEntityPersister( entityName );
    if ( p.hasCache() ) {
      if ( log.isDebugEnabled() ) {
        log.debug( "evicting second-level cache: " + p.getEntityName() );
      }
      p.getCacheAccessStrategy().evictAll();
    }
  }
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.