Create a function to reliably identify which sessions block which others.

This patch introduces "pg_blocking_pids(int) returns int[]", which returns
the PIDs of any sessions that are blocking the session with the given PID.
Historically people have obtained such information using a self-join on
the pg_locks view, but it's unreasonably tedious to do it that way with any
modicum of correctness, and the addition of parallel queries has pretty
much broken that approach altogether.  (Given some more columns in the view
than there are today, you could imagine handling parallel-query cases with
a 4-way join; but ugh.)

The new function has the following behaviors that are painful or impossible
to get right via pg_locks:

1. Correctly understands which lock modes block which other ones.

2. In soft-block situations (two processes both waiting for conflicting lock
modes), only the one that's in front in the wait queue is reported to
block the other.

3. In parallel-query cases, reports all sessions blocking any member of
the given PID's lock group, and reports a session by naming its leader
process's PID, which will be the pg_backend_pid() value visible to
clients.

The motivation for doing this right now is mostly to fix the isolation
tests.  Commit 38f8bdcac4982215beb9f65a19debecaf22fd470 lobotomized
isolationtester's is-it-waiting query by removing its ability to recognize
nonconflicting lock modes, as a crude workaround for the inability to
handle soft-block situations properly.  But even without the lock mode
tests, the old query was excessively slow, particularly in
CLOBBER_CACHE_ALWAYS builds; some of our buildfarm animals fail the new
deadlock-hard test because the deadlock timeout elapses before they can
probe the waiting status of all eight sessions.  Replacing the pg_locks
self-join with use of pg_blocking_pids() is not only much more correct, but
a lot faster: I measure it at about 9X faster in a typical dev build with
Asserts, and 3X faster in CLOBBER_CACHE_ALWAYS builds.  That should provide
enough headroom for the slower CLOBBER_CACHE_ALWAYS animals to pass the
test, without having to lengthen deadlock_timeout yet more and thus slow
down the test for everyone else.

1 files changed, 8 insertions, 22 deletions

diff --git a/src/test/isolation/isolationtester.c b/src/test/isolation/isolationtester.c
index 0a9d25ce9ca..6461ae8f815 100644
--- a/src/test/isolation/isolationtester.c
+++ b/src/test/isolation/isolationtester.c
@@ -227,27 +227,12 @@ main(int argc, char **argv)
 	 */
 	initPQExpBuffer(&wait_query);
 	appendPQExpBufferStr(&wait_query,
-						 "SELECT 1 FROM pg_locks holder, pg_locks waiter "
-						 "WHERE NOT waiter.granted AND waiter.pid = $1 "
-						 "AND holder.granted "
-						 "AND holder.pid <> $1 AND holder.pid IN (");
+						 "SELECT pg_catalog.pg_blocking_pids($1) && '{");
 	/* The spec syntax requires at least one session; assume that here. */
 	appendPQExpBufferStr(&wait_query, backend_pids[1]);
 	for (i = 2; i < nconns; i++)
-		appendPQExpBuffer(&wait_query, ", %s", backend_pids[i]);
-	appendPQExpBufferStr(&wait_query,
-						 ") "
-
-				  "AND holder.locktype IS NOT DISTINCT FROM waiter.locktype "
-				  "AND holder.database IS NOT DISTINCT FROM waiter.database "
-				  "AND holder.relation IS NOT DISTINCT FROM waiter.relation "
-						 "AND holder.page IS NOT DISTINCT FROM waiter.page "
-						 "AND holder.tuple IS NOT DISTINCT FROM waiter.tuple "
-			  "AND holder.virtualxid IS NOT DISTINCT FROM waiter.virtualxid "
-		"AND holder.transactionid IS NOT DISTINCT FROM waiter.transactionid "
-					"AND holder.classid IS NOT DISTINCT FROM waiter.classid "
-						 "AND holder.objid IS NOT DISTINCT FROM waiter.objid "
-				"AND holder.objsubid IS NOT DISTINCT FROM waiter.objsubid ");
+		appendPQExpBuffer(&wait_query, ",%s", backend_pids[i]);
+	appendPQExpBufferStr(&wait_query, "}'::integer[]");
 
 	res = PQprepare(conns[0], PREP_WAITING, wait_query.data, 0, NULL);
 	if (PQresultStatus(res) != PGRES_COMMAND_OK)
@@ -745,21 +730,22 @@ try_complete_step(Step *step, int flags)
 			/* If it's OK for the step to block, check whether it has. */
 			if (flags & STEP_NONBLOCK)
 			{
-				int			ntuples;
+				bool		waiting;
 
 				res = PQexecPrepared(conns[0], PREP_WAITING, 1,
 									 &backend_pids[step->session + 1],
 									 NULL, NULL, 0);
-				if (PQresultStatus(res) != PGRES_TUPLES_OK)
+				if (PQresultStatus(res) != PGRES_TUPLES_OK ||
+					PQntuples(res) != 1)
 				{
 					fprintf(stderr, "lock wait query failed: %s",
 							PQerrorMessage(conn));
 					exit_nicely();
 				}
-				ntuples = PQntuples(res);
+				waiting = ((PQgetvalue(res, 0, 0))[0] == 't');
 				PQclear(res);
 
-				if (ntuples >= 1)		/* waiting to acquire a lock */
+				if (waiting)	/* waiting to acquire a lock */
 				{
 					if (!(flags & STEP_RETRY))
 						printf("step %s: %s <waiting ...>\n",