Package org.hibernate.event.spi

Examples of org.hibernate.event.spi.EventSource


   * @param event
   *            The auto-flush event to be handled.
   * @throws HibernateException
   */
  public void onAutoFlush(AutoFlushEvent event) throws HibernateException {
    final EventSource source = event.getSession();
    if ( flushMightBeNeeded(source) ) {
      final int oldSize = source.getActionQueue().numberOfCollectionRemovals();
      flushEverythingToExecutions(event);
      if ( flushIsReallyNeeded(event, source) ) {
        LOG.trace( "Need to execute flush" );

        performExecutions(source);
        postFlush(source);
        // note: performExecutions() clears all collectionXxxxtion
        // collections (the collection actions) in the session

        if ( source.getFactory().getStatistics().isStatisticsEnabled() ) {
          source.getFactory().getStatisticsImplementor().flush();
        }
      }
      else {
        LOG.trace( "Don't need to execute flush" );
        source.getActionQueue().clearFromFlushNeededCheck( oldSize );
      }

      event.setFlushRequired( flushIsReallyNeeded( event, source ) );
    }
  }
View Full Code Here


   * 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

  }

  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 ) {
      //TODO: merge into one method!
      cascadeBeforeSave(source, persister, entity, createCache);
      cascadeAfterSave(source, persister, entity, createCache);
View Full Code Here

   */
  protected void entityIsTransient(PersistEvent event, Map createCache) throws HibernateException {

    LOG.trace( "Saving transient instance" );

    final EventSource source = event.getSession();

    final Object entity = source.getPersistenceContext().unproxy( event.getObject() );

    if ( createCache.put(entity, entity)==null ) {
      saveWithGeneratedId( entity, event.getEntityName(), createCache, source, false );
    }

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 EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );
    final String entityName = persister.getEntityName();

    event.setResult( mergeTransientEntity( entity, entityName, event.getRequestedId(), source, copyCache, true ) );
  }
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

      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

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.