Open Source Repository

Home /hibernate/hibernate-3.2.4.ga | Repository Home


org/hibernate/engine/ActionQueue.java
// $Id: ActionQueue.java 11403 2007-04-11 14:25:13Z [email protected] $
package org.hibernate.engine;

import org.hibernate.action.EntityInsertAction;
import org.hibernate.action.EntityDeleteAction;
import org.hibernate.action.Executable;
import org.hibernate.action.EntityUpdateAction;
import org.hibernate.action.CollectionRecreateAction;
import org.hibernate.action.CollectionRemoveAction;
import org.hibernate.action.CollectionUpdateAction;
import org.hibernate.action.EntityIdentityInsertAction;
import org.hibernate.action.BulkOperationCleanupAction;
import org.hibernate.HibernateException;
import org.hibernate.AssertionFailure;
import org.hibernate.cache.CacheException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.HashMap;
import java.util.Iterator;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.io.Serializable;
import java.io.ObjectOutputStream;

/**
 * Responsible for maintaining the queue of actions related to events.
 </p>
 * The ActionQueue holds the DML operations queued as part of a session's
 * transactional-write-behind semantics.  DML operations are queued here
 * until a flush forces them to be executed against the database.
 *
 @author Steve Ebersole
 */
public class ActionQueue {

  private static final Log log = LogFactory.getLogActionQueue.class );
  private static final int INIT_QUEUE_LIST_SIZE = 5;

  private SessionImplementor session;

  // Object insertions, updates, and deletions have list semantics because
  // they must happen in the right order so as to respect referential
  // integrity
  private ArrayList insertions;
  private ArrayList deletions;
  private ArrayList updates;
  // Actually the semantics of the next three are really "Bag"
  // Note that, unlike objects, collection insertions, updates,
  // deletions are not really remembered between flushes. We
  // just re-use the same Lists for convenience.
  private ArrayList collectionCreations;
  private ArrayList collectionUpdates;
  private ArrayList collectionRemovals;

  private ArrayList executions;

  /**
   * Constructs an action queue bound to the given session.
   *
   @param session The session "owning" this queue.
   */
  public ActionQueue(SessionImplementor session) {
    this.session = session;
    init();
  }

  private void init() {
    insertions = new ArrayListINIT_QUEUE_LIST_SIZE );
    deletions = new ArrayListINIT_QUEUE_LIST_SIZE );
    updates = new ArrayListINIT_QUEUE_LIST_SIZE );

    collectionCreations = new ArrayListINIT_QUEUE_LIST_SIZE );
    collectionRemovals = new ArrayListINIT_QUEUE_LIST_SIZE );
    collectionUpdates = new ArrayListINIT_QUEUE_LIST_SIZE );

    executions = new ArrayListINIT_QUEUE_LIST_SIZE * );
  }

  public void clear() {
    updates.clear();
    insertions.clear();
    deletions.clear();

    collectionCreations.clear();
    collectionRemovals.clear();
    collectionUpdates.clear();
  }

  public void addAction(EntityInsertAction action) {
    insertions.addaction );
  }

  public void addAction(EntityDeleteAction action) {
    deletions.addaction );
  }

  public void addAction(EntityUpdateAction action) {
    updates.addaction );
  }

  public void addAction(CollectionRecreateAction action) {
    collectionCreations.addaction );
  }

  public void addAction(CollectionRemoveAction action) {
    collectionRemovals.addaction );
  }

  public void addAction(CollectionUpdateAction action) {
    collectionUpdates.addaction );
  }

  public void addAction(EntityIdentityInsertAction insert) {
    insertions.addinsert );
  }

  public void addAction(BulkOperationCleanupAction cleanupAction) {
    // Add these directly to the executions queue
    executions.addcleanupAction );
  }

  /**
   * Perform all currently queued entity-insertion actions.
   *
   @throws HibernateException error executing queued insertion actions.
   */
  public void executeInserts() throws HibernateException {
    executeActionsinsertions );
  }

  /**
   * Perform all currently queued actions.
   *
   @throws HibernateException error executing queued actions.
   */
  public void executeActions() throws HibernateException {
    executeActionsinsertions );
    executeActionsupdates );
    executeActionscollectionRemovals );
    executeActionscollectionUpdates );
    executeActionscollectionCreations );
    executeActionsdeletions );
  }

  /**
   * Prepares the internal action queues for execution.
   *
   @throws HibernateException error preparing actions.
   */
  public void prepareActions() throws HibernateException {
    prepareActionscollectionRemovals );
    prepareActionscollectionUpdates );
    prepareActionscollectionCreations );
  }

  /**
   * Performs cleanup of any held cache softlocks.
   *
   @param success Was the transaction successful.
   */
  public void afterTransactionCompletion(boolean success) {
    int size = executions.size();
    final boolean invalidateQueryCache = session.getFactory().getSettings().isQueryCacheEnabled();
    for int i = 0; i < size; i++ ) {
      try {
        Executable exec = Executable executions.get(i);
        try {
          exec.afterTransactionCompletionsuccess );
        }
        finally {
          if invalidateQueryCache ) {
            session.getFactory().getUpdateTimestampsCache().invalidateexec.getPropertySpaces() );
          }
        }
      }
      catch (CacheException ce) {
        log.error"could not release a cache lock", ce );
        // continue loop
      }
      catch (Exception e) {
        throw new AssertionFailure"Exception releasing cache locks", e );
      }
    }
    executions.clear();
  }

  /**
   * Check whether the given tables/query-spaces are to be executed against
   * given the currently queued actions.
   *
   @param tables The table/query-spaces to check.
   @return True if we contain pending actions against any of the given
   * tables; false otherwise.
   */
  public boolean areTablesToBeUpdated(Set tables) {
    return areTablesToUpdatedupdates, tables ||
           areTablesToUpdatedinsertions, tables ||
           areTablesToUpdateddeletions, tables ||
           areTablesToUpdatedcollectionUpdates, tables ||
           areTablesToUpdatedcollectionCreations, tables ||
           areTablesToUpdatedcollectionRemovals, tables );
  }

  /**
   * Check whether any insertion or deletion actions are currently queued.
   *
   @return True if insertions or deletions are currently queued; false otherwise.
   */
  public boolean areInsertionsOrDeletionsQueued() {
    return insertions.size() || deletions.size() );
  }

  private static boolean areTablesToUpdated(List executables, Set tablespaces) {
    int size = executables.size();
    for int j = 0; j < size; j++ ) {
      Serializable[] spaces = ( (Executableexecutables.get(j) ).getPropertySpaces();
      for int i = 0; i < spaces.length; i++ ) {
        if tablespaces.containsspaces[i] ) ) {
          if log.isDebugEnabled() ) log.debug"changes must be flushed to space: " + spaces[i] );
          return true;
        }
      }
    }
    return false;
  }

  private void executeActions(List listthrows HibernateException {
    int size = list.size();
    for int i = 0; i < size; i++ ) {
      execute( (Executablelist.get(i) );
    }
    list.clear();
    session.getBatcher().executeBatch();
  }

  public void execute(Executable executable) {
    final boolean lockQueryCache = session.getFactory().getSettings().isQueryCacheEnabled();
    if executable.hasAfterTransactionCompletion() || lockQueryCache ) {
      executions.addexecutable );
    }
    if (lockQueryCache) {
      session.getFactory()
        .getUpdateTimestampsCache()
        .preinvalidateexecutable.getPropertySpaces() );
    }
    executable.execute();
  }

  private void prepareActions(List queuethrows HibernateException {
    int size = queue.size();
    for int i=0; i<size; i++ ) {
      Executable executable = Executable queue.get(i);
      executable.beforeExecutions();
    }
  }

  /**
   * Returns a string representation of the object.
   *
   @return a string representation of the object.
   */
  public String toString() {
    return new StringBuffer()
        .append("ActionQueue[insertions=").append(insertions)
        .append(" updates=").append(updates)
            .append(" deletions=").append(deletions)
        .append(" collectionCreations=").append(collectionCreations)
        .append(" collectionRemovals=").append(collectionRemovals)
        .append(" collectionUpdates=").append(collectionUpdates)
            .append("]")
        .toString();
  }

  public int numberOfCollectionRemovals() {
    return collectionRemovals.size();
  }

  public int numberOfCollectionUpdates() {
    return collectionUpdates.size();
  }

  public int numberOfCollectionCreations() {
    return collectionCreations.size();
  }

  public int numberOfDeletions() {
    return deletions.size();
  }

  public int numberOfUpdates() {
    return updates.size();
  }

  public int numberOfInsertions() {
    return insertions.size();
  }

  public void sortCollectionActions() {
    if session.getFactory().getSettings().isOrderUpdatesEnabled() ) {
      //sort the updates by fk
      java.util.Collections.sortcollectionCreations );
      java.util.Collections.sortcollectionUpdates );
      java.util.Collections.sortcollectionRemovals );
    }
  }

  public void sortActions() {
    if session.getFactory().getSettings().isOrderUpdatesEnabled() ) {
      //sort the updates by pk
      java.util.Collections.sortupdates );
    }
    if session.getFactory().getSettings().isOrderInsertsEnabled() ) {
      sortInsertActions();
    }
  }

  /**
   * Order the {@link #insertions} queue such that we group inserts
   * against the same entity together (without violating constraints).  The
   * original order is generated by cascade order, which in turn is based on
   * the directionality of foreign-keys.  So even though we will be changing
   * the ordering here, we need to make absolutely certain that we do not
   * circumvent this FK ordering to the extent of causing constraint
   * violations
   */
  private void sortInsertActions() {
    // IMPLEMENTATION NOTES:
    //
    // The main data structure in this ordering algorithm is the 'positionToAction'
    // map.  Essentially this can be thought of as an put-ordered map (the problem with
    // actually implementing it that way and doing away with the 'nameList' is that
    // we'd end up having potential duplicate key values).  'positionToAction' maitains
    // a mapping from a position within the 'nameList' structure to a "partial queue"
    // of actions.

    HashMap positionToAction = new HashMap();
    List nameList = new ArrayList();

    loopInsertion: while!insertions.isEmpty() ) {
      EntityInsertAction action = EntityInsertAction insertions.remove);
      String thisEntityName = action.getEntityName();

      // see if we have already encountered this entity-name...
      if ! nameList.containsthisEntityName ) ) {
        // we have not, so create the proper entries in nameList and positionToAction
        ArrayList segmentedActionQueue = new ArrayList();
        segmentedActionQueue.addaction );
        nameList.addthisEntityName );
        positionToAction.putnew IntegernameList.indexOfthisEntityName ) ), segmentedActionQueue );
      }
      else {
        // we have seen it before, so we need to determine if this insert action is
        // is depenedent upon a previously processed action in terms of FK
        // relationships (this FK checking is done against the entity's property-state
        // associated with the action...)
        int lastPos = nameList.lastIndexOfthisEntityName );
        Object[] states = action.getState();
        for int i = 0; i < states.length; i++ ) {
          for int j = 0; j < nameList.size(); j++ ) {
            ArrayList tmpList = ArrayList positionToAction.getnew Integer) );
            for int k = 0; k < tmpList.size(); k++ ) {
              final EntityInsertAction checkAction = EntityInsertAction tmpList.get);
              if checkAction.getInstance() == states[i&& j > lastPos ) {
                // 'checkAction' is inserting an entity upon which 'action'
                // depends...
                // note: this is an assumption and may not be correct in the case of one-to-one
                ArrayList segmentedActionQueue = new ArrayList();
                segmentedActionQueue.addaction );
                nameList.addthisEntityName );
                positionToAction.put(new IntegernameList.lastIndexOfthisEntityName ) ), segmentedActionQueue );
                continue loopInsertion;
              }
            }
          }
        }

        ArrayList actionQueue = ArrayList positionToAction.getnew IntegerlastPos ) );
         actionQueue.addaction );
       }
     }

     // now iterate back through positionToAction map and move entityInsertAction back to insertion list
    for int p = 0; p < nameList.size(); p++ ) {
      ArrayList actionQueue = ArrayList positionToAction.getnew Integer) );
      Iterator itr = actionQueue.iterator();
      while itr.hasNext() ) {
        insertions.additr.next() );
      }
    }
  }

  public ArrayList cloneDeletions() {
    return (ArrayListdeletions.clone();
  }

  public void clearFromFlushNeededCheck(int previousCollectionRemovalSize) {
    collectionCreations.clear();
    collectionUpdates.clear();
    updates.clear();
    // collection deletions are a special case since update() can add
    // deletions of collections not loaded by the session.
    for int i = collectionRemovals.size()-1; i >= previousCollectionRemovalSize; i-- ) {
      collectionRemovals.remove(i);
    }
  }

  public boolean hasAnyQueuedActions() {
    return updates.size() ||
           insertions.size() ||
           deletions.size() ||
           collectionUpdates.size() ||
           collectionRemovals.size() ||
           collectionCreations.size() 0;
  }

  /**
   * Used by the owning session to explicitly control serialization of the
   * action queue
   *
   @param oos The stream to which the action queue should get written
   @throws IOException
   */
  public void serialize(ObjectOutputStream oosthrows IOException {
    log.trace"serializing action-queue" );

    int queueSize = insertions.size();
    log.trace"starting serialization of [" + queueSize + "] insertions entries" );
    oos.writeIntqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      oos.writeObjectinsertions.get) );
    }

    queueSize = deletions.size();
    log.trace"starting serialization of [" + queueSize + "] deletions entries" );
    oos.writeIntqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      oos.writeObjectdeletions.get) );
    }

    queueSize = updates.size();
    log.trace"starting serialization of [" + queueSize + "] updates entries" );
    oos.writeIntqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      oos.writeObjectupdates.get) );
    }

    queueSize = collectionUpdates.size();
    log.trace"starting serialization of [" + queueSize + "] collectionUpdates entries" );
    oos.writeIntqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      oos.writeObjectcollectionUpdates.get) );
    }

    queueSize = collectionRemovals.size();
    log.trace"starting serialization of [" + queueSize + "] collectionRemovals entries" );
    oos.writeIntqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      oos.writeObjectcollectionRemovals.get) );
    }

    queueSize = collectionCreations.size();
    log.trace"starting serialization of [" + queueSize + "] collectionCreations entries" );
    oos.writeIntqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      oos.writeObjectcollectionCreations.get) );
    }
  }

  /**
   * Used by the owning session to explicitly control deserialization of the
   * action queue
   *
   @param ois The stream from which to read the action queue
   @throws IOException
   */
  public static ActionQueue deserialize(
      ObjectInputStream ois,
          SessionImplementor sessionthrows IOException, ClassNotFoundException {
    log.trace"deserializing action-queue" );
    ActionQueue rtn = new ActionQueuesession );

    int queueSize = ois.readInt();
    log.trace"starting deserialization of [" + queueSize + "] insertions entries" );
    rtn.insertions = new ArrayListqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      rtn.insertions.addois.readObject() );
    }

    queueSize = ois.readInt();
    log.trace"starting deserialization of [" + queueSize + "] deletions entries" );
    rtn.deletions = new ArrayListqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      rtn.deletions.addois.readObject() );
    }

    queueSize = ois.readInt();
    log.trace"starting deserialization of [" + queueSize + "] updates entries" );
    rtn.updates = new ArrayListqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      rtn.updates.addois.readObject() );
    }

    queueSize = ois.readInt();
    log.trace"starting deserialization of [" + queueSize + "] collectionUpdates entries" );
    rtn.collectionUpdates = new ArrayListqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      rtn.collectionUpdates.addois.readObject() );
    }

    queueSize = ois.readInt();
    log.trace"starting deserialization of [" + queueSize + "] collectionRemovals entries" );
    rtn.collectionRemovals = new ArrayListqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      rtn.collectionRemovals.addois.readObject() );
    }

    queueSize = ois.readInt();
    log.trace"starting deserialization of [" + queueSize + "] collectionCreations entries" );
    rtn.collectionCreations = new ArrayListqueueSize );
    for int i = 0; i < queueSize; i++ ) {
      rtn.collectionCreations.addois.readObject() );
    }
    return rtn;
  }

}