Examples of org.hibernate.persister.entity.EntityPersister

org.hibernate.persister.entity.EntityPersister
Implementors define mapping and persistence logic for a particular strategy of entity mapping. An instance of entity persisters corresponds to a given mapped entity.
Implementors must be threadsafe (preferrably immutable) and must provide a constructor matching the signature of: {@link org.hibernate.mapping.PersistentClass}, {@link org.hibernate.engine.SessionFactoryImplementor} @author Gavin King

          "assembling entity from second-level cache: " +
          MessageHelper.infoString( persister, id, factory )
        );
    }


    EntityPersister subclassPersister = factory.getEntityPersister( entry.getSubclass() );
    Object result = optionalObject == null ?
        session.instantiate( subclassPersister, id ) : optionalObject;


    // make it circular-reference safe
    TwoPhaseLoad.addUninitializedCachedEntity(
        new EntityKey( id, subclassPersister, session.getEntityMode() ),
        result,
        subclassPersister,
        LockMode.NONE,
        entry.areLazyPropertiesUnfetched(),
        entry.getVersion(),
        session
      );


    Type[] types = subclassPersister.getPropertyTypes();
    Object[] values = entry.assemble( result, id, subclassPersister, session.getInterceptor(), session ); // intializes result by side-effect
    TypeFactory.deepCopy(
        values,
        types,
        subclassPersister.getPropertyUpdateability(),
        values,
        session
      );


    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

View Full Code Here

   */
  public void onFlushEntity(FlushEntityEvent event) throws HibernateException {
    final Object entity = event.getEntity();
    final EntityEntry entry = event.getEntityEntry();
    final EventSource session = event.getSession();
    final EntityPersister persister = entry.getPersister();
    final Status status = entry.getStatus();
    final EntityMode entityMode = session.getEntityMode();
    final Type[] types = persister.getPropertyTypes();


    final boolean mightBeDirty = entry.requiresDirtyCheck(entity);


    final Object[] values = getValues( entity, entry, entityMode, mightBeDirty, session );


    event.setPropertyValues(values);


    //TODO: avoid this for non-new instances where mightBeDirty==false
    boolean substitute = wrapCollections( session, persister, types, values);


    if ( isUpdateNecessary( event, mightBeDirty ) ) {
      substitute = scheduleUpdate( event ) || substitute;
    }


    if ( status != Status.DELETED ) {
      // now update the object .. has to be outside the main if block above (because of collections)
      if (substitute) persister.setPropertyValues( entity, values, entityMode );


      // Search for collections by reachability, updating their role.
      // We don't want to touch collections reachable from a deleted object
      if ( persister.hasCollections() ) {
        new FlushVisitor(session, entity).processEntityPropertyValues(values, types);
      }
    }


  }

View Full Code Here

      boolean mightBeDirty,
          SessionImplementor session
  ) {
    final Object[] loadedState = entry.getLoadedState();
    final Status status = entry.getStatus();
    final EntityPersister persister = entry.getPersister();


    final Object[] values;
    if ( status == Status.DELETED ) {
      //grab its state saved at deletion
      values = entry.getDeletedState();
    }
    else if ( !mightBeDirty && loadedState!=null ) {
      values = loadedState;
    }
    else {
      checkId( entity, persister, entry.getId(), entityMode );


      // grab its current state
      values = persister.getPropertyValues( entity, entityMode );


      checkNaturalId( persister, entry, values, loadedState, entityMode, session );
    }
    return values;
  }

View Full Code Here

    final EntityEntry entry = event.getEntityEntry();
    final EventSource session = event.getSession();
    final Object entity = event.getEntity();
    final Status status = entry.getStatus();
    final EntityMode entityMode = session.getEntityMode();
    final EntityPersister persister = entry.getPersister();
    final Object[] values = event.getPropertyValues();
    
    if ( log.isTraceEnabled() ) {
      if ( status == Status.DELETED ) {
        log.trace(

View Full Code Here

  }
  
  protected boolean handleInterception(FlushEntityEvent event) {
    SessionImplementor session = event.getSession();
    EntityEntry entry = event.getEntityEntry();
    EntityPersister persister = entry.getPersister();
    Object entity = event.getEntity();
    
    //give the Interceptor a chance to modify property values
    final Object[] values = event.getPropertyValues();
    final boolean intercepted = invokeInterceptor( session, entity, entry, values, persister );


    //now we might need to recalculate the dirtyProperties array
    if ( intercepted && event.isDirtyCheckPossible() && !event.isDirtyCheckHandledByInterceptor() ) {
      int[] dirtyProperties;
      if ( event.hasDatabaseSnapshot() ) {
        dirtyProperties = persister.findModified( event.getDatabaseSnapshot(), values, entity, session );
      }
      else {
        dirtyProperties = persister.findDirty( values, entry.getLoadedState(), entity, session );
      }
      event.setDirtyProperties(dirtyProperties);
    }
    
    return intercepted;

View Full Code Here

   * Convience method to retreive an entities next version value
   */
  private Object getNextVersion(FlushEntityEvent event) throws HibernateException {
    
    EntityEntry entry = event.getEntityEntry();
    EntityPersister persister = entry.getPersister();
    if ( persister.isVersioned() ) {


      Object[] values = event.getPropertyValues();
        
      if ( entry.isBeingReplicated() ) {
        return Versioning.getVersion(values, persister);
      }
      else {
        int[] dirtyProperties = event.getDirtyProperties();
        
        final boolean isVersionIncrementRequired = isVersionIncrementRequired( 
            event, 
            entry, 
            persister, 
            dirtyProperties 
          );
        
        final Object nextVersion = isVersionIncrementRequired ?
            Versioning.increment( entry.getVersion(), persister.getVersionType(), event.getSession() ) :
            entry.getVersion(); //use the current version
            
        Versioning.setVersion(values, nextVersion, persister);
        
        return nextVersion;

View Full Code Here

   * to synchronize its state to the database. Modifies the event by side-effect!
   * Note: this method is quite slow, avoid calling if possible!
   */
  protected final boolean isUpdateNecessary(FlushEntityEvent event) throws HibernateException {


    EntityPersister persister = event.getEntityEntry().getPersister();
    Status status = event.getEntityEntry().getStatus();
    
    if ( !event.isDirtyCheckPossible() ) {
      return true;
    }

View Full Code Here

    
    final Object entity = event.getEntity();
    final Object[] values = event.getPropertyValues();
    final SessionImplementor session = event.getSession();
    final EntityEntry entry = event.getEntityEntry();
    final EntityPersister persister = entry.getPersister();
    final Serializable id = entry.getId();
    final Object[] loadedState = entry.getLoadedState();


    int[] dirtyProperties = session.getInterceptor().findDirty( 
        entity, 
        id, 
        values, 
        loadedState, 
        persister.getPropertyNames(), 
        persister.getPropertyTypes() 
      );
    
    event.setDatabaseSnapshot(null);


    final boolean interceptorHandledDirtyCheck;
    boolean cannotDirtyCheck;
    
    if ( dirtyProperties==null ) {
      // Interceptor returned null, so do the dirtycheck ourself, if possible
      interceptorHandledDirtyCheck = false;
      
      cannotDirtyCheck = loadedState==null; // object loaded by update()
      if ( !cannotDirtyCheck ) {
        // dirty check against the usual snapshot of the entity
        dirtyProperties = persister.findDirty( values, loadedState, entity, session );
        
      }
      else {
        // dirty check against the database snapshot, if possible/necessary
        final Object[] databaseSnapshot = getDatabaseSnapshot(session, persister, id);
        if ( databaseSnapshot != null ) {
          dirtyProperties = persister.findModified(databaseSnapshot, values, entity, session);
          cannotDirtyCheck = false;
          event.setDatabaseSnapshot(databaseSnapshot);
        }
      }
    }

View Full Code Here

      log.trace( "ignoring persistent instance passed to replicate()" );
      //hum ... should we cascade anyway? throw an exception? fine like it is?
      return;
    }


    EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );


    // get the id from the object
    /*if ( persister.isUnsaved(entity, source) ) {
      throw new TransientObjectException("transient instance passed to replicate()");
    }*/
    Serializable id = persister.getIdentifier( entity, source.getEntityMode() );
    if ( id == null ) {
      throw new TransientObjectException( "instance with null id passed to replicate()" );
    }


    final ReplicationMode replicationMode = event.getReplicationMode();


    final Object oldVersion;
    if ( replicationMode == ReplicationMode.EXCEPTION ) {
      //always do an INSERT, and let it fail by constraint violation
      oldVersion = null;
    }
    else {
      //what is the version on the database?
      oldVersion = persister.getCurrentVersion( id, source );      
    }


    if ( oldVersion != null ) {       
      if ( log.isTraceEnabled() ) {
        log.trace(
            "found existing row for " +
                MessageHelper.infoString( persister, id, source.getFactory() )
        );
      }


      /// HHH-2378
      final Object realOldVersion = persister.isVersioned() ? oldVersion : null;
      
      boolean canReplicate = replicationMode.shouldOverwriteCurrentVersion(
          entity,
          realOldVersion,
          persister.getVersion( entity, source.getEntityMode() ),
          persister.getVersionType()
      );


      if ( canReplicate ) {
        //will result in a SQL UPDATE:
        performReplication( entity, id, realOldVersion, persister, replicationMode, source );
      }
      else {
        //else do nothing (don't even reassociate object!)
        log.trace( "no need to replicate" );
      }


      //TODO: would it be better to do a refresh from db?
    }
    else {
      // no existing row - do an insert
      if ( log.isTraceEnabled() ) {
        log.trace(
            "no existing row, replicating new instance " +
                MessageHelper.infoString( persister, id, source.getFactory() )
        );
      }


      final boolean regenerate = persister.isIdentifierAssignedByInsert(); // prefer re-generation of identity!
      final EntityKey key = regenerate ?
          null : new EntityKey( id, persister, source.getEntityMode() );


      performSaveOrReplicate(
          entity,

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

0 1 2 3 4 5 6 7 8 9

TOP

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

org.hibernate.action.BulkOperationCleanupAction

org.hibernate.action.EntityDeleteAction

org.hibernate.action.EntityIdentityInsertAction

org.hibernate.action.EntityIncrementVersionProcess

org.hibernate.action.EntityInsertAction

org.hibernate.action.EntityUpdateAction

org.hibernate.action.EntityVerifyVersionProcess

org.hibernate.action.internal.BulkOperationCleanupAction

org.hibernate.action.internal.EntityDeleteAction

org.hibernate.action.internal.EntityIdentityInsertAction

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.