Relaxed lock wait rules so that record lock does not need to wait for a

gap type lock.

innobase/lock/lock0lock.c

@@ -773,19 +773,22 @@ lock_rec_has_to_wait(
 		/* We have somewhat complex rules when gap type record locks
 		cause waits */
 
-		if (( lock_is_on_supremum || (type_mode & LOCK_GAP))
+		if ((lock_is_on_supremum || (type_mode & LOCK_GAP))
 			&& !(type_mode & LOCK_INSERT_INTENTION)) {
+
 			/* Gap type locks without LOCK_INSERT_INTENTION flag
-			do not need to wait for anything. This is because different 
-			users can have conflicting lock types on gaps. */
+			do not need to wait for anything. This is because 
+			different users can have conflicting lock types 
+			on gaps. */
 						  
 			return(FALSE);
 		}
 		
-		if ((type_mode & LOCK_REC_NOT_GAP)
+		if (!(type_mode & LOCK_INSERT_INTENTION)
 						&& lock_rec_get_gap(lock2)) {
-			/* Lock on just the record does not need to wait for
-			a gap type lock */
+
+			/* Record lock (LOCK_ORDINARY or LOCK_REC_NOT_GAP
+			does not need to wait for a gap type lock */
 
 			return(FALSE);
 		}
@@ -846,8 +849,8 @@ lock_has_to_wait(
 			then the second bit on the lock bitmap is set */
 			
 			return(lock_rec_has_to_wait(lock1->trx,
-						lock1->type_mode, lock2,
-						lock_rec_get_nth_bit(lock1,1)));
+					lock1->type_mode, lock2,
+					lock_rec_get_nth_bit(lock1,1)));
 		}
 
 		return(TRUE);

innobase/row/row0ins.c

@@ -1635,21 +1635,24 @@ row_ins_duplicate_error_in_clust(
 			sure that in roll-forward we get the same duplicate
 			errors as in original execution */
 
-			dict_accept(*trx->mysql_query_str, "REPLACE", &success);
+			dict_accept(*trx->mysql_query_str, "REPLACE", 
+				    &success);
 
 			if (success) {
 
-				/* The manual defines the REPLACE semantics that it 
-				is either an INSERT or DELETE(s) for duplicate key
-				+ INSERT. Therefore, we should take X-lock for
-				duplicates */
+				/* The manual defines the REPLACE semantics 
+				that it is either an INSERT or DELETE(s) 
+				for duplicate key + INSERT. Therefore, we 
+				should take X-lock for duplicates */
 				
 				err = row_ins_set_exclusive_rec_lock(
-					LOCK_REC_NOT_GAP,rec,cursor->index,thr);
+					LOCK_REC_NOT_GAP,rec,cursor->index,
+					thr);
 			} else {
 				
 				err = row_ins_set_shared_rec_lock(
-					LOCK_REC_NOT_GAP,rec, cursor->index, thr);
+					LOCK_REC_NOT_GAP,rec, cursor->index, 
+					thr);
 			} 
 
 			if (err != DB_SUCCESS) {
@@ -1673,26 +1676,28 @@ row_ins_duplicate_error_in_clust(
 		if (rec != page_get_supremum_rec(page)) {
 
 
-                        /* The manual defines the REPLACE semantics that it 
-                           is either an INSERT or DELETE(s) for duplicate key
-                           + INSERT. Therefore, we should take X-lock for
-                           duplicates.
+			/* The manual defines the REPLACE semantics that it 
+			is either an INSERT or DELETE(s) for duplicate key
+			+ INSERT. Therefore, we should take X-lock for
+			duplicates.
 		        */
 
-                        
-                        /* Is the first word in MySQL query REPLACE ? */
+			/* Is the first word in MySQL query REPLACE ? */
 
-                        dict_accept(*trx->mysql_query_str, "REPLACE", &success);
+		 	dict_accept(*trx->mysql_query_str, "REPLACE", 
+				    &success);
 
-                        if (success) {
+			if (success) {
 
-		            err = row_ins_set_exclusive_rec_lock(
-			       LOCK_REC_NOT_GAP,rec,cursor->index,thr);
-		        } else {
+				err = row_ins_set_exclusive_rec_lock(
+						LOCK_REC_NOT_GAP,
+						rec,cursor->index,thr);
+			} else {
 
-			    err = row_ins_set_shared_rec_lock(
-                               LOCK_REC_NOT_GAP,rec, cursor->index, thr);
-                        }
+				err = row_ins_set_shared_rec_lock(
+						LOCK_REC_NOT_GAP,rec, 
+						cursor->index, thr);
+			}
 
 			if (err != DB_SUCCESS) {