Package org.hibernate.event.spi

Examples of org.hibernate.event.spi.EventSource


   */
  protected void flushEverythingToExecutions(FlushEvent event) throws HibernateException {

    LOG.trace( "Flushing session" );

    EventSource session = event.getSession();

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    session.getInterceptor().preFlush( new LazyIterator( persistenceContext.getEntitiesByKey() ) );

    prepareEntityFlushes(session);
    // we could move this inside if we wanted to
    // tolerate collection initializations during
    // collection dirty checking:
View Full Code Here


  @SuppressWarnings( value = {"unchecked"} )
  private void logFlushResults(FlushEvent event) {
    if ( !LOG.isDebugEnabled() ) {
      return;
    }
    final EventSource session = event.getSession();
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    LOG.debugf(
        "Flushed: %s insertions, %s updates, %s deletions to %s objects",
        session.getActionQueue().numberOfInsertions(),
        session.getActionQueue().numberOfUpdates(),
        session.getActionQueue().numberOfDeletions(),
        persistenceContext.getEntityEntries().size()
    );
    LOG.debugf(
        "Flushed: %s (re)creations, %s updates, %s removals to %s collections",
        session.getActionQueue().numberOfCollectionCreations(),
        session.getActionQueue().numberOfCollectionUpdates(),
        session.getActionQueue().numberOfCollectionRemovals(),
        persistenceContext.getCollectionEntries().size()
    );
    new EntityPrinter( session.getFactory() ).toString(
        persistenceContext.getEntitiesByKey().entrySet()
    );
  }
View Full Code Here

    // be loaded.

    // So this needs to be safe from concurrent modification problems.
    // It is safe because of how IdentityMap implements entrySet()

    final EventSource source = event.getSession();

    final Map.Entry[] list = IdentityMap.concurrentEntries( source.getPersistenceContext().getEntityEntries() );
    final int size = list.length;
    for ( int i = 0; i < size; i++ ) {

      // Update the status of the object and if necessary, schedule an update

      Map.Entry me = list[i];
      EntityEntry entry = (EntityEntry) me.getValue();
      Status status = entry.getStatus();

      if ( status != Status.LOADING && status != Status.GONE ) {
        final FlushEntityEvent entityEvent = new FlushEntityEvent( source, me.getKey(), entry );
        final EventListenerGroup<FlushEntityEventListener> listenerGroup = source
            .getFactory()
            .getServiceRegistry()
            .getService( EventListenerRegistry.class )
            .getEventListenerGroup( EventType.FLUSH_ENTITY );
        for ( FlushEntityEventListener listener : listenerGroup.listeners() ) {
          listener.onFlushEntity( entityEvent );
        }
      }
    }

    source.getActionQueue().sortActions();
  }
View Full Code Here

   */
  protected Serializable entityIsTransient(SaveOrUpdateEvent event) {

    LOG.trace( "Saving transient instance" );

    final EventSource source = event.getSession();

    EntityEntry entityEntry = event.getEntry();
    if ( entityEntry != null ) {
      if ( entityEntry.getStatus() == Status.DELETED ) {
        source.forceFlush( entityEntry );
      }
      else {
        throw new AssertionFailure( "entity was persistent" );
      }
    }

    Serializable id = saveWithGeneratedOrRequestedId( event );

    source.getPersistenceContext().reassociateProxy( event.getObject(), id );

    return id;
  }
View Full Code Here

    if ( LOG.isTraceEnabled() ) {
      LOG.tracev( "Updating {0}",
          MessageHelper.infoString( persister, event.getRequestedId(), event.getSession().getFactory() ) );
    }

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

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

    if (invokeUpdateLifecycle(entity, persister, source)) {
            reassociate(event, event.getObject(), event.getRequestedId(), persister);
            return;
        }

    // this is a transient object with existing persistent state not loaded by the session

    new OnUpdateVisitor(source, event.getRequestedId(), entity).process(entity, persister);

    // TODO: put this stuff back in to read snapshot from
        // the second-level cache (needs some extra work)
        /*Object[] cachedState = null;

        if ( persister.hasCache() ) {
          CacheEntry entry = (CacheEntry) persister.getCache()
              .get( event.getRequestedId(), source.getTimestamp() );
            cachedState = entry==null ?
                null :
                entry.getState(); //TODO: half-assemble this stuff
        }*/

    source.getPersistenceContext().addEntity(
        entity,
        (persister.isMutable() ? Status.MANAGED : Status.READ_ONLY),
        null, // cachedState,
        key,
        persister.getVersion( entity ),
        LockMode.NONE,
        true,
        persister,
        false,
        true // assume true, since we don't really know, and it doesn't matter
        );

    persister.afterReassociate(entity, source);

    if ( LOG.isTraceEnabled() ) {
      LOG.tracev( "Updating {0}", MessageHelper.infoString( persister, event.getRequestedId(), source.getFactory() ) );
    }

    cascadeOnUpdate( event, persister, entity );
  }
View Full Code Here

   * @param event The event currently being processed.
   * @param persister The defined persister for the entity being updated.
   * @param entity The entity being updated.
   */
  private void cascadeOnUpdate(SaveOrUpdateEvent event, EntityPersister persister, Object entity) {
    EventSource source = event.getSession();
    source.getPersistenceContext().incrementCascadeLevel();
    try {
      new Cascade( CascadingAction.SAVE_UPDATE, Cascade.AFTER_UPDATE, source )
          .cascade( persister, entity );
    }
    finally {
      source.getPersistenceContext().decrementCascadeLevel();
    }
  }
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(), persister, transientEntities );

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

  }

  private static TransactionManager lookupTransactionManager(SessionFactoryImplementor sessionFactory) {
    final Session session = sessionFactory.openSession();
    try {
      EventSource eventSource = (EventSource)session;
      return eventSource
        .getTransactionCoordinator()
        .getTransactionContext()
        .getTransactionEnvironment()
        .getJtaPlatform()
        .retrieveTransactionManager();
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

   * 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

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.