diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 4e5be1a..9bb13df 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -313,8 +313,8 @@ ExecInsert(TupleTableSlot *slot,
 		 * deleting the already-inserted tuple and retrying, but that's fairly
 		 * expensive, so we try to avoid it.
 		 */
-		conflict = false;
 vlock:
+		conflict = false;
 		ItemPointerSetInvalid(&conflictTid);
 
 		/*
@@ -354,7 +354,8 @@ vlock:
 			 * which is appropriate only for non-promise tuples) to wait for us
 			 * to decide if we're going to go ahead with the insertion.
 			 */
-			SpeculativeInsertionLockAcquire(GetCurrentTransactionId());
+			if (spec != SPEC_NONE)
+				SpeculativeInsertionLockAcquire(GetCurrentTransactionId());
 
 			/*
 			 * insert the tuple
@@ -363,7 +364,8 @@ vlock:
 			 * the t_self field.
 			 */
 			newId = heap_insert(resultRelationDesc, tuple,
-								estate->es_output_cid, HEAP_INSERT_SPECULATIVE,
+								estate->es_output_cid,
+								spec != SPEC_NONE? HEAP_INSERT_SPECULATIVE:0,
 								NULL);
 
 			/*
@@ -404,8 +406,11 @@ vlock:
 							estate->es_output_cid, NULL, false, &hufd, true);
 			}
 
-			SpeculativeInsertionLockRelease(GetCurrentTransactionId());
-			ClearSpeculativeInsertionState();
+			if (spec != SPEC_NONE)
+			{
+				SpeculativeInsertionLockRelease(GetCurrentTransactionId());
+				ClearSpeculativeInsertionState();
+			}
 		}
 
 		if (conflict)
@@ -1014,6 +1019,17 @@ ExecLockUpdateTuple(EState *estate,
 						   LockTupleExclusive, false, /* wait */
 						   false, &buffer, &hufd);
 
+	/* Was tuple concurrently super-deleted? */
+	if (TransactionIdEquals(HeapTupleHeaderGetRawXmin(tuple.t_data),
+							 InvalidTransactionId))
+	{
+		test = HeapTupleUpdated;
+		/* XXX Should be caught within tqual.c */
+		elog(WARNING, "concurrent super delete of tuple (%u,%u)",
+			 ItemPointerGetBlockNumber(&tuple.t_data->t_ctid),
+			 ItemPointerGetOffsetNumber(&tuple.t_data->t_ctid));
+	}
+
 	if (test == HeapTupleMayBeUpdated)
 		copyTuple = heap_copytuple(&tuple);
 
@@ -1145,6 +1161,15 @@ ExecLockUpdateTuple(EState *estate,
 				*returning = ExecUpdate(&tuple.t_data->t_ctid, NULL, slot,
 										planSlot, &onConflict->mt_epqstate,
 										onConflict->ps.state, canSetTag);
+			else
+				/*
+				 * XXX Debug instrumentation.  This is useful for stress test
+				 * queries with "WHERE target.index = excluded.index", in order
+				 * to assert that the UPDATE affects the right row.
+				 */
+				elog(WARNING, "did not update tuple (%u,%u)",
+					 ItemPointerGetBlockNumber(&tuple.t_data->t_ctid),
+					 ItemPointerGetOffsetNumber(&tuple.t_data->t_ctid));
 
 			ReleaseBuffer(buffer);
 
diff --git a/src/backend/utils/time/tqual.c b/src/backend/utils/time/tqual.c
index 9216779..94099f1 100644
--- a/src/backend/utils/time/tqual.c
+++ b/src/backend/utils/time/tqual.c
@@ -728,6 +728,16 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
 	snapshot->xmin = snapshot->xmax = InvalidTransactionId;
 	snapshot->speculativeToken = 0;
 
+	/*
+	 * Never return "super-deleted" tuples
+	 *
+	 * XXX:  Comment this code out and you'll get conflicts within
+	 * ExecLockUpdateTuple(), which result in an infinite loop.
+	 */
+	if (TransactionIdEquals(HeapTupleHeaderGetRawXmin(tuple),
+							InvalidTransactionId))
+		return false;
+
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
 		if (HeapTupleHeaderXminInvalid(tuple))
@@ -943,6 +953,13 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
 	Assert(ItemPointerIsValid(&htup->t_self));
 	Assert(htup->t_tableOid != InvalidOid);
 
+	/*
+	 * Never return "super-deleted" tuples
+	 */
+	if (TransactionIdEquals(HeapTupleHeaderGetRawXmin(tuple),
+							InvalidTransactionId))
+		return false;
+
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
 		if (HeapTupleHeaderXminInvalid(tuple))
@@ -1147,6 +1164,13 @@ HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin,
 	Assert(htup->t_tableOid != InvalidOid);
 
 	/*
+	 * Immediately VACUUM "super-deleted" tuples
+	 */
+	if (TransactionIdEquals(HeapTupleHeaderGetRawXmin(tuple),
+							InvalidTransactionId))
+		return HEAPTUPLE_DEAD;
+
+	/*
 	 * Has inserting transaction committed?
 	 *
 	 * If the inserting transaction aborted, then the tuple was never visible