Package org.hibernate.event.spi

Examples of org.hibernate.event.spi.EventSource


   * an update action, if necessary
   */
  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 Type[] types = persister.getPropertyTypes();

    final boolean mightBeDirty = entry.requiresDirtyCheck( entity );
View Full Code Here


    }
  }

  private boolean scheduleUpdate(final FlushEntityEvent event) {
    final EntityEntry entry = event.getEntityEntry();
    final EventSource session = event.getSession();
    final Object entity = event.getEntity();
    final Status status = entry.getStatus();
    final EntityPersister persister = entry.getPersister();
    final Object[] values = event.getPropertyValues();

    if ( LOG.isTraceEnabled() ) {
      if ( status == Status.DELETED ) {
        if ( !persister.isMutable() ) {
          LOG.tracev(
              "Updating immutable, deleted entity: {0}",
              MessageHelper.infoString( persister, entry.getId(), session.getFactory() )
          );
        }
        else if ( !entry.isModifiableEntity() ) {
          LOG.tracev(
              "Updating non-modifiable, deleted entity: {0}",
              MessageHelper.infoString( persister, entry.getId(), session.getFactory() )
          );
        }
        else {
          LOG.tracev(
              "Updating deleted entity: ",
              MessageHelper.infoString( persister, entry.getId(), session.getFactory() )
          );
        }
      }
      else {
        LOG.tracev(
            "Updating entity: {0}",
            MessageHelper.infoString( persister, entry.getId(), session.getFactory() )
        );
      }
    }

    final boolean intercepted = !entry.isBeingReplicated() && handleInterception( event );

    // increment the version number (if necessary)
    final Object nextVersion = getNextVersion( event );

    // if it was dirtied by a collection only
    int[] dirtyProperties = event.getDirtyProperties();
    if ( event.isDirtyCheckPossible() && dirtyProperties == null ) {
      if ( !intercepted && !event.hasDirtyCollection() ) {
        throw new AssertionFailure( "dirty, but no dirty properties" );
      }
      dirtyProperties = ArrayHelper.EMPTY_INT_ARRAY;
    }

    // check nullability but do not doAfterTransactionCompletion command execute
    // we'll use scheduled updates for that.
    new Nullability( session ).checkNullability( values, persister, true );

    // schedule the update
    // note that we intentionally do _not_ pass in currentPersistentState!
    session.getActionQueue().addAction(
        new EntityUpdateAction(
            entry.getId(),
            values,
            dirtyProperties,
            event.hasDirtyCollection(),
View Full Code Here

   * @param event The replicate event to be handled.
   *
   * @throws TransientObjectException An invalid attempt to replicate a transient entity.
   */
  public void onReplicate(ReplicateEvent event) {
    final EventSource source = event.getSession();
    if ( source.getPersistenceContext().reassociateIfUninitializedProxy( event.getObject() ) ) {
      LOG.trace( "Uninitialized proxy passed to replicate()" );
      return;
    }

    Object entity = source.getPersistenceContext().unproxyAndReassociate( event.getObject() );

    if ( source.getPersistenceContext().isEntryFor( entity ) ) {
      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 );
    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 );
    }

    final boolean traceEnabled = LOG.isTraceEnabled();
    if ( oldVersion != null ) {
      if ( traceEnabled ) {
        LOG.tracev(
            "Found existing row for {0}", MessageHelper.infoString(
            persister,
            id,
            source.getFactory()
        )
        );
      }

      /// HHH-2378
      final Object realOldVersion = persister.isVersioned() ? oldVersion : null;

      boolean canReplicate = replicationMode.shouldOverwriteCurrentVersion(
          entity,
          realOldVersion,
          persister.getVersion( entity ),
          persister.getVersionType()
      );

      // if can replicate, will result in a SQL UPDATE
      // else do nothing (don't even reassociate object!)
      if ( canReplicate ) {
        performReplication( entity, id, realOldVersion, persister, replicationMode, source );
      }
      else if ( traceEnabled ) {
        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 ( traceEnabled ) {
        LOG.tracev(
            "No existing row, replicating new instance {0}",
            MessageHelper.infoString( persister, id, source.getFactory() )
        );
      }

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

      performSaveOrReplicate(
          entity,
          key,
          persister,
View Full Code Here

   * @throws HibernateException
   */
  public void onMerge(MergeEvent event, Map copiedAlready) throws HibernateException {

    final EventCache copyCache = (EventCache) copiedAlready;
    final EventSource source = event.getSession();
    final Object original = event.getOriginal();

    if ( original != null ) {

      final Object entity;
      if ( original instanceof HibernateProxy ) {
        LazyInitializer li = ( (HibernateProxy) original ).getHibernateLazyInitializer();
        if ( li.isUninitialized() ) {
          LOG.trace( "Ignoring uninitialized proxy" );
          event.setResult( source.load( li.getEntityName(), li.getIdentifier() ) );
          return; //EARLY EXIT!
        }
        else {
          entity = li.getImplementation();
        }
      }
      else {
        entity = original;
      }

      if ( copyCache.containsKey( entity ) &&
          ( copyCache.isOperatedOn( entity ) ) ) {
        LOG.trace( "Already in merge process" );
        event.setResult( entity );
      }
      else {
        if ( copyCache.containsKey( entity ) ) {
          LOG.trace( "Already in copyCache; setting in merge process" );
          copyCache.setOperatedOn( entity, true );
        }
        event.setEntity( entity );
        EntityState entityState = null;

        // Check the persistence context for an entry relating to this
        // entity to be merged...
        EntityEntry entry = source.getPersistenceContext().getEntry( entity );
        if ( entry == null ) {
          EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );
          Serializable id = persister.getIdentifier( entity, source );
          if ( id != null ) {
            final EntityKey key = source.generateEntityKey( id, persister );
            final Object managedEntity = source.getPersistenceContext().getEntity( key );
            entry = source.getPersistenceContext().getEntry( managedEntity );
            if ( entry != null ) {
              // we have specialized case of a detached entity from the
              // perspective of the merge operation.  Specifically, we
              // have an incoming entity instance which has a corresponding
              // entry in the current persistence context, but registered
View Full Code Here

    LOG.trace( "Ignoring persistent instance" );

    //TODO: check that entry.getIdentifier().equals(requestedId)

    final Object entity = event.getEntity();
    final EventSource source = event.getSession();
    final EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );

    ( (EventCache) copyCache ).put( entity, entity, true )//before cascade!

    cascadeOnMerge( source, persister, entity, copyCache );
    copyValues( persister, entity, entity, source, copyCache );
View Full Code Here

  protected void entityIsTransient(MergeEvent event, Map copyCache) {

    LOG.trace( "Merging transient instance" );

    final Object entity = event.getEntity();
    final EventSource source = event.getSession();

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

    final Serializable id = persister.hasIdentifierProperty() ?
        persister.getIdentifier( entity, source ) :
        null;
    if ( copyCache.containsKey( entity ) ) {
      persister.setIdentifier( copyCache.get( entity ), id, source );
    }
    else {
      ( (EventCache) copyCache ).put( entity, source.instantiate( persister, id ), true ); //before cascade!
    }
    final Object copy = copyCache.get( entity );

    // cascade first, so that all unsaved objects get their
    // copy created before we actually copy
View Full Code Here

  protected void entityIsDetached(MergeEvent event, Map copyCache) {

    LOG.trace( "Merging detached instance" );

    final Object entity = event.getEntity();
    final EventSource source = event.getSession();

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

    Serializable id = event.getRequestedId();
    if ( id == null ) {
      id = persister.getIdentifier( entity, source );
    }
    else {
      // check that entity id = requestedId
      Serializable entityId = persister.getIdentifier( entity, source );
      if ( !persister.getIdentifierType().isEqual( id, entityId, source.getFactory() ) ) {
        throw new HibernateException( "merge requested with id not matching id of passed entity" );
      }
    }

    String previousFetchProfile = source.getFetchProfile();
    source.setFetchProfile( "merge" );
    //we must clone embedded composite identifiers, or
    //we will get back the same instance that we pass in
    final Serializable clonedIdentifier = (Serializable) persister.getIdentifierType()
        .deepCopy( id, source.getFactory() );
    final Object result = source.get( entityName, clonedIdentifier );
    source.setFetchProfile( previousFetchProfile );

    if ( result == null ) {
      //TODO: we should throw an exception if we really *know* for sure
      //      that this is a detached instance, rather than just assuming
      //throw new StaleObjectStateException(entityName, id);

      // we got here because we assumed that an instance
      // with an assigned id was detached, when it was
      // really persistent
      entityIsTransient( event, copyCache );
    }
    else {
      ( (EventCache) copyCache ).put( entity, result, true ); //before cascade!

      final Object target = source.getPersistenceContext().unproxy( result );
      if ( target == entity ) {
        throw new AssertionFailure( "entity was not detached" );
      }
      else if ( !source.getEntityName( target ).equals( entityName ) ) {
        throw new WrongClassException(
            "class of the given object did not match class of persistent copy",
            event.getRequestedId(),
            entityName
        );
      }
      else if ( isVersionChanged( entity, source, persister, target ) ) {
        if ( source.getFactory().getStatistics().isStatisticsEnabled() ) {
          source.getFactory().getStatisticsImplementor()
              .optimisticFailure( entityName );
        }
        throw new StaleObjectStateException( entityName, id );
      }

View Full Code Here

    upgradeLock( entity, entry, event.getLockOptions(), event.getSession() );
  }
 
  private void cascadeOnLock(LockEvent event, EntityPersister persister, Object entity) {
    EventSource source = event.getSession();
    source.getPersistenceContext().incrementCascadeLevel();
    try {
      new Cascade( CascadingActions.LOCK, CascadePoint.AFTER_LOCK, source).cascade(
          persister,
          entity,
          event.getLockOptions()
      );
    }
    finally {
      source.getPersistenceContext().decrementCascadeLevel();
    }
  }
View Full Code Here

  public Object processCollection(Object collection, CollectionType type) throws HibernateException {
    if ( collection == CollectionType.UNFETCHED_COLLECTION ) {
      return null;
    }

    final EventSource session = getSession();
    final CollectionPersister persister = session.getFactory().getCollectionPersister( type.getRole() );

    if ( isUpdate ) {
      removeCollection( persister, extractCollectionKeyFromOwner( persister ), session );
    }
    if ( collection != null && collection instanceof PersistentCollection ) {
      final PersistentCollection wrapper = (PersistentCollection) collection;
      wrapper.setCurrentSession( session );
      if ( wrapper.wasInitialized() ) {
        session.getPersistenceContext().addNewCollection( persister, wrapper );
      }
      else {
        reattachCollection( wrapper, type );
      }
    }
View Full Code Here

  }

  @SuppressWarnings({"unchecked"})
  protected void entityIsPersistent(PersistEvent event, Map createCache) {
    LOG.trace( "Ignoring persistent instance" );
    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 ) {
      justCascade( createCache, source, entity, persister );

    }
View Full Code Here

TOP

Related Classes of org.hibernate.event.spi.EventSource

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.