HHH-8083 @OrderColumn not updated on @onetomany cascade

Conflicts:
	hibernate-core/src/main/java/org/hibernate/action/internal/CollectionUpdateAction.java

Author: brmeyer

hibernate-core/src/main/java/org/hibernate/action/internal/QueuedOperationCollectionAction.java

@@ -0,0 +1,74 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008-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
+ */
+package org.hibernate.action.internal;
+
+import java.io.Serializable;
+
+import org.hibernate.HibernateException;
+import org.hibernate.collection.spi.PersistentCollection;
+import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.persister.collection.CollectionPersister;
+
+/**
+ * If a collection is extra lazy and has queued ops, we still need to
+ * process them.  Ex: OneToManyPersister needs to insert indexes for List
+ * collections.  See HHH-8083.
+ * 
+ * @author Brett Meyer
+ */
+public final class QueuedOperationCollectionAction extends CollectionAction {
+	
+	/**
+	 * Constructs a CollectionUpdateAction
+	 *
+	 * @param collection The collection to update
+	 * @param persister The collection persister
+	 * @param id The collection key
+	 * @param session The session
+	 */
+	public QueuedOperationCollectionAction(
+				final PersistentCollection collection,
+				final CollectionPersister persister,
+				final Serializable id,
+				final SessionImplementor session) {
+		super( persister, collection, id, session );
+	}
+
+	@Override
+	public void execute() throws HibernateException {
+		final Serializable id = getKey();
+		final SessionImplementor session = getSession();
+		final CollectionPersister persister = getPersister();
+		final PersistentCollection collection = getCollection();
+
+		persister.processQueuedOps( collection, id, session );
+	}
+}
+
+
+
+
+
+
+

hibernate-core/src/main/java/org/hibernate/engine/spi/ActionQueue.java

@@ -52,6 +52,7 @@
 import org.hibernate.action.internal.EntityIdentityInsertAction;
 import org.hibernate.action.internal.EntityInsertAction;
 import org.hibernate.action.internal.EntityUpdateAction;
+import org.hibernate.action.internal.QueuedOperationCollectionAction;
 import org.hibernate.action.internal.UnresolvedEntityInsertActions;
 import org.hibernate.action.spi.AfterTransactionCompletionProcess;
 import org.hibernate.action.spi.BeforeTransactionCompletionProcess;
@@ -63,7 +64,7 @@
 
 /**
  * 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.
@@ -91,6 +92,7 @@ public class ActionQueue {
 	// just re-use the same Lists for convenience.
 	private ArrayList collectionCreations;
 	private ArrayList collectionUpdates;
+	private ArrayList collectionQueuedOps;
 	private ArrayList collectionRemovals;
 
 	private AfterTransactionCompletionProcessQueue afterTransactionProcesses;
@@ -115,6 +117,7 @@ private void init() {
 		collectionCreations = new ArrayList( INIT_QUEUE_LIST_SIZE );
 		collectionRemovals = new ArrayList( INIT_QUEUE_LIST_SIZE );
 		collectionUpdates = new ArrayList( INIT_QUEUE_LIST_SIZE );
+		collectionQueuedOps = new ArrayList( INIT_QUEUE_LIST_SIZE );
 
 		afterTransactionProcesses = new AfterTransactionCompletionProcessQueue( session );
 		beforeTransactionProcesses = new BeforeTransactionCompletionProcessQueue( session );
@@ -128,6 +131,7 @@ public void clear() {
 		collectionCreations.clear();
 		collectionRemovals.clear();
 		collectionUpdates.clear();
+		collectionQueuedOps.clear();
 
 		unresolvedInsertions.clear();
 	}
@@ -163,6 +167,11 @@ public void addAction(CollectionUpdateAction action) {
 		collectionUpdates.add( action );
 	}
 
+	@SuppressWarnings({ "unchecked" })
+	public void addAction(QueuedOperationCollectionAction action) {
+		collectionQueuedOps.add( action );
+	}
+
 	@SuppressWarnings({ "unchecked" })
 	public void addAction(EntityIdentityInsertAction insert) {
 		LOG.tracev( "Adding an EntityIdentityInsertAction for [{0}] object", insert.getEntityName() );
@@ -276,6 +285,8 @@ public void executeActions() throws HibernateException {
 		}
 		executeActions( insertions );
 		executeActions( updates );
+		// do before actions are handled in the other collection queues
+		executeActions( collectionQueuedOps );
 		executeActions( collectionRemovals );
 		executeActions( collectionUpdates );
 		executeActions( collectionCreations );
@@ -291,6 +302,7 @@ public void prepareActions() throws HibernateException {
 		prepareActions( collectionRemovals );
 		prepareActions( collectionUpdates );
 		prepareActions( collectionCreations );
+		prepareActions( collectionQueuedOps );
 	}
 
 	/**
@@ -325,6 +337,7 @@ public boolean areTablesToBeUpdated(Set tables) {
 				areTablesToUpdated( deletions, tables ) ||
 				areTablesToUpdated( collectionUpdates, tables ) ||
 				areTablesToUpdated( collectionCreations, tables ) ||
+				areTablesToUpdated( collectionQueuedOps, tables ) ||
 				areTablesToUpdated( collectionRemovals, tables );
 	}
 
@@ -401,6 +414,7 @@ public String toString() {
 				.append( " collectionCreations=" ).append( collectionCreations )
 				.append( " collectionRemovals=" ).append( collectionRemovals )
 				.append( " collectionUpdates=" ).append( collectionUpdates )
+				.append( " collectionQueuedOps=" ).append( collectionQueuedOps )
 				.append( " unresolvedInsertDependencies=" ).append( unresolvedInsertions )
 				.append( "]" )
 				.toString();
@@ -436,6 +450,7 @@ public void sortCollectionActions() {
 			//sort the updates by fk
 			java.util.Collections.sort( collectionCreations );
 			java.util.Collections.sort( collectionUpdates );
+			java.util.Collections.sort( collectionQueuedOps );
 			java.util.Collections.sort( collectionRemovals );
 		}
 	}
@@ -472,6 +487,7 @@ public ArrayList cloneDeletions() {
 	public void clearFromFlushNeededCheck(int previousCollectionRemovalSize) {
 		collectionCreations.clear();
 		collectionUpdates.clear();
+		collectionQueuedOps.clear();
 		updates.clear();
 		// collection deletions are a special case since update() can add
 		// deletions of collections not loaded by the session.
@@ -495,6 +511,7 @@ public boolean hasAnyQueuedActions() {
 				! unresolvedInsertions.isEmpty() ||
 				deletions.size() > 0 ||
 				collectionUpdates.size() > 0 ||
+				collectionQueuedOps.size() > 0 ||
 				collectionRemovals.size() > 0 ||
 				collectionCreations.size() > 0;
 	}
@@ -564,6 +581,13 @@ public void serialize(ObjectOutputStream oos) throws IOException {
 		for ( int i = 0; i < queueSize; i++ ) {
 			oos.writeObject( collectionCreations.get( i ) );
 		}
+
+		queueSize = collectionQueuedOps.size();
+		LOG.tracev( "Starting serialization of [{0}] collectionQueuedOps entries", queueSize );
+		oos.writeInt( queueSize );
+		for ( int i = 0; i < queueSize; i++ ) {
+			oos.writeObject( collectionQueuedOps.get( i ) );
+		}
 	}
 
 	/**
@@ -640,6 +664,15 @@ public static ActionQueue deserialize(
 			action.afterDeserialize( session );
 			rtn.collectionCreations.add( action );
 		}
+
+		queueSize = ois.readInt();
+		LOG.tracev( "Starting deserialization of [{0}] collectionQueuedOps entries", queueSize );
+		rtn.collectionQueuedOps = new ArrayList<Executable>( queueSize );
+		for ( int i = 0; i < queueSize; i++ ) {
+			CollectionAction action = ( CollectionAction ) ois.readObject();
+			action.afterDeserialize( session );
+			rtn.collectionQueuedOps.add( action );
+		}
 		return rtn;
 	}
 

hibernate-core/src/main/java/org/hibernate/event/internal/AbstractFlushingEventListener.java

@@ -32,6 +32,7 @@
 import org.hibernate.action.internal.CollectionRecreateAction;
 import org.hibernate.action.internal.CollectionRemoveAction;
 import org.hibernate.action.internal.CollectionUpdateAction;
+import org.hibernate.action.internal.QueuedOperationCollectionAction;
 import org.hibernate.collection.spi.PersistentCollection;
 import org.hibernate.engine.internal.Cascade;
 import org.hibernate.engine.internal.Collections;
@@ -293,6 +294,16 @@ private void flushCollections(final EventSource session, final PersistenceContex
 							)
 					);
 			}
+			if ( !coll.wasInitialized() && coll.hasQueuedOperations() ) {
+				actionQueue.addAction(
+						new QueuedOperationCollectionAction(
+								coll,
+								ce.getLoadedPersister(),
+								ce.getLoadedKey(),
+								session
+							)
+					);
+			}
 
 		}
 

hibernate-core/src/main/java/org/hibernate/persister/collection/AbstractCollectionPersister.java

@@ -1631,6 +1631,16 @@ public void updateRows(PersistentCollection collection, Serializable id, Session
 
 	protected abstract int doUpdateRows(Serializable key, PersistentCollection collection, SessionImplementor session)
 			throws HibernateException;
+	
+	public void processQueuedOps(PersistentCollection collection, Serializable key, SessionImplementor session)
+			throws HibernateException {
+		if ( collection.hasQueuedOperations() ) {
+			doProcessQueuedOps( collection, key, session );
+		}
+	}
+	
+	protected abstract void doProcessQueuedOps(PersistentCollection collection, Serializable key, SessionImplementor session)
+			throws HibernateException;
 
 	public CollectionMetadata getCollectionMetadata() {
 		return this;

hibernate-core/src/main/java/org/hibernate/persister/collection/BasicCollectionPersister.java

@@ -152,6 +152,12 @@ else if ( hasIndex && !indexContainsFormula ) {
 
 		return update.toStatementString();
 	}
+	
+	@Override
+	protected void doProcessQueuedOps(PersistentCollection collection, Serializable id, SessionImplementor session)
+			throws HibernateException {
+		// nothing to do
+	}
 
 	/**
 	 * Generate the SQL DELETE that deletes a particular row

hibernate-core/src/main/java/org/hibernate/persister/collection/CollectionPersister.java

@@ -198,6 +198,16 @@ public void insertRows(
 		Serializable key,
 		SessionImplementor session)
 		throws HibernateException;
+	
+	/**
+	 * Process queued operations within the PersistentCollection.
+	 */
+	public void processQueuedOps(
+			PersistentCollection collection,
+			Serializable key,
+			SessionImplementor session)
+			throws HibernateException;
+	
 	/**
 	 * Get the name of this collection role (the fully qualified class name,
 	 * extended by a "property path")

hibernate-core/src/main/java/org/hibernate/persister/collection/OneToManyPersister.java

@@ -181,21 +181,26 @@ protected String generateDeleteRowString() {
 	public void recreate(PersistentCollection collection, Serializable id, SessionImplementor session)
 			throws HibernateException {
 		super.recreate( collection, id, session );
-		writeIndex( collection, id, session );
+		writeIndex( collection, collection.entries( this ), id, session );
 	}
 
 	@Override
 	public void insertRows(PersistentCollection collection, Serializable id, SessionImplementor session)
 			throws HibernateException {
 		super.insertRows( collection, id, session );
-		writeIndex( collection, id, session );
+		writeIndex( collection, collection.entries( this ), id, session );
 	}
 
-	private void writeIndex(PersistentCollection collection, Serializable id, SessionImplementor session) {
+	@Override
+	protected void doProcessQueuedOps(PersistentCollection collection, Serializable id, SessionImplementor session)
+			throws HibernateException {
+		writeIndex( collection, collection.queuedAdditionIterator(), id, session );
+	}
+	
+	private void writeIndex(PersistentCollection collection, Iterator entries, Serializable id, SessionImplementor session) {
 		// If one-to-many and inverse, still need to create the index.  See HHH-5732.
 		if ( isInverse && hasIndex && !indexContainsFormula ) {
 			try {
-				Iterator entries = collection.entries( this );
 				if ( entries.hasNext() ) {
 					Expectation expectation = Expectations.appropriateExpectation( getUpdateCheckStyle() );
 					int i = 0;

hibernate-core/src/test/java/org/hibernate/test/annotations/onetomany/Comment.java

@@ -0,0 +1,67 @@
+package org.hibernate.test.annotations.onetomany;
+
+import javax.persistence.Column;
+import javax.persistence.DiscriminatorColumn;
+import javax.persistence.DiscriminatorType;
+import javax.persistence.DiscriminatorValue;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+
+@Entity(name="Comment")
+@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
+@DiscriminatorColumn(name = "DTYPE", discriminatorType= DiscriminatorType.STRING, length = 3)
+@DiscriminatorValue(value = "WPT")
+public class Comment {
+	
+	private Long id;
+	private Post post;
+	private String name;
+	private Forum forum;
+	
+	@Id
+	@GeneratedValue(strategy = GenerationType.AUTO)
+	@Column(name = "id", updatable = false, insertable = false)
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+	
+	@ManyToOne(optional=true,fetch=FetchType.LAZY)
+	@JoinColumn(name="FK_PostId", nullable=true, insertable=true,updatable=false)
+	public Post getPost() {
+		return post;
+	}
+
+	public void setPost(Post family) {
+		this.post = family;
+	}
+
+	@ManyToOne(optional=true,fetch=FetchType.LAZY)
+	@JoinColumn(name="FK_ForumId", nullable=true, insertable=true,updatable=false)
+	public Forum getForum() {
+		return forum;
+	}
+
+	public void setForum(Forum forum) {
+		this.forum = forum;
+	}
+
+	@Column
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+}