Package org.hibernate.event.spi

Examples of org.hibernate.event.spi.EventSource


    }
  }

  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

      CacheEntry entry,
      Serializable entityId,
      EntityPersister persister,
      LoadEvent event) {

    final EventSource session = event.getSession();
    final SessionFactoryImplementor factory = session.getFactory();
    final EntityPersister subclassPersister = factory.getEntityPersister( entry.getSubclass() );

    if ( LOG.isTraceEnabled() ) {
      LOG.tracef(
          "Converting second-level cache entry [%s] into entity : %s",
          entry,
          MessageHelper.infoString( persister, entityId, factory )
      );
    }

    final Object entity;
    if ( entry.isReferenceEntry() ) {
      final Object optionalObject = event.getInstanceToLoad();
      if ( optionalObject != null ) {
        throw new HibernateException(
            String.format(
                "Attempt to load entity [%s] from cache using provided object instance, but cache " +
                    "is storing references",
                MessageHelper.infoString( persister, entityId, factory )
            )
        );
      }

      entity = ( (ReferenceCacheEntryImpl) entry ).getReference();
      if ( entity == null ) {
        throw new IllegalStateException(
            "Reference cache entry contained null : " + MessageHelper.infoString( persister, entityId, factory )
        );
      }
    }
    else {
      final Object optionalObject = event.getInstanceToLoad();
      entity = optionalObject == null
          ? session.instantiate( subclassPersister, entityId )
          : optionalObject;
    }

    // make it circular-reference safe
    final EntityKey entityKey = session.generateEntityKey( entityId, subclassPersister );
    TwoPhaseLoad.addUninitializedCachedEntity(
        entityKey,
        entity,
        subclassPersister,
        LockMode.NONE,
        entry.areLazyPropertiesUnfetched(),
        entry.getVersion(),
        session
    );

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final Object[] values;
    final Object version;
    final boolean isReadOnly;
    if ( entry.isReferenceEntry() ) {
      values = null;
      version = null;
      isReadOnly = true;
    }
    else {
      final Type[] types = subclassPersister.getPropertyTypes();
      // initializes the entity by (desired) side-effect
      values = ( (StandardCacheEntryImpl) entry).assemble(
          entity, entityId, subclassPersister, session.getInterceptor(), session
      );
      if ( ( (StandardCacheEntryImpl) entry ).isDeepCopyNeeded() ) {
        TypeHelper.deepCopy(
            values,
            types,
            subclassPersister.getPropertyUpdateability(),
            values,
            session
        );
      }
      version = Versioning.getVersion( values, subclassPersister );
      LOG.tracef( "Cached Version : %s", version );

      final Object proxy = persistenceContext.getProxy( entityKey );
      if ( proxy != null ) {
        // there is already a proxy for this impl
        // only set the status to read-only if the proxy is read-only
        isReadOnly = ( ( HibernateProxy ) proxy ).getHibernateLazyInitializer().isReadOnly();
      }
      else {
        isReadOnly = session.isDefaultReadOnly();
      }
    }

    persistenceContext.addEntry(
        entity,
View Full Code Here

      final Serializable id,
      final EntityPersister persister,
      final LoadEvent event) throws HibernateException {

    final Object optionalObject = event.getInstanceToLoad();
    final EventSource session = event.getSession();
    final SessionFactoryImplementor factory = session.getFactory();

    if ( LOG.isTraceEnabled() ) {
      LOG.tracev( "Assembling entity from second-level cache: {0}",
          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
    final EntityKey entityKey = session.generateEntityKey( id, subclassPersister );
    TwoPhaseLoad.addUninitializedCachedEntity(
        entityKey,
        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
    TypeHelper.deepCopy(
        values,
        types,
        subclassPersister.getPropertyUpdateability(),
        values,
        session
    );

    Object version = Versioning.getVersion( values, subclassPersister );
    LOG.tracev( "Cached Version: {0}", version );

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    boolean isReadOnly = session.isDefaultReadOnly();
    if ( persister.isMutable() ) {
      Object proxy = persistenceContext.getProxy( entityKey );
      if ( proxy != null ) {
        // there is already a proxy for this impl
        // only set the status to read-only if the proxy is read-only
View Full Code Here

   *
   * @throws HibernateException
   */
  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;
      }
      performDetachedEntityDeletionCheck( event );

      id = persister.getIdentifier( entity, source );

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

      final EntityKey key = source.generateEntityKey( id, persister );

      persistenceContext.checkUniqueness( key, entity );

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

      version = persister.getVersion( entity );

      entityEntry = persistenceContext.addEntity(
          entity,
          ( persister.isMutable() ? Status.MANAGED : Status.READ_ONLY ),
          persister.getPropertyValues( entity ),
          key,
          version,
          LockMode.NONE,
          true,
          persister,
          false,
          false
      );
    }
    else {
      LOG.trace( "Deleting a persistent instance" );

      if ( entityEntry.getStatus() == Status.DELETED || entityEntry.getStatus() == Status.GONE ) {
        LOG.trace( "Object was already deleted" );
        return;
      }
      persister = entityEntry.getPersister();
      id = entityEntry.getId();
      version = entityEntry.getVersion();
    }

    /*if ( !persister.isMutable() ) {
      throw new HibernateException(
          "attempted to delete an object of immutable class: " +
          MessageHelper.infoString(persister)
        );
    }*/

    if ( invokeDeleteLifecycle( source, entity, persister ) ) {
      return;
    }

    deleteEntity( source, entity, entityEntry, event.isCascadeDeleteEnabled(),
        event.isOrphanRemovalBeforeUpdates(), persister, transientEntities );

    if ( source.getFactory().getSettings().isIdentifierRollbackEnabled() ) {
      persister.resetIdentifier( entity, id, version, source );
    }
  }
View Full Code Here

    if ( LOG.isTraceEnabled() ) {
      LOG.tracev( "Reassociating transient instance: {0}", MessageHelper.infoString( persister, id, event.getSession().getFactory() ) );
    }

    final EventSource source = event.getSession();
    final EntityKey key = source.generateEntityKey( id, persister );

    source.getPersistenceContext().checkUniqueness( key, object );

    //get a snapshot
    Object[] values = persister.getPropertyValues( object );
    TypeHelper.deepCopy(
        values,
        persister.getPropertyTypes(),
        persister.getPropertyUpdateability(),
        values,
        source
    );
    Object version = Versioning.getVersion( values, persister );

    EntityEntry newEntry = source.getPersistenceContext().addEntity(
        object,
        ( persister.isMutable() ? Status.MANAGED : Status.READ_ONLY ),
        values,
        key,
        version,
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

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.