Package org.hibernate.engine.spi

Examples of org.hibernate.engine.spi.EntityEntry


    if ( hydratedObjects != null ) {
      for ( Object hydratedObject : hydratedObjects ) {
        TwoPhaseLoad.postLoad( hydratedObject, session, post );
        if ( afterLoadActions != null ) {
          for ( AfterLoadAction afterLoadAction : afterLoadActions ) {
            final EntityEntry entityEntry = session.getPersistenceContext().getEntry( hydratedObject );
            if ( entityEntry == null ) {
              // big problem
              throw new HibernateException( "Could not locate EntityEntry immediately after two-phase load" );
            }
            afterLoadAction.afterLoad( session, hydratedObject, (Loadable) entityEntry.getPersister() );
          }
        }
      }
    }
  }
View Full Code Here


          persister.getEntityName()
      );
    }

    if ( LockMode.NONE != requestedLockMode && upgradeLocks() ) { //no point doing this if NONE was requested
      final EntityEntry entry = session.getPersistenceContext().getEntry( object );
      if ( entry.getLockMode().lessThan( requestedLockMode ) ) {
        //we only check the version when _upgrading_ lock modes
        if ( persister.isVersioned() ) {
          checkVersion( i, persister, key.getIdentifier(), object, rs, session );
        }
        //we need to upgrade the lock mode to the mode requested
        entry.setLockMode( requestedLockMode );
      }
    }
  }
View Full Code Here

  public Object initializeLazyProperty(String fieldName, Object entity, SessionImplementor session)
      throws HibernateException {

    final Serializable id = session.getContextEntityIdentifier( entity );

    final EntityEntry entry = session.getPersistenceContext().getEntry( entity );
    if ( entry == null ) {
      throw new HibernateException( "entity is not associated with the session: " + id );
    }

    if ( LOG.isTraceEnabled() ) {
View Full Code Here

    final boolean[] tableUpdateNeeded = getTableUpdateNeeded( dirtyFields, hasDirtyCollection );
    final int span = getTableSpan();

    final boolean[] propsToUpdate;
    final String[] updateStrings;
    EntityEntry entry = session.getPersistenceContext().getEntry( object );

    // Ensure that an immutable or non-modifiable entity is not being updated unless it is
    // in the process of being deleted.
    if ( entry == null && ! isMutable() ) {
      throw new IllegalStateException( "Updating immutable entity that is not in session yet!" );
View Full Code Here

      //
      // Note, it potentially could be a proxy, so doAfterTransactionCompletion the location the safe way...
      final EntityKey key = session.generateEntityKey( id, this );
      Object entity = session.getPersistenceContext().getEntity( key );
      if ( entity != null ) {
        EntityEntry entry = session.getPersistenceContext().getEntry( entity );
        loadedState = entry.getLoadedState();
      }
    }

    final String[] deleteStrings;
    if ( isImpliedOptimisticLocking && loadedState != null ) {
View Full Code Here

  @Override
  public void lock(Serializable id, Object version, Object object, int timeout, SessionImplementor session) {
    if ( !lockable.isVersioned() ) {
      throw new HibernateException( "[" + lockMode + "] not supported for non-versioned entities [" + lockable.getEntityName() + "]" );
    }
    final EntityEntry entry = session.getPersistenceContext().getEntry( object );
    final EntityPersister persister = entry.getPersister();
    final Object nextVersion = persister.forceVersionIncrement( entry.getId(), entry.getVersion(), session );
    entry.forceLocked( object, nextVersion );
  }
View Full Code Here

  @Override
  public void lock(Serializable id, Object version, Object object, int timeout, SessionImplementor session) {
    if ( !lockable.isVersioned() ) {
      throw new HibernateException( "[" + lockMode + "] not supported for non-versioned entities [" + lockable.getEntityName() + "]" );
    }
    final EntityEntry entry = session.getPersistenceContext().getEntry( object );
    // Register the EntityIncrementVersionProcess action to run just prior to transaction commit.
    ( (EventSource) session ).getActionQueue().registerProcess( new EntityIncrementVersionProcess( object, entry ) );
  }
View Full Code Here

  @Override
  public void lock(Serializable id, Object version, Object object, int timeout, SessionImplementor session) {
    if ( !lockable.isVersioned() ) {
      throw new OptimisticLockException( object, "[" + lockMode + "] not supported for non-versioned entities [" + lockable.getEntityName() + "]" );
    }
    final EntityEntry entry = session.getPersistenceContext().getEntry( object );
    // Register the EntityVerifyVersionProcess action to run just prior to transaction commit.
    ( (EventSource) session ).getActionQueue().registerProcess( new EntityVerifyVersionProcess( object, entry ) );
  }
View Full Code Here

    //postDelete:
    // After actually deleting a row, record the fact that the instance no longer
    // exists on the database (needed for identity-column key generation), and
    // remove it from the session cache
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    final EntityEntry entry = persistenceContext.removeEntry( instance );
    if ( entry == null ) {
      throw new AssertionFailure( "possible nonthreadsafe access to session" );
    }
    entry.postDelete();

    persistenceContext.removeEntity( entry.getEntityKey() );
    persistenceContext.removeProxy( entry.getEntityKey() );
   
    if ( persister.hasCache() ) {
      persister.getCacheAccessStrategy().remove( ck );
    }
View Full Code Here

   *
   * @throws IllegalArgumentException if {@code managedEntity} did not have managed or read-only status.
   */
  @SuppressWarnings({ "unchecked" })
  public Set<AbstractEntityInsertAction> resolveDependentActions(Object managedEntity, SessionImplementor session) {
    final EntityEntry entityEntry = session.getPersistenceContext().getEntry( managedEntity );
    if ( entityEntry.getStatus() != Status.MANAGED && entityEntry.getStatus() != Status.READ_ONLY ) {
      throw new IllegalArgumentException( "EntityEntry did not have status MANAGED or READ_ONLY: " + entityEntry );
    }

    final boolean traceEnabled = LOG.isTraceEnabled();
    // Find out if there are any unresolved insertions that are waiting for the
    // specified entity to be resolved.
    final Set<AbstractEntityInsertAction> dependentActions = dependentActionsByTransientEntity.remove( managedEntity );
    if ( dependentActions == null ) {
      if ( traceEnabled ) {
        LOG.tracev(
            "No unresolved entity inserts that depended on [{0}]",
            MessageHelper.infoString( entityEntry.getEntityName(), entityEntry.getId() )
        );
      }
      // NOTE EARLY EXIT!
      return Collections.emptySet();
    }
    final Set<AbstractEntityInsertAction> resolvedActions = new IdentitySet(  );
    if ( traceEnabled  ) {
      LOG.tracev(
          "Unresolved inserts before resolving [{0}]: [{1}]",
          MessageHelper.infoString( entityEntry.getEntityName(), entityEntry.getId() ),
          toString()
      );
    }
    for ( AbstractEntityInsertAction dependentAction : dependentActions ) {
      if ( traceEnabled ) {
        LOG.tracev(
            "Resolving insert [{0}] dependency on [{1}]",
            MessageHelper.infoString( dependentAction.getEntityName(), dependentAction.getId() ),
            MessageHelper.infoString( entityEntry.getEntityName(), entityEntry.getId() )
        );
      }
      final NonNullableTransientDependencies dependencies = dependenciesByAction.get( dependentAction );
      dependencies.resolveNonNullableTransientEntity( managedEntity );
      if ( dependencies.isEmpty() ) {
        if ( traceEnabled ) {
          LOG.tracev(
              "Resolving insert [{0}] (only depended on [{1}])",
              dependentAction,
              MessageHelper.infoString( entityEntry.getEntityName(), entityEntry.getId() )
          );
        }
        // dependentAction only depended on managedEntity..
        dependenciesByAction.remove( dependentAction );
        resolvedActions.add( dependentAction );
      }
    }
    if ( traceEnabled  ) {
      LOG.tracev(
          "Unresolved inserts after resolving [{0}]: [{1}]",
          MessageHelper.infoString( entityEntry.getEntityName(), entityEntry.getId() ),
          toString()
      );
    }
    return resolvedActions;
  }
View Full Code Here

TOP

Related Classes of org.hibernate.engine.spi.EntityEntry

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.