Identify pooled connections by pointer instead of backend PID

PostgreSQL can assign a terminated backend's PID to a new backend, so a PID does not uniquely identify a connection
over time. PID reuse is common on the Windows CI runners, where it made these tests fail:

    TestPoolAcquireChecksIdleConns: []uint32{0xd48, 0x23bc, 0x1738} should not contain 0x1738
    TestPoolAfterRelease:           expected: 5, actual: 4

Compare *pgx.Conn pointers instead. TestPoolAfterRelease keeps them in a map, which also retains the destroyed
connections so their addresses cannot be reused either. TestPoolAcquireChecksIdleConns still needs the PIDs to call
pg_terminate_backend().

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: jackc

pgxpool/pool_test.go

@@ -176,8 +176,10 @@ func TestPoolAcquireChecksIdleConns(t *testing.T) {
 	require.EqualValues(t, 3, pool.Stat().TotalConns())
 
 	var pids []uint32
+	var originalConns []*pgx.Conn
 	for _, c := range conns {
 		pids = append(pids, c.Conn().PgConn().PID())
+		originalConns = append(originalConns, c.Conn())
 		c.Release()
 	}
 
@@ -199,10 +201,14 @@ func TestPoolAcquireChecksIdleConns(t *testing.T) {
 	c, err := pool.Acquire(ctx)
 	require.NoError(t, err)
 
-	cPID := c.Conn().PgConn().PID()
+	newConn := c.Conn()
 	c.Release()
 
-	require.NotContains(t, pids, cPID)
+	// Compare connections by identity instead of by backend PID. PostgreSQL can assign a terminated backend's PID to a
+	// new backend, which made this test flaky in CI.
+	for _, originalConn := range originalConns {
+		require.NotSame(t, originalConn, newConn)
+	}
 }
 
 func TestPoolAcquireChecksIdleConnsWithShouldPing(t *testing.T) {
@@ -477,17 +483,20 @@ func TestPoolAfterRelease(t *testing.T) {
 	require.NoError(t, err)
 	defer db.Close()
 
-	connPIDs := map[uint32]struct{}{}
+	// Count distinct connections by identity instead of by backend PID. PostgreSQL can assign a terminated backend's
+	// PID to a new backend, which made this test flaky in CI. Retaining the connections in the map also prevents them
+	// from being garbage collected, so a destroyed connection's address cannot be reused either.
+	distinctConns := map[*pgx.Conn]struct{}{}
 
 	for range 10 {
 		conn, err := db.Acquire(ctx)
 		assert.NoError(t, err)
-		connPIDs[conn.Conn().PgConn().PID()] = struct{}{}
+		distinctConns[conn.Conn()] = struct{}{}
 		conn.Release()
 		waitForReleaseToComplete()
 	}
 
-	assert.EqualValues(t, 5, len(connPIDs))
+	assert.EqualValues(t, 5, len(distinctConns))
 }
 
 func TestPoolBeforeClose(t *testing.T) {
@@ -1405,13 +1414,10 @@ func TestPoolAcquirePingTimeout(t *testing.T) {
 	config.PingTimeout = 200 * time.Millisecond
 	config.ConnConfig.DialFunc = newDelayProxyDialFunc(500 * time.Millisecond)
 
-	var conID *uint32
-	// Only ping the connection with the original PID to force creation of a new connection
+	var originalConn *pgx.Conn
+	// Only ping the original connection to force creation of a new connection
 	config.ShouldPing = func(_ context.Context, params pgxpool.ShouldPingParams) bool {
-		if conID != nil && params.Conn.PgConn().PID() == *conID {
-			return true
-		}
-		return false
+		return originalConn != nil && params.Conn == originalConn
 	}
 
 	// Limit to a single connection to ensure the same connection is reused
@@ -1425,21 +1431,20 @@ func TestPoolAcquirePingTimeout(t *testing.T) {
 	c, err := pool.Acquire(ctx)
 	require.NoError(t, err)
 	require.EqualValues(t, 1, pool.Stat().TotalConns())
-	originalPID := c.Conn().PgConn().PID()
-	conID = &originalPID
+	originalConn = c.Conn()
 
 	c.Release()
 	require.EqualValues(t, 1, pool.Stat().TotalConns())
 
 	c, err = pool.Acquire(ctx)
 	require.NoError(t, err)
 	require.EqualValues(t, 1, pool.Stat().TotalConns())
-	newPID := c.Conn().PgConn().PID()
+	newConn := c.Conn()
 
 	c.Release()
 
 	require.EqualValues(t, 1, pool.Stat().TotalConns())
 	assert.Nil(t, ctx.Err())
-	assert.NotEqualValues(t, originalPID, newPID,
+	assert.NotSame(t, originalConn, newConn,
 		"Expected new connection due to ping timeout, but got same connection")
 }

stdlib/sql_test.go

@@ -1328,9 +1328,12 @@ func TestCheckIdleConn(t *testing.T) {
 	require.EqualValues(t, 3, db.Stats().OpenConnections)
 
 	var pids []uint32
+	var originalConns []*pgx.Conn
 	for _, c := range conns {
 		err := c.Raw(func(driverConn any) error {
-			pids = append(pids, driverConn.(*stdlib.Conn).Conn().PgConn().PID())
+			pgxConn := driverConn.(*stdlib.Conn).Conn()
+			pids = append(pids, pgxConn.PgConn().PID())
+			originalConns = append(originalConns, pgxConn)
 			return nil
 		})
 		require.NoError(t, err)
@@ -1359,16 +1362,20 @@ func TestCheckIdleConn(t *testing.T) {
 	c, err := db.Conn(context.Background())
 	require.NoError(t, err)
 
-	var cPID uint32
+	var newConn *pgx.Conn
 	err = c.Raw(func(driverConn any) error {
-		cPID = driverConn.(*stdlib.Conn).Conn().PgConn().PID()
+		newConn = driverConn.(*stdlib.Conn).Conn()
 		return nil
 	})
 	require.NoError(t, err)
 	err = c.Close()
 	require.NoError(t, err)
 
-	require.NotContains(t, pids, cPID)
+	// Compare connections by identity instead of by backend PID. PostgreSQL can assign a terminated backend's PID to a
+	// new backend, which made the equivalent pgxpool test flaky in CI.
+	for _, originalConn := range originalConns {
+		require.NotSame(t, originalConn, newConn)
+	}
 }
 
 func TestOptionShouldPing_HookCalledOnReuse(t *testing.T) {