* Hibernate, Relational Persistence for Idiomatic Java

*

* Copyright (c) 2005-2011, Red Hat Inc. or third-party contributors as

* indicated by the @author tags or express copyright attribution

* statements applied by the authors.  All third-party contributions are

* distributed under license by Red Hat Inc.

*

* This copyrighted material is made available to anyone wishing to use, modify,

* copy, or redistribute it subject to the terms and conditions of the GNU

* Lesser General Public License, as published by the Free Software Foundation.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

* or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License

* for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this distribution; if not, write to:

* Free Software Foundation, Inc.

* 51 Franklin Street, Fifth Floor

* Boston, MA  02110-1301  USA

*/

* Concrete implementation of a Session.

*

* Exposes two interfaces:<ul>

*     <li>{@link Session} to the application</li>

*     <li>{@link org.hibernate.engine.spi.SessionImplementor} to other Hibernate components (SPI)</li>

* </ul>

*

* This class is not thread-safe.

*

* @author Gavin King

*/

  // todo : need to find a clean way to handle the "event source" role

  // a separate class responsible for generating/dispatching events just duplicates most of the Session methods...

  // passing around separate interceptor, factory, actionQueue, and persistentContext is not manageable...

  private static final CoreMessageLogger LOG = Logger.getMessageLogger(CoreMessageLogger.class, SessionImpl.class.getName());

  private transient long timestamp;

  private transient ActionQueue actionQueue;

  private transient StatefulPersistenceContext persistenceContext;

  private transient TransactionCoordinatorImpl transactionCoordinator;

  private transient Interceptor interceptor;

  private transient EntityNameResolver entityNameResolver = new CoordinatingEntityNameResolver();

  private transient ConnectionReleaseMode connectionReleaseMode;

  private transient FlushMode flushMode = FlushMode.AUTO;

  private transient CacheMode cacheMode = CacheMode.NORMAL;

  private transient boolean autoClear; //for EJB3

  private transient boolean autoJoinTransactions = true;

  private transient boolean flushBeforeCompletionEnabled;

  private transient boolean autoCloseSessionEnabled;

  private transient int dontFlushFromFind = 0;

  private transient LoadQueryInfluencers loadQueryInfluencers;

  /**

   * Constructor used for openSession(...) processing, as well as construction

   * of sessions for getCurrentSession().

   *

   * @param connection The user-supplied connection to use for this session.

   * @param factory The factory from which this session was obtained

   * @param transactionCoordinator The transaction coordinator to use, may be null to indicate that a new transaction

   * coordinator should get created.

   * @param autoJoinTransactions Should the session automatically join JTA transactions?

   * @param timestamp The timestamp for this session

   * @param interceptor The interceptor to be applied to this session

   * @param flushBeforeCompletionEnabled Should we auto flush before completion of transaction

   * @param autoCloseSessionEnabled Should we auto close after completion of transaction

   * @param connectionReleaseMode The mode by which we should release JDBC connections.

   * @param tenantIdentifier The tenant identifier to use.  May be null

   */

  SessionImpl(

      final Connection connection,

      final SessionFactoryImpl factory,

      final TransactionCoordinatorImpl transactionCoordinator,

      final boolean autoJoinTransactions,

      final long timestamp,

      final Interceptor interceptor,

      final boolean flushBeforeCompletionEnabled,

      final boolean autoCloseSessionEnabled,

      final ConnectionReleaseMode connectionReleaseMode,

      final String tenantIdentifier) {

    super( factory, tenantIdentifier );

    this.timestamp = timestamp;

    this.interceptor = interceptor == null ? EmptyInterceptor.INSTANCE : interceptor;

    this.actionQueue = new ActionQueue( this );

    this.persistenceContext = new StatefulPersistenceContext( this );

    this.flushBeforeCompletionEnabled = flushBeforeCompletionEnabled;

    this.autoCloseSessionEnabled = autoCloseSessionEnabled;

    this.connectionReleaseMode = connectionReleaseMode;

    this.autoJoinTransactions = autoJoinTransactions;

    if ( transactionCoordinator == null ) {

      this.transactionCoordinator = new TransactionCoordinatorImpl( connection, this );

      this.transactionCoordinator.getJdbcCoordinator().getLogicalConnection().addObserver(

          new ConnectionObserverStatsBridge( factory )

      );

    }

    else {

      if ( connection != null ) {

        throw new SessionException( "Cannot simultaneously share transaction context and specify connection" );

      }

      this.transactionCoordinator = transactionCoordinator;

    }

    loadQueryInfluencers = new LoadQueryInfluencers( factory );

    if (factory.getStatistics().isStatisticsEnabled()) factory.getStatisticsImplementor().openSession();

    LOG.debugf( "Opened session at timestamp: %s", timestamp );

  }

  @Override

  public SharedSessionBuilder sessionWithOptions() {

    return new SharedSessionBuilderImpl( this );

  }

  public void clear() {

    errorIfClosed();

    checkTransactionSynchStatus();

    persistenceContext.clear();

    actionQueue.clear();

  }

  public long getTimestamp() {

    checkTransactionSynchStatus();

    return timestamp;

  }

  public Connection close() throws HibernateException {

    LOG.trace( "Closing session" );

    if ( isClosed() ) {

      throw new SessionException( "Session was already closed" );

    }

    if ( factory.getStatistics().isStatisticsEnabled() ) {

      factory.getStatisticsImplementor().closeSession();

    }

    try {

      return transactionCoordinator.close();

    }

    finally {

      setClosed();

      cleanup();

    }

  }

  public ConnectionReleaseMode getConnectionReleaseMode() {

    return connectionReleaseMode;

  }

  @Override

  public boolean shouldAutoJoinTransaction() {

    return autoJoinTransactions;

  }

  public boolean isAutoCloseSessionEnabled() {

    return autoCloseSessionEnabled;

  }

  public boolean isOpen() {

    checkTransactionSynchStatus();

    return !isClosed();

  }

  public boolean isFlushModeNever() {

    return FlushMode.isManualFlushMode( getFlushMode() );

  }

  public boolean isFlushBeforeCompletionEnabled() {

    return flushBeforeCompletionEnabled;

  }

  public void managedFlush() {

    if ( isClosed() ) {

      LOG.trace( "Skipping auto-flush due to session closed" );

      return;

    }

    LOG.trace( "Automatically flushing session" );

    flush();

  }

  /**

   * Return changes to this session and its child sessions that have not been flushed yet.

   * <p/>

   * @return The non-flushed changes.

   */

  public NonFlushedChanges getNonFlushedChanges() throws HibernateException {

    errorIfClosed();

    checkTransactionSynchStatus();

    return new NonFlushedChangesImpl( this );

  }

  /**

   * Apply non-flushed changes from a different session to this session. It is assumed

   * that this SessionImpl is "clean" (e.g., has no non-flushed changes, no cached entities,

   * no cached collections, no queued actions). The specified NonFlushedChanges object cannot

   * be bound to any session.

   * <p/>

   * @param nonFlushedChanges the non-flushed changes

   */

  public void applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges) throws HibernateException {

    errorIfClosed();

    checkTransactionSynchStatus();

    // todo : why aren't these just part of the NonFlushedChanges API ?

    replacePersistenceContext( ( ( NonFlushedChangesImpl ) nonFlushedChanges ).getPersistenceContext() );

    replaceActionQueue( ( ( NonFlushedChangesImpl ) nonFlushedChanges ).getActionQueue() );

  }

  private void replacePersistenceContext(StatefulPersistenceContext persistenceContextNew) {

    if ( persistenceContextNew.getSession() != null ) {

      throw new IllegalStateException( "new persistence context is already connected to a session " );

    }

    persistenceContext.clear();

    ObjectInputStream ois = null;

    try {

      ois = new ObjectInputStream( new ByteArrayInputStream( serializePersistenceContext( persistenceContextNew ) ) );

      this.persistenceContext = StatefulPersistenceContext.deserialize( ois, this );

    }

    catch (IOException ex) {

      throw new SerializationException( "could not deserialize the persistence context",  ex );

    }

    catch (ClassNotFoundException ex) {

      throw new SerializationException( "could not deserialize the persistence context", ex );

    }

    finally {

      try {

        if (ois != null) ois.close();

      }

      catch (IOException ex) {}

    }

  }

  private static byte[] serializePersistenceContext(StatefulPersistenceContext pc) {

    ByteArrayOutputStream baos = new ByteArrayOutputStream( 512 );

    ObjectOutputStream oos = null;

    try {

      oos = new ObjectOutputStream( baos );

      ( pc ).serialize( oos );

    }

    catch (IOException ex) {

      throw new SerializationException( "could not serialize persistence context", ex );

    }

    finally {

      if ( oos != null ) {

        try {

          oos.close();

        }

        catch( IOException ex ) {

          //ignore

        }

      }

    }

    return baos.toByteArray();

  }

  private void replaceActionQueue(ActionQueue actionQueueNew) {

    if ( actionQueue.hasAnyQueuedActions() ) {

      throw new IllegalStateException( "cannot replace an ActionQueue with queued actions " );

    }

    actionQueue.clear();

    ObjectInputStream ois = null;

    try {

      ois = new ObjectInputStream( new ByteArrayInputStream( serializeActionQueue( actionQueueNew ) ) );

      actionQueue = ActionQueue.deserialize( ois, this );

    }

    catch (IOException ex) {

      throw new SerializationException( "could not deserialize the action queue",  ex );

    }

    catch (ClassNotFoundException ex) {

      throw new SerializationException( "could not deserialize the action queue", ex );

    }

    finally {

      try {

        if (ois != null) ois.close();

      }

      catch (IOException ex) {}

    }

  }

  private static byte[] serializeActionQueue(ActionQueue actionQueue) {

    ByteArrayOutputStream baos = new ByteArrayOutputStream( 512 );

    ObjectOutputStream oos = null;

    try {

      oos = new ObjectOutputStream( baos );

      actionQueue.serialize( oos );

    }

    catch (IOException ex) {

      throw new SerializationException( "could not serialize action queue", ex );

    }

    finally {

      if ( oos != null ) {

        try {

          oos.close();

        }

        catch( IOException ex ) {

          //ignore

        }

      }

    }

    return baos.toByteArray();

  }

  public boolean shouldAutoClose() {

    return isAutoCloseSessionEnabled() && !isClosed();

  }

  public void managedClose() {

    LOG.trace( "Automatically closing session" );

    close();

  }

  public Connection connection() throws HibernateException {

    errorIfClosed();

    return transactionCoordinator.getJdbcCoordinator().getLogicalConnection().getDistinctConnectionProxy();

  }

  public boolean isConnected() {

    checkTransactionSynchStatus();

    return !isClosed() && transactionCoordinator.getJdbcCoordinator().getLogicalConnection().isOpen();

  }

  public boolean isTransactionInProgress() {

    checkTransactionSynchStatus();

    return !isClosed() && transactionCoordinator.isTransactionInProgress();

  }

  @Override

  public Connection disconnect() throws HibernateException {

    errorIfClosed();

    LOG.debug( "Disconnecting session" );

    return transactionCoordinator.getJdbcCoordinator().getLogicalConnection().manualDisconnect();

  }

  @Override

  public void reconnect(Connection conn) throws HibernateException {

    errorIfClosed();

    LOG.debug( "Reconnecting session" );

    checkTransactionSynchStatus();

    transactionCoordinator.getJdbcCoordinator().getLogicalConnection().manualReconnect( conn );

  }

  public void setAutoClear(boolean enabled) {

    errorIfClosed();

    autoClear = enabled;

  }

  @Override

  public void disableTransactionAutoJoin() {

    errorIfClosed();

    autoJoinTransactions = false;

  }

  /**

   * Check if there is a Hibernate or JTA transaction in progress and,

   * if there is not, flush if necessary, make sure the connection has

   * been committed (if it is not in autocommit mode) and run the after

   * completion processing

   */

  public void afterOperation(boolean success) {

    if ( ! transactionCoordinator.isTransactionInProgress() ) {

      transactionCoordinator.afterNonTransactionalQuery( success );

    }

  }

  @Override

  public void afterTransactionBegin(TransactionImplementor hibernateTransaction) {

    errorIfClosed();

    interceptor.afterTransactionBegin( hibernateTransaction );

  }

  @Override

  public void beforeTransactionCompletion(TransactionImplementor hibernateTransaction) {

    LOG.trace( "before transaction completion" );

    actionQueue.beforeTransactionCompletion();

    try {

      interceptor.beforeTransactionCompletion( hibernateTransaction );

    }

    catch (Throwable t) {

      LOG.exceptionInBeforeTransactionCompletionInterceptor( t );

    }

  }

  @Override

  public void afterTransactionCompletion(TransactionImplementor hibernateTransaction, boolean successful) {

    LOG.trace( "after transaction completion" );

    persistenceContext.afterTransactionCompletion();

    actionQueue.afterTransactionCompletion( successful );

    if ( hibernateTransaction != null ) {

      try {

        interceptor.afterTransactionCompletion( hibernateTransaction );

      }

      catch (Throwable t) {

        LOG.exceptionInAfterTransactionCompletionInterceptor( t );

      }

    }

    if ( autoClear ) {

      clear();

    }

  }

  @Override

  public String onPrepareStatement(String sql) {

    errorIfClosed();

    sql = interceptor.onPrepareStatement( sql );

    if ( sql == null || sql.length() == 0 ) {

      throw new AssertionFailure( "Interceptor.onPrepareStatement() returned null or empty string." );

    }

    return sql;

  }

  /**

   * clear all the internal collections, just

   * to help the garbage collector, does not

   * clear anything that is needed during the

   * afterTransactionCompletion() phase

   */

  private void cleanup() {

    persistenceContext.clear();

  }

  public LockMode getCurrentLockMode(Object object) throws HibernateException {

    errorIfClosed();

    checkTransactionSynchStatus();

    if ( object == null ) {

      throw new NullPointerException( "null object passed to getCurrentLockMode()" );

    }

    if ( object instanceof HibernateProxy ) {

      object = ( (HibernateProxy) object ).getHibernateLazyInitializer().getImplementation(this);

      if ( object == null ) {

        return LockMode.NONE;

      }

    }

    EntityEntry e = persistenceContext.getEntry(object);

    if ( e == null ) {

      throw new TransientObjectException( "Given object not associated with the session" );

    }

    if ( e.getStatus() != Status.MANAGED ) {

      throw new ObjectDeletedException(

          "The given object was deleted",

          e.getId(),

          e.getPersister().getEntityName()

        );

    }

    return e.getLockMode();

  }

  public Object getEntityUsingInterceptor(EntityKey key) throws HibernateException {

    errorIfClosed();

    // todo : should this get moved to PersistentContext?

    // logically, is PersistentContext the "thing" to which an interceptor gets attached?

    final Object result = persistenceContext.getEntity(key);

    if ( result == null ) {

      final Object newObject = interceptor.getEntity( key.getEntityName(), key.getIdentifier() );

      if ( newObject != null ) {

        lock( newObject, LockMode.NONE );

      }

      return newObject;

    }

    else {

      return result;

    }

  }

  // saveOrUpdate() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public void saveOrUpdate(Object object) throws HibernateException {

    saveOrUpdate( null, object );

  }

  public void saveOrUpdate(String entityName, Object obj) throws HibernateException {

    fireSaveOrUpdate( new SaveOrUpdateEvent( entityName, obj, this ) );

  }

  private void fireSaveOrUpdate(SaveOrUpdateEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( SaveOrUpdateEventListener listener : listeners( EventType.SAVE_UPDATE ) ) {

      listener.onSaveOrUpdate( event );

    }

  }

  private <T> Iterable<T> listeners(EventType<T> type) {

    return eventListenerGroup( type ).listeners();

  }

  private <T> EventListenerGroup<T> eventListenerGroup(EventType<T> type) {

    return factory.getServiceRegistry().getService( EventListenerRegistry.class ).getEventListenerGroup( type );

  }

  // save() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public Serializable save(Object obj) throws HibernateException {

    return save( null, obj );

  }

  public Serializable save(String entityName, Object object) throws HibernateException {

    return fireSave( new SaveOrUpdateEvent( entityName, object, this ) );

  }

  private Serializable fireSave(SaveOrUpdateEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( SaveOrUpdateEventListener listener : listeners( EventType.SAVE ) ) {

      listener.onSaveOrUpdate( event );

    }

    return event.getResultId();

  }

  // update() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public void update(Object obj) throws HibernateException {

    update(null, obj);

  }

  public void update(String entityName, Object object) throws HibernateException {

    fireUpdate( new SaveOrUpdateEvent( entityName, object, this ) );

  }

  private void fireUpdate(SaveOrUpdateEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( SaveOrUpdateEventListener listener : listeners( EventType.UPDATE ) ) {

      listener.onSaveOrUpdate( event );

    }

  }

  // lock() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public void lock(String entityName, Object object, LockMode lockMode) throws HibernateException {

    fireLock( new LockEvent( entityName, object, lockMode, this ) );

  }

  public LockRequest buildLockRequest(LockOptions lockOptions) {

    return new LockRequestImpl(lockOptions);

  }

  public void lock(Object object, LockMode lockMode) throws HibernateException {

    fireLock( new LockEvent(object, lockMode, this) );

  }

  private void fireLock(String entityName, Object object, LockOptions options) {

    fireLock( new LockEvent( entityName, object, options, this) );

  }

  private void fireLock( Object object, LockOptions options) {

    fireLock( new LockEvent( object, options, this ) );

  }

  private void fireLock(LockEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( LockEventListener listener : listeners( EventType.LOCK ) ) {

      listener.onLock( event );

    }

  }

  // persist() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public void persist(String entityName, Object object) throws HibernateException {

    firePersist( new PersistEvent( entityName, object, this ) );

  }

  public void persist(Object object) throws HibernateException {

    persist( null, object );

  }

  public void persist(String entityName, Object object, Map copiedAlready)

  throws HibernateException {

    firePersist( copiedAlready, new PersistEvent( entityName, object, this ) );

  }

  private void firePersist(Map copiedAlready, PersistEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( PersistEventListener listener : listeners( EventType.PERSIST ) ) {

      listener.onPersist( event, copiedAlready );

    }

  }

  private void firePersist(PersistEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( PersistEventListener listener : listeners( EventType.PERSIST ) ) {

      listener.onPersist( event );

    }

  }

  // persistOnFlush() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public void persistOnFlush(String entityName, Object object)

      throws HibernateException {

    firePersistOnFlush( new PersistEvent( entityName, object, this ) );

  }

  public void persistOnFlush(Object object) throws HibernateException {

    persist( null, object );

  }

  public void persistOnFlush(String entityName, Object object, Map copiedAlready)

      throws HibernateException {

    firePersistOnFlush( copiedAlready, new PersistEvent( entityName, object, this ) );

  }

  private void firePersistOnFlush(Map copiedAlready, PersistEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( PersistEventListener listener : listeners( EventType.PERSIST_ONFLUSH ) ) {

      listener.onPersist( event, copiedAlready );

    }

  }

  private void firePersistOnFlush(PersistEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( PersistEventListener listener : listeners( EventType.PERSIST_ONFLUSH ) ) {

      listener.onPersist( event );

    }

  }

  // merge() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public Object merge(String entityName, Object object) throws HibernateException {

    return fireMerge( new MergeEvent( entityName, object, this ) );

  }

  public Object merge(Object object) throws HibernateException {

    return merge( null, object );

  }

  public void merge(String entityName, Object object, Map copiedAlready) throws HibernateException {

    fireMerge( copiedAlready, new MergeEvent( entityName, object, this ) );

  }

  private Object fireMerge(MergeEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( MergeEventListener listener : listeners( EventType.MERGE ) ) {

      listener.onMerge( event );

    }

    return event.getResult();

  }

  private void fireMerge(Map copiedAlready, MergeEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( MergeEventListener listener : listeners( EventType.MERGE ) ) {

      listener.onMerge( event, copiedAlready );

    }

  }

  // delete() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  /**

   * Delete a persistent object

   */

  public void delete(Object object) throws HibernateException {

    fireDelete( new DeleteEvent( object, this ) );

  }

  /**

   * Delete a persistent object (by explicit entity name)

   */

  public void delete(String entityName, Object object) throws HibernateException {

    fireDelete( new DeleteEvent( entityName, object, this ) );

  }

  /**

   * Delete a persistent object

   */

  public void delete(String entityName, Object object, boolean isCascadeDeleteEnabled, Set transientEntities) throws HibernateException {

    fireDelete( new DeleteEvent( entityName, object, isCascadeDeleteEnabled, this ), transientEntities );

  }

  private void fireDelete(DeleteEvent event) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( DeleteEventListener listener : listeners( EventType.DELETE ) ) {

      listener.onDelete( event );

    }

  }

  private void fireDelete(DeleteEvent event, Set transientEntities) {

    errorIfClosed();

    checkTransactionSynchStatus();

    for ( DeleteEventListener listener : listeners( EventType.DELETE ) ) {

      listener.onDelete( event, transientEntities );

    }

  }

  // load()/get() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public void load(Object object, Serializable id) throws HibernateException {

    LoadEvent event = new LoadEvent(id, object, this);

    fireLoad( event, LoadEventListener.RELOAD );

  }

  public Object load(Class entityClass, Serializable id) throws HibernateException {

    return load( entityClass.getName(), id );

  }

  public Object load(String entityName, Serializable id) throws HibernateException {

    LoadEvent event = new LoadEvent(id, entityName, false, this);

    boolean success = false;

    try {

      fireLoad( event, LoadEventListener.LOAD );

      if ( event.getResult() == null ) {

        getFactory().getEntityNotFoundDelegate().handleEntityNotFound( entityName, id );

      }

      success = true;

      return event.getResult();

    }

    finally {

      afterOperation(success);

    }

  }

  public Object get(Class entityClass, Serializable id) throws HibernateException {

    return get( entityClass.getName(), id );

  }

  public Object get(String entityName, Serializable id) throws HibernateException {

    LoadEvent event = new LoadEvent(id, entityName, false, this);

    boolean success = false;

    try {

      fireLoad(event, LoadEventListener.GET);

      success = true;

      return event.getResult();

    }

    finally {

      afterOperation(success);

    }

  }

  /**

   * Load the data for the object with the specified id into a newly created object.

   * This is only called when lazily initializing a proxy.

   * Do NOT return a proxy.

   */

  public Object immediateLoad(String entityName, Serializable id) throws HibernateException {

    if ( LOG.isDebugEnabled() ) {

      EntityPersister persister = getFactory().getEntityPersister(entityName);

      LOG.debugf( "Initializing proxy: %s", MessageHelper.infoString( persister, id, getFactory() ) );

    }

    LoadEvent event = new LoadEvent(id, entityName, true, this);

    fireLoad(event, LoadEventListener.IMMEDIATE_LOAD);

    return event.getResult();

  }

  public Object internalLoad(String entityName, Serializable id, boolean eager, boolean nullable) throws HibernateException {

    // todo : remove

    LoadEventListener.LoadType type = nullable

        ? LoadEventListener.INTERNAL_LOAD_NULLABLE

        : eager

            ? LoadEventListener.INTERNAL_LOAD_EAGER

            : LoadEventListener.INTERNAL_LOAD_LAZY;

    LoadEvent event = new LoadEvent(id, entityName, true, this);

    fireLoad(event, type);

    if ( !nullable ) {

      UnresolvableObjectException.throwIfNull( event.getResult(), id, entityName );

    }

    return event.getResult();

  }

  public Object load(Class entityClass, Serializable id, LockMode lockMode) throws HibernateException {

    return load( entityClass.getName(), id, lockMode );

  }

  public Object load(Class entityClass, Serializable id, LockOptions lockOptions) throws HibernateException {

    return load( entityClass.getName(), id, lockOptions );

  }

  public Object load(String entityName, Serializable id, LockMode lockMode) throws HibernateException {

    LoadEvent event = new LoadEvent(id, entityName, lockMode, this);

    fireLoad( event, LoadEventListener.LOAD );

    return event.getResult();

  }

  public Object load(String entityName, Serializable id, LockOptions lockOptions) throws HibernateException {

    LoadEvent event = new LoadEvent(id, entityName, lockOptions, this);

    fireLoad( event, LoadEventListener.LOAD );

    return event.getResult();

  }

  public Object get(Class entityClass, Serializable id, LockMode lockMode) throws HibernateException {

    return get( entityClass.getName(), id, lockMode );

  }

  public Object get(Class entityClass, Serializable id, LockOptions lockOptions) throws HibernateException {

    return get( entityClass.getName(), id, lockOptions );

  }

  public Object get(String entityName, Serializable id, LockMode lockMode) throws HibernateException {

    LoadEvent event = new LoadEvent(id, entityName, lockMode, this);

       fireLoad(event, LoadEventListener.GET);

    return event.getResult();

  }