pgsql: Support partition pruning at execution time

diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index 9762cc9748..de339797f5 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -1347,6 +1347,8 @@ create table ab_a3 partition of ab for values in(3) partition by list (b);
 create table ab_a3_b1 partition of ab_a3 for values in (1);
 create table ab_a3_b2 partition of ab_a3 for values in (2);
 create table ab_a3_b3 partition of ab_a3 for values in (3);
+-- disable to prevent variable "Heap Fetches:" output
+set enable_indexonlyscan = off;
 prepare ab_q1 (int, int, int) as
 select * from ab where a between $1 and $2 and b <= $3;
 -- Execute query 5 times to allow choose_custom_plan
@@ -1709,7 +1711,7 @@ create table lprt_a (a int not null);
 insert into lprt_a select 0 from generate_series(1,100);
 -- and insert some values that we should find.
 insert into lprt_a values(1),(1);
-analyze lprt_a;
+vacuum (analyze) lprt_a;
 create index ab_a2_b1_a_idx on ab_a2_b1 (a);
 create index ab_a2_b2_a_idx on ab_a2_b2 (a);
 create index ab_a2_b3_a_idx on ab_a2_b3 (a);
@@ -1754,8 +1756,8 @@ execute ab_q6 (1, 2, 3);
 (1 row)
 
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (0, 0, 1);
-                                               QUERY PLAN                                               
---------------------------------------------------------------------------------------------------------
+                                            QUERY PLAN                                             
+---------------------------------------------------------------------------------------------------
  Finalize Aggregate (actual rows=1 loops=1)
    ->  Gather (actual rows=2 loops=1)
          Workers Planned: 1
@@ -1765,39 +1767,31 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6 (0, 0, 1);
                      ->  Parallel Seq Scan on lprt_a a (actual rows=51 loops=2)
                            Filter: (a = ANY ('{0,0,1}'::integer[]))
                      ->  Append (actual rows=0 loops=102)
-                           ->  Index Only Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-(36 rows)
+(27 rows)
 
 insert into lprt_a values(3),(3);
+vacuum (analyze) lprt_a;
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 3);
-                                               QUERY PLAN                                               
---------------------------------------------------------------------------------------------------------
+                                            QUERY PLAN                                             
+---------------------------------------------------------------------------------------------------
  Finalize Aggregate (actual rows=1 loops=1)
    ->  Gather (actual rows=2 loops=1)
          Workers Planned: 1
@@ -1807,38 +1801,29 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 3);
                      ->  Parallel Seq Scan on lprt_a a (actual rows=52 loops=2)
                            Filter: (a = ANY ('{1,0,3}'::integer[]))
                      ->  Append (actual rows=0 loops=104)
-                           ->  Index Only Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b1_a_idx on ab_a3_b1 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b2_a_idx on ab_a3_b2 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b3_a_idx on ab_a3_b3 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-(36 rows)
+(27 rows)
 
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
-                                               QUERY PLAN                                               
---------------------------------------------------------------------------------------------------------
+                                            QUERY PLAN                                             
+---------------------------------------------------------------------------------------------------
  Finalize Aggregate (actual rows=1 loops=1)
    ->  Gather (actual rows=2 loops=1)
          Workers Planned: 1
@@ -1849,39 +1834,31 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
                            Filter: (a = ANY ('{1,0,0}'::integer[]))
                            Rows Removed by Filter: 1
                      ->  Append (actual rows=0 loops=102)
-                           ->  Index Only Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-(37 rows)
+(28 rows)
 
 delete from lprt_a where a = 1;
+vacuum (analyze) lprt_a;
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
-                                           QUERY PLAN                                            
--------------------------------------------------------------------------------------------------
+                                         QUERY PLAN                                         
+--------------------------------------------------------------------------------------------
  Finalize Aggregate (actual rows=1 loops=1)
    ->  Gather (actual rows=2 loops=1)
          Workers Planned: 1
@@ -1892,34 +1869,25 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
                            Filter: (a = ANY ('{1,0,0}'::integer[]))
                            Rows Removed by Filter: 1
                      ->  Append (actual rows=0 loops=100)
-                           ->  Index Only Scan using ab_a1_b1_a_idx on ab_a1_b1 (never executed)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b2_a_idx on ab_a1_b2 (never executed)
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b3_a_idx on ab_a1_b3 (never executed)
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-(37 rows)
+(28 rows)
 
 reset enable_hashjoin;
 reset enable_mergejoin;
@@ -2011,61 +1979,50 @@ create index tprt4_idx on tprt_4 (col1);
 create index tprt5_idx on tprt_5 (col1);
 create index tprt6_idx on tprt_6 (col1);
 insert into tprt values (10), (20), (501), (502), (505), (1001), (4500);
+vacuum (analyze) tprt;
 set enable_hashjoin = off;
 set enable_mergejoin = off;
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 join tprt on tbl1.col1 > tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=6 loops=1)
    ->  Seq Scan on tbl1 (actual rows=2 loops=1)
    ->  Append (actual rows=3 loops=2)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (actual rows=2 loops=2)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 4
-         ->  Index Only Scan using tprt2_idx on tprt_2 (actual rows=2 loops=1)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 2
-         ->  Index Only Scan using tprt3_idx on tprt_3 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+         ->  Index Scan using tprt1_idx on tprt_1 (actual rows=2 loops=2)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt2_idx on tprt_2 (actual rows=2 loops=1)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt3_idx on tprt_3 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+(15 rows)
 
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 join tprt on tbl1.col1 = tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=2 loops=1)
    ->  Seq Scan on tbl1 (actual rows=2 loops=1)
    ->  Append (actual rows=1 loops=2)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (never executed)
+         ->  Index Scan using tprt1_idx on tprt_1 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
+         ->  Index Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 2
-         ->  Index Only Scan using tprt3_idx on tprt_3 (never executed)
+         ->  Index Scan using tprt3_idx on tprt_3 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+(15 rows)
 
 select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 > tprt.col1
@@ -2091,59 +2048,50 @@ order by tbl1.col1, tprt.col1;
 
 -- Multiple partitions
 insert into tbl1 values (1001), (1010), (1011);
+vacuum (analyze) tbl1;
+set enable_seqscan = off;
+set enable_bitmapscan = off;
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 inner join tprt on tbl1.col1 > tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=23 loops=1)
    ->  Seq Scan on tbl1 (actual rows=5 loops=1)
    ->  Append (actual rows=5 loops=5)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (actual rows=2 loops=5)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 10
-         ->  Index Only Scan using tprt2_idx on tprt_2 (actual rows=3 loops=4)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 11
-         ->  Index Only Scan using tprt3_idx on tprt_3 (actual rows=1 loops=2)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 2
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+         ->  Index Scan using tprt1_idx on tprt_1 (actual rows=2 loops=5)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt2_idx on tprt_2 (actual rows=3 loops=4)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt3_idx on tprt_3 (actual rows=1 loops=2)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+(15 rows)
 
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 inner join tprt on tbl1.col1 = tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=3 loops=1)
    ->  Seq Scan on tbl1 (actual rows=5 loops=1)
    ->  Append (actual rows=1 loops=5)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (never executed)
+         ->  Index Scan using tprt1_idx on tprt_1 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
+         ->  Index Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 2
-         ->  Index Only Scan using tprt3_idx on tprt_3 (actual rows=0 loops=3)
+         ->  Index Scan using tprt3_idx on tprt_3 (actual rows=0 loops=3)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 1
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+(15 rows)
 
 select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 > tprt.col1
@@ -2190,30 +2138,24 @@ delete from tbl1;
 insert into tbl1 values (4400);
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 join tprt on tbl1.col1 < tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=1 loops=1)
    ->  Seq Scan on tbl1 (actual rows=1 loops=1)
    ->  Append (actual rows=1 loops=1)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt2_idx on tprt_2 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt3_idx on tprt_3 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (actual rows=1 loops=1)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 1
-(21 rows)
+         ->  Index Scan using tprt1_idx on tprt_1 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt2_idx on tprt_2 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt3_idx on tprt_3 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt6_idx on tprt_6 (actual rows=1 loops=1)
+               Index Cond: (tbl1.col1 < col1)
+(15 rows)
 
 select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 < tprt.col1
@@ -2228,30 +2170,24 @@ delete from tbl1;
 insert into tbl1 values (10000);
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 join tprt on tbl1.col1 = tprt.col1;
-                               QUERY PLAN                               
-------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Nested Loop (actual rows=0 loops=1)
    ->  Seq Scan on tbl1 (actual rows=1 loops=1)
    ->  Append (actual rows=0 loops=1)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (never executed)
+         ->  Index Scan using tprt1_idx on tprt_1 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt2_idx on tprt_2 (never executed)
+         ->  Index Scan using tprt2_idx on tprt_2 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt3_idx on tprt_3 (never executed)
+         ->  Index Scan using tprt3_idx on tprt_3 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+(15 rows)
 
 select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 = tprt.col1
@@ -2260,6 +2196,8 @@ order by tbl1.col1, tprt.col1;
 ------+------
 (0 rows)
 
+reset enable_seqscan;
+reset enable_bitmapscan;
 drop table tbl1, tprt;
 -- Test with columns defined in varying orders between each level
 create table part_abc (a int not null, b int not null, c int not null) partition by list (a);
@@ -2466,3 +2404,4 @@ select * from boolp where a = (select value from boolvalues where not value);
 (9 rows)
 
 drop table boolp;
+reset enable_indexonlyscan;
diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql
index 1d712b4ada..7d75c9adf9 100644
--- a/src/test/regress/sql/partition_prune.sql
+++ b/src/test/regress/sql/partition_prune.sql
@@ -256,6 +256,9 @@ create table ab_a3_b1 partition of ab_a3 for values in (1);
 create table ab_a3_b2 partition of ab_a3 for values in (2);
 create table ab_a3_b3 partition of ab_a3 for values in (3);
 
+-- disable to prevent variable "Heap Fetches:" output
+set enable_indexonlyscan = off;
+
 prepare ab_q1 (int, int, int) as
 select * from ab where a between $1 and $2 and b <= $3;
 
@@ -359,7 +362,7 @@ insert into lprt_a select 0 from generate_series(1,100);
 -- and insert some values that we should find.
 insert into lprt_a values(1),(1);
 
-analyze lprt_a;
+vacuum (analyze) lprt_a;
 
 create index ab_a2_b1_a_idx on ab_a2_b1 (a);
 create index ab_a2_b2_a_idx on ab_a2_b2 (a);
@@ -385,11 +388,13 @@ execute ab_q6 (1, 2, 3);
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (0, 0, 1);
 
 insert into lprt_a values(3),(3);
+vacuum (analyze) lprt_a;
 
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 3);
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
 
 delete from lprt_a where a = 1;
+vacuum (analyze) lprt_a;
 
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
 
@@ -435,6 +440,7 @@ create index tprt6_idx on tprt_6 (col1);
 
 insert into tprt values (10), (20), (501), (502), (505), (1001), (4500);
 
+vacuum (analyze) tprt;
 set enable_hashjoin = off;
 set enable_mergejoin = off;
 
@@ -454,6 +460,11 @@ order by tbl1.col1, tprt.col1;
 
 -- Multiple partitions
 insert into tbl1 values (1001), (1010), (1011);
+vacuum (analyze) tbl1;
+
+set enable_seqscan = off;
+set enable_bitmapscan = off;
+
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 inner join tprt on tbl1.col1 > tprt.col1;
 
@@ -488,6 +499,9 @@ select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 = tprt.col1
 order by tbl1.col1, tprt.col1;
 
+reset enable_seqscan;
+reset enable_bitmapscan;
+
 drop table tbl1, tprt;
 
 -- Test with columns defined in varying orders between each level
@@ -581,3 +595,5 @@ explain (analyze, costs off, summary off, timing off)
 select * from boolp where a = (select value from boolvalues where not value);
 
 drop table boolp;
+
+reset enable_indexonlyscan;
\ No newline at end of file

diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index 9762cc9748..df3fca025e 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -1347,6 +1347,10 @@ create table ab_a3 partition of ab for values in(3) partition by list (b);
 create table ab_a3_b1 partition of ab_a3 for values in (1);
 create table ab_a3_b2 partition of ab_a3 for values in (2);
 create table ab_a3_b3 partition of ab_a3 for values in (3);
+-- Disallow index only scans as concurrent transactions may stop visibility
+-- bits being set causing "Heap Fetches" to be unstable in the EXPLAIN ANALYZE
+-- output.
+set enable_indexonlyscan = off;
 prepare ab_q1 (int, int, int) as
 select * from ab where a between $1 and $2 and b <= $3;
 -- Execute query 5 times to allow choose_custom_plan
@@ -1754,8 +1758,8 @@ execute ab_q6 (1, 2, 3);
 (1 row)
 
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (0, 0, 1);
-                                               QUERY PLAN                                               
---------------------------------------------------------------------------------------------------------
+                                            QUERY PLAN                                             
+---------------------------------------------------------------------------------------------------
  Finalize Aggregate (actual rows=1 loops=1)
    ->  Gather (actual rows=2 loops=1)
          Workers Planned: 1
@@ -1765,39 +1769,30 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6 (0, 0, 1);
                      ->  Parallel Seq Scan on lprt_a a (actual rows=51 loops=2)
                            Filter: (a = ANY ('{0,0,1}'::integer[]))
                      ->  Append (actual rows=0 loops=102)
-                           ->  Index Only Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-(36 rows)
+(27 rows)
 
 insert into lprt_a values(3),(3);
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 3);
-                                               QUERY PLAN                                               
---------------------------------------------------------------------------------------------------------
+                                            QUERY PLAN                                             
+---------------------------------------------------------------------------------------------------
  Finalize Aggregate (actual rows=1 loops=1)
    ->  Gather (actual rows=2 loops=1)
          Workers Planned: 1
@@ -1807,38 +1802,29 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 3);
                      ->  Parallel Seq Scan on lprt_a a (actual rows=52 loops=2)
                            Filter: (a = ANY ('{1,0,3}'::integer[]))
                      ->  Append (actual rows=0 loops=104)
-                           ->  Index Only Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b1_a_idx on ab_a3_b1 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b2_a_idx on ab_a3_b2 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b3_a_idx on ab_a3_b3 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-(36 rows)
+(27 rows)
 
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
-                                               QUERY PLAN                                               
---------------------------------------------------------------------------------------------------------
+                                            QUERY PLAN                                             
+---------------------------------------------------------------------------------------------------
  Finalize Aggregate (actual rows=1 loops=1)
    ->  Gather (actual rows=2 loops=1)
          Workers Planned: 1
@@ -1849,39 +1835,30 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
                            Filter: (a = ANY ('{1,0,0}'::integer[]))
                            Rows Removed by Filter: 1
                      ->  Append (actual rows=0 loops=102)
-                           ->  Index Only Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (actual rows=0 loops=2)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-(37 rows)
+(28 rows)
 
 delete from lprt_a where a = 1;
 explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
-                                           QUERY PLAN                                            
--------------------------------------------------------------------------------------------------
+                                         QUERY PLAN                                         
+--------------------------------------------------------------------------------------------
  Finalize Aggregate (actual rows=1 loops=1)
    ->  Gather (actual rows=2 loops=1)
          Workers Planned: 1
@@ -1892,34 +1869,25 @@ explain (analyze, costs off, summary off, timing off) execute ab_q6 (1, 0, 0);
                            Filter: (a = ANY ('{1,0,0}'::integer[]))
                            Rows Removed by Filter: 1
                      ->  Append (actual rows=0 loops=100)
-                           ->  Index Only Scan using ab_a1_b1_a_idx on ab_a1_b1 (never executed)
+                           ->  Index Scan using ab_a1_b1_a_idx on ab_a1_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b2_a_idx on ab_a1_b2 (never executed)
+                           ->  Index Scan using ab_a1_b2_a_idx on ab_a1_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a1_b3_a_idx on ab_a1_b3 (never executed)
+                           ->  Index Scan using ab_a1_b3_a_idx on ab_a1_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
+                           ->  Index Scan using ab_a2_b1_a_idx on ab_a2_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
+                           ->  Index Scan using ab_a2_b2_a_idx on ab_a2_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
+                           ->  Index Scan using ab_a2_b3_a_idx on ab_a2_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
+                           ->  Index Scan using ab_a3_b1_a_idx on ab_a3_b1 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
+                           ->  Index Scan using ab_a3_b2_a_idx on ab_a3_b2 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-                           ->  Index Only Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
+                           ->  Index Scan using ab_a3_b3_a_idx on ab_a3_b3 (never executed)
                                  Index Cond: (a = a.a)
-                                 Heap Fetches: 0
-(37 rows)
+(28 rows)
 
 reset enable_hashjoin;
 reset enable_mergejoin;
@@ -2015,57 +1983,45 @@ set enable_hashjoin = off;
 set enable_mergejoin = off;
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 join tprt on tbl1.col1 > tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=6 loops=1)
    ->  Seq Scan on tbl1 (actual rows=2 loops=1)
    ->  Append (actual rows=3 loops=2)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (actual rows=2 loops=2)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 4
-         ->  Index Only Scan using tprt2_idx on tprt_2 (actual rows=2 loops=1)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 2
-         ->  Index Only Scan using tprt3_idx on tprt_3 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+         ->  Index Scan using tprt1_idx on tprt_1 (actual rows=2 loops=2)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt2_idx on tprt_2 (actual rows=2 loops=1)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt3_idx on tprt_3 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+(15 rows)
 
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 join tprt on tbl1.col1 = tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=2 loops=1)
    ->  Seq Scan on tbl1 (actual rows=2 loops=1)
    ->  Append (actual rows=1 loops=2)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (never executed)
+         ->  Index Scan using tprt1_idx on tprt_1 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
+         ->  Index Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 2
-         ->  Index Only Scan using tprt3_idx on tprt_3 (never executed)
+         ->  Index Scan using tprt3_idx on tprt_3 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+(15 rows)
 
 select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 > tprt.col1
@@ -2093,57 +2049,45 @@ order by tbl1.col1, tprt.col1;
 insert into tbl1 values (1001), (1010), (1011);
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 inner join tprt on tbl1.col1 > tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=23 loops=1)
    ->  Seq Scan on tbl1 (actual rows=5 loops=1)
    ->  Append (actual rows=5 loops=5)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (actual rows=2 loops=5)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 10
-         ->  Index Only Scan using tprt2_idx on tprt_2 (actual rows=3 loops=4)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 11
-         ->  Index Only Scan using tprt3_idx on tprt_3 (actual rows=1 loops=2)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 2
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
-               Index Cond: (col1 < tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+         ->  Index Scan using tprt1_idx on tprt_1 (actual rows=2 loops=5)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt2_idx on tprt_2 (actual rows=3 loops=4)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt3_idx on tprt_3 (actual rows=1 loops=2)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
+               Index Cond: (tbl1.col1 > col1)
+(15 rows)
 
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 inner join tprt on tbl1.col1 = tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=3 loops=1)
    ->  Seq Scan on tbl1 (actual rows=5 loops=1)
    ->  Append (actual rows=1 loops=5)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (never executed)
+         ->  Index Scan using tprt1_idx on tprt_1 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
+         ->  Index Scan using tprt2_idx on tprt_2 (actual rows=1 loops=2)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 2
-         ->  Index Only Scan using tprt3_idx on tprt_3 (actual rows=0 loops=3)
+         ->  Index Scan using tprt3_idx on tprt_3 (actual rows=0 loops=3)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 1
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+(15 rows)
 
 select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 > tprt.col1
@@ -2190,30 +2134,24 @@ delete from tbl1;
 insert into tbl1 values (4400);
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 join tprt on tbl1.col1 < tprt.col1;
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                                QUERY PLAN                                
+--------------------------------------------------------------------------
  Nested Loop (actual rows=1 loops=1)
    ->  Seq Scan on tbl1 (actual rows=1 loops=1)
    ->  Append (actual rows=1 loops=1)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt2_idx on tprt_2 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt3_idx on tprt_3 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (actual rows=1 loops=1)
-               Index Cond: (col1 > tbl1.col1)
-               Heap Fetches: 1
-(21 rows)
+         ->  Index Scan using tprt1_idx on tprt_1 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt2_idx on tprt_2 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt3_idx on tprt_3 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
+               Index Cond: (tbl1.col1 < col1)
+         ->  Index Scan using tprt6_idx on tprt_6 (actual rows=1 loops=1)
+               Index Cond: (tbl1.col1 < col1)
+(15 rows)
 
 select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 < tprt.col1
@@ -2228,30 +2166,24 @@ delete from tbl1;
 insert into tbl1 values (10000);
 explain (analyze, costs off, summary off, timing off)
 select * from tbl1 join tprt on tbl1.col1 = tprt.col1;
-                               QUERY PLAN                               
-------------------------------------------------------------------------
+                            QUERY PLAN                             
+-------------------------------------------------------------------
  Nested Loop (actual rows=0 loops=1)
    ->  Seq Scan on tbl1 (actual rows=1 loops=1)
    ->  Append (actual rows=0 loops=1)
-         ->  Index Only Scan using tprt1_idx on tprt_1 (never executed)
+         ->  Index Scan using tprt1_idx on tprt_1 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt2_idx on tprt_2 (never executed)
+         ->  Index Scan using tprt2_idx on tprt_2 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt3_idx on tprt_3 (never executed)
+         ->  Index Scan using tprt3_idx on tprt_3 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt4_idx on tprt_4 (never executed)
+         ->  Index Scan using tprt4_idx on tprt_4 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt5_idx on tprt_5 (never executed)
+         ->  Index Scan using tprt5_idx on tprt_5 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-         ->  Index Only Scan using tprt6_idx on tprt_6 (never executed)
+         ->  Index Scan using tprt6_idx on tprt_6 (never executed)
                Index Cond: (col1 = tbl1.col1)
-               Heap Fetches: 0
-(21 rows)
+(15 rows)
 
 select tbl1.col1, tprt.col1 from tbl1
 inner join tprt on tbl1.col1 = tprt.col1
@@ -2466,3 +2398,4 @@ select * from boolp where a = (select value from boolvalues where not value);
 (9 rows)
 
 drop table boolp;
+reset enable_indexonlyscan;
diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql
index 1d712b4ada..7fe93bbc04 100644
--- a/src/test/regress/sql/partition_prune.sql
+++ b/src/test/regress/sql/partition_prune.sql
@@ -256,6 +256,11 @@ create table ab_a3_b1 partition of ab_a3 for values in (1);
 create table ab_a3_b2 partition of ab_a3 for values in (2);
 create table ab_a3_b3 partition of ab_a3 for values in (3);
 
+-- Disallow index only scans as concurrent transactions may stop visibility
+-- bits being set causing "Heap Fetches" to be unstable in the EXPLAIN ANALYZE
+-- output.
+set enable_indexonlyscan = off;
+
 prepare ab_q1 (int, int, int) as
 select * from ab where a between $1 and $2 and b <= $3;
 
@@ -581,3 +586,5 @@ explain (analyze, costs off, summary off, timing off)
 select * from boolp where a = (select value from boolvalues where not value);
 
 drop table boolp;
+
+reset enable_indexonlyscan;
\ No newline at end of file

From 18260f490a3d8355e09c18e216fc1ec743df1432 Mon Sep 17 00:00:00 2001
From: "dgrowley@gmail.com" <dgrowley@gmail.com>
Date: Mon, 9 Apr 2018 14:49:01 +1200
Subject: [PATCH 1/2] Fix incorrect logic for choosing the next Parallel Append
 subplan

In 499be013de support for pruning unneeded Append subnodes was added. The
logic in that commit was not correct and was not correctly checking if the
next subplan was in fact a valid subplan. This could cause parallel workers
processes to be given a subplan to work on which didn't require any work.

In passing also add a comment to explain what first_partial_plan means.
---
 src/backend/executor/nodeAppend.c | 54 ++++++++++++++++++++++++++++++---------
 src/include/nodes/plannodes.h     |  5 ++++
 2 files changed, 47 insertions(+), 12 deletions(-)

diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index b135b61324..ddca1b2a2a 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -547,6 +547,11 @@ choose_next_subplan_for_leader(AppendState *node)
 			LWLockRelease(&pstate->pa_lock);
 			return false;
 		}
+
+		/*
+		 * We needn't pay attention to as_valid_subplans here as all invalid
+		 * plans have been marked as finished.
+		 */
 		node->as_whichplan--;
 	}
 
@@ -612,18 +617,32 @@ choose_next_subplan_for_worker(AppendState *node)
 	/* Save the plan from which we are starting the search. */
 	node->as_whichplan = pstate->pa_next_plan;
 
-	/* Loop until we find a subplan to execute. */
+	/* Loop until we find a valid subplan to execute. */
 	while (pstate->pa_finished[pstate->pa_next_plan])
 	{
-		if (pstate->pa_next_plan < node->as_nplans - 1)
+		int			nextplan = bms_next_member(node->as_valid_subplans,
+											   pstate->pa_next_plan);
+
+		if (nextplan >= 0)
 		{
-			/* Advance to next plan. */
-			pstate->pa_next_plan++;
+			/* Advance to the next valid plan. */
+			pstate->pa_next_plan = nextplan;
 		}
 		else if (node->as_whichplan > append->first_partial_plan)
 		{
-			/* Loop back to first partial plan. */
-			pstate->pa_next_plan = append->first_partial_plan;
+			/* Try looping back to first valid partial plan. */
+			nextplan = bms_next_member(node->as_valid_subplans,
+									   append->first_partial_plan - 1);
+
+			/*
+			 * There mightn't be any valid partial plans.  If there's none
+			 * then set pa_next_plan to as_whichplan so that we exit in the
+			 * test below, otherwise just select the first valid partial plan.
+			 */
+			if (nextplan < 0)
+				pstate->pa_next_plan = node->as_whichplan;
+			else
+				pstate->pa_next_plan = nextplan;
 		}
 		else
 		{
@@ -644,16 +663,27 @@ choose_next_subplan_for_worker(AppendState *node)
 	}
 
 	/* Pick the plan we found, and advance pa_next_plan one more time. */
-	node->as_whichplan = pstate->pa_next_plan++;
-	if (pstate->pa_next_plan >= node->as_nplans)
+	node->as_whichplan = pstate->pa_next_plan;
+	pstate->pa_next_plan = bms_next_member(node->as_valid_subplans,
+										   pstate->pa_next_plan);
+
+	/*
+	 * If there are no more valid plans then try setting the next plan to the
+	 * first valid partial plan.
+	 */
+	if (pstate->pa_next_plan < 0)
 	{
-		if (append->first_partial_plan < node->as_nplans)
-			pstate->pa_next_plan = append->first_partial_plan;
+		int			nextplan = bms_next_member(node->as_valid_subplans,
+											   append->first_partial_plan - 1);
+
+		if (nextplan >= 0)
+			pstate->pa_next_plan = nextplan;
 		else
 		{
 			/*
-			 * We have only non-partial plans, and we already chose the last
-			 * one; so arrange for the other workers to immediately bail out.
+			 * There are no valid partial plans, and we already chose the last
+			 * non-partial plan; so flag that there's nothing more for our
+			 * fellow workers to do.
 			 */
 			pstate->pa_next_plan = INVALID_SUBPLAN_INDEX;
 		}
diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index c3e5c2c79f..c5c33cd336 100644
--- a/src/include/nodes/plannodes.h
+++ b/src/include/nodes/plannodes.h
@@ -255,6 +255,11 @@ typedef struct Append
 	/* RT indexes of non-leaf tables in a partition tree */
 	List	   *partitioned_rels;
 	List	   *appendplans;
+
+	/*
+	 * All 'appendplans' preceding this index are non-partial plans. All
+	 * 'appendplans' from this index onwards are partial plans.
+	 */
 	int			first_partial_plan;
 
 	/*
-- 
2.16.2.windows.1

From 88d74aa37e95f34000ab19f704994da9e4c2e7f7 Mon Sep 17 00:00:00 2001
From: "dgrowley@gmail.com" <dgrowley@gmail.com>
Date: Mon, 9 Apr 2018 14:53:49 +1200
Subject: [PATCH 2/2] Fix misleading comment and typo

Clean up of 499be013de
---
 src/backend/executor/execPartition.c | 5 ++---
 src/include/partitioning/partprune.h | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 50bea2c2ce..b9d5159354 100644
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1524,9 +1524,8 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubnodes)
 
 	/*
 	 * Record that partition pruning has been performed for external params.
-	 * This partly also serves to ensure we never call this function twice
-	 * with the same input and also so that ExecFindMatchingSubPlans is aware
-	 * that pruning has already been performed for external Params.
+	 * These are not required again and NULLifying them helps ensure nothing
+	 * accidentally calls this function twice on the same PartitionPruneState.
 	 */
 	bms_free(prunestate->extparams);
 	prunestate->extparams = NULL;
diff --git a/src/include/partitioning/partprune.h b/src/include/partitioning/partprune.h
index f68b6c9935..2ae2fd16ed 100644
--- a/src/include/partitioning/partprune.h
+++ b/src/include/partitioning/partprune.h
@@ -40,7 +40,7 @@ typedef struct PartitionPruneContext
 
 	/*
 	 * Can be set when the context is used from the executor to allow params
-	 * found matching the partition key to be evaulated.
+	 * found matching the partition key to be evaluated.
 	 */
 	PlanState  *planstate;
 
-- 
2.16.2.windows.1

From 10b29c7706efd00279182164de14592643ff7f40 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Mon, 9 Apr 2018 18:42:04 -0300
Subject: [PATCH 1/2] print nfiltered3

---
 src/backend/commands/explain.c    | 4 +++-
 src/backend/executor/instrument.c | 1 +
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 989b6aad67..347fbbe1cf 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -2592,7 +2592,9 @@ show_instrumentation_count(const char *qlabel, int which,
 	if (!es->analyze || !planstate->instrument)
 		return;
 
-	if (which == 2)
+	if (which == 3)
+		nfiltered = planstate->instrument->nfiltered3;
+	else if (which == 2)
 		nfiltered = planstate->instrument->nfiltered2;
 	else
 		nfiltered = planstate->instrument->nfiltered1;
diff --git a/src/backend/executor/instrument.c b/src/backend/executor/instrument.c
index 86252cee1f..d3045f57ac 100644
--- a/src/backend/executor/instrument.c
+++ b/src/backend/executor/instrument.c
@@ -159,6 +159,7 @@ InstrAggNode(Instrumentation *dst, Instrumentation *add)
 	dst->nloops += add->nloops;
 	dst->nfiltered1 += add->nfiltered1;
 	dst->nfiltered2 += add->nfiltered2;
+	dst->nfiltered3 += add->nfiltered3;
 
 	/* Add delta of buffer usage since entry to node's totals */
 	if (dst->need_bufusage)
-- 
2.11.0

From acaf8e8af643f05605eab21ad3e5a04a8714f06a Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Mon, 9 Apr 2018 18:41:20 -0300
Subject: [PATCH 2/2] use nfiltered3 instead of ad-hoc counter

---
 src/backend/commands/explain.c           | 8 ++------
 src/backend/executor/nodeIndexonlyscan.c | 3 +--
 src/include/nodes/execnodes.h            | 1 -
 3 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 347fbbe1cf..434051e7df 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -1459,12 +1459,8 @@ ExplainNode(PlanState *planstate, List *ancestors,
 				show_instrumentation_count("Rows Removed by Filter", 1,
 										   planstate, es);
 			if (es->analyze)
-			{
-				long		heapFetches =
-					((IndexOnlyScanState *) planstate)->ioss_HeapFetches;
-
-				ExplainPropertyInteger("Heap Fetches", NULL, heapFetches, es);
-			}
+				ExplainPropertyInteger("Heap Fetches", NULL,
+									   planstate->instrument->nfiltered3, es);
 			break;
 		case T_BitmapIndexScan:
 			show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig,
diff --git a/src/backend/executor/nodeIndexonlyscan.c b/src/backend/executor/nodeIndexonlyscan.c
index ddc0ae9061..ef835f13c2 100644
--- a/src/backend/executor/nodeIndexonlyscan.c
+++ b/src/backend/executor/nodeIndexonlyscan.c
@@ -162,7 +162,7 @@ IndexOnlyNext(IndexOnlyScanState *node)
 			/*
 			 * Rats, we have to visit the heap to check visibility.
 			 */
-			node->ioss_HeapFetches++;
+			InstrCountFiltered3(node, 1);
 			tuple = index_fetch_heap(scandesc);
 			if (tuple == NULL)
 				continue;		/* no visible tuple, try next index entry */
@@ -509,7 +509,6 @@ ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
 	indexstate->ss.ps.plan = (Plan *) node;
 	indexstate->ss.ps.state = estate;
 	indexstate->ss.ps.ExecProcNode = ExecIndexOnlyScan;
-	indexstate->ioss_HeapFetches = 0;
 
 	/*
 	 * Miscellaneous initialization
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 06456f07cc..d00839c161 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -1387,7 +1387,6 @@ typedef struct IndexOnlyScanState
 	Relation	ioss_RelationDesc;
 	IndexScanDesc ioss_ScanDesc;
 	Buffer		ioss_VMBuffer;
-	long		ioss_HeapFetches;
 	Size		ioss_PscanLen;
 } IndexOnlyScanState;
 
-- 
2.11.0

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 989b6aad67..fe0419311b 100644
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 1459,1470 **** ExplainNode(PlanState *planstate, List *ancestors,
  				show_instrumentation_count("Rows Removed by Filter", 1,
  										   planstate, es);
  			if (es->analyze)
! 			{
! 				long		heapFetches =
! 					((IndexOnlyScanState *) planstate)->ioss_HeapFetches;
! 
! 				ExplainPropertyInteger("Heap Fetches", NULL, heapFetches, es);
! 			}
  			break;
  		case T_BitmapIndexScan:
  			show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig,
--- 1459,1466 ----
  				show_instrumentation_count("Rows Removed by Filter", 1,
  										   planstate, es);
  			if (es->analyze)
! 				ExplainPropertyInteger("Heap Fetches", NULL,
! 									   planstate->instrument->ntuples2, es);
  			break;
  		case T_BitmapIndexScan:
  			show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig,
diff --git a/src/backend/executor/insindex 86252cee1f..fe5d55904d 100644
*** a/src/backend/executor/instrument.c
--- b/src/backend/executor/instrument.c
***************
*** 156,161 **** InstrAggNode(Instrumentation *dst, Instrumentation *add)
--- 156,162 ----
  	dst->startup += add->startup;
  	dst->total += add->total;
  	dst->ntuples += add->ntuples;
+ 	dst->ntuples2 += add->ntuples2;
  	dst->nloops += add->nloops;
  	dst->nfiltered1 += add->nfiltered1;
  	dst->nfiltered2 += add->nfiltered2;
diff --git a/src/backend/executor/nodeInindex ddc0ae9061..3a02a99621 100644
*** a/src/backend/executor/nodeIndexonlyscan.c
--- b/src/backend/executor/nodeIndexonlyscan.c
***************
*** 162,168 **** IndexOnlyNext(IndexOnlyScanState *node)
  			/*
  			 * Rats, we have to visit the heap to check visibility.
  			 */
! 			node->ioss_HeapFetches++;
  			tuple = index_fetch_heap(scandesc);
  			if (tuple == NULL)
  				continue;		/* no visible tuple, try next index entry */
--- 162,168 ----
  			/*
  			 * Rats, we have to visit the heap to check visibility.
  			 */
! 			InstrCountTuples2(node, 1);
  			tuple = index_fetch_heap(scandesc);
  			if (tuple == NULL)
  				continue;		/* no visible tuple, try next index entry */
***************
*** 509,515 **** ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
  	indexstate->ss.ps.plan = (Plan *) node;
  	indexstate->ss.ps.state = estate;
  	indexstate->ss.ps.ExecProcNode = ExecIndexOnlyScan;
- 	indexstate->ioss_HeapFetches = 0;
  
  	/*
  	 * Miscellaneous initialization
--- 509,514 ----
diff --git a/src/include/executor/instrument.h index 28eb0093d4..0ba407f83a 100644
*** a/src/include/executor/instrument.h
--- b/src/include/executor/instrument.h
***************
*** 57,62 **** typedef struct Instrumentation
--- 57,63 ----
  	double		startup;		/* Total startup time (in seconds) */
  	double		total;			/* Total total time (in seconds) */
  	double		ntuples;		/* Total tuples produced */
+ 	double		ntuples2;		/* Secondary generic tuple counter */
  	double		nloops;			/* # of run cycles for this node */
  	double		nfiltered1;		/* # tuples removed by scanqual or joinqual OR
  								 * # tuples inserted by MERGE */
diff --git a/src/include/nodes/execnodesindex 06456f07cc..deab875466 100644
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 1004,1009 **** typedef struct PlanState
--- 1004,1014 ----
  #define outerPlanState(node)		(((PlanState *)(node))->lefttree)
  
  /* Macros for inline access to certain instrumentation counters */
+ #define InstrCountTuples2(node, delta) \
+ 	do { \
+ 		if (((PlanState *)(node))->instrument) \
+ 			((PlanState *)(node))->instrument->ntuples2 += (delta); \
+ 	} while (0)
  #define InstrCountFiltered1(node, delta) \
  	do { \
  		if (((PlanState *)(node))->instrument) \
***************
*** 1368,1374 **** typedef struct IndexScanState
   *		RelationDesc	   index relation descriptor
   *		ScanDesc		   index scan descriptor
   *		VMBuffer		   buffer in use for visibility map testing, if any
-  *		HeapFetches		   number of tuples we were forced to fetch from heap
   *		ioss_PscanLen	   Size of parallel index-only scan descriptor
   * ----------------
   */
--- 1373,1378 ----

diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c
index d062cfddac..188399cc12 100644
--- a/src/backend/executor/nodeAppend.c
+++ b/src/backend/executor/nodeAppend.c
@@ -204,6 +204,13 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 	appendplanstates = (PlanState **) palloc(nplans *
 											 sizeof(PlanState *));
 
+	/*
+	 * We must determine the first valid partial plan.  Default this to point
+	 * beyond the final valid plan.  We'll determine the actual first valid
+	 * partial subplan in the loop below.
+	 */
+	appendstate->as_first_partial_plan = nplans;
+
 	/*
 	 * call ExecInitNode on each of the valid plans to be executed and save
 	 * the results into the appendplanstates array.
@@ -215,6 +222,13 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
 		{
 			Plan	   *initNode = (Plan *) lfirst(lc);
 
+			/*
+			 * Record the lowest appendplanstates index which is a partial
+			 * plan.
+			 */
+			if (i >= node->first_partial_plan && j < appendstate->as_first_partial_plan)
+				appendstate->as_first_partial_plan = j;
+
 			appendplanstates[j++] = ExecInitNode(initNode, estate, eflags);
 		}
 		i++;
@@ -556,7 +570,7 @@ choose_next_subplan_for_leader(AppendState *node)
 	}
 
 	/* If non-partial, immediately mark as finished. */
-	if (node->as_whichplan < append->first_partial_plan)
+	if (node->as_whichplan < node->as_first_partial_plan)
 		node->as_pstate->pa_finished[node->as_whichplan] = true;
 
 	LWLockRelease(&pstate->pa_lock);
@@ -629,14 +643,14 @@ choose_next_subplan_for_worker(AppendState *node)
 			/* Advance to the next valid plan. */
 			pstate->pa_next_plan = nextplan;
 		}
-		else if (node->as_whichplan > append->first_partial_plan)
+		else if (node->as_whichplan > node->as_first_partial_plan)
 		{
 			/*
 			 * Try looping back to the first valid partial plan, if there is
 			 * one.  If there isn't, arrange to bail out below.
 			 */
 			nextplan = bms_next_member(node->as_valid_subplans,
-									   append->first_partial_plan - 1);
+									   node->as_first_partial_plan - 1);
 			pstate->pa_next_plan =
 				nextplan < 0 ? node->as_whichplan : nextplan;
 		}
@@ -670,7 +684,7 @@ choose_next_subplan_for_worker(AppendState *node)
 	if (pstate->pa_next_plan < 0)
 	{
 		int			nextplan = bms_next_member(node->as_valid_subplans,
-											   append->first_partial_plan - 1);
+											   node->as_first_partial_plan - 1);
 
 		if (nextplan >= 0)
 			pstate->pa_next_plan = nextplan;
@@ -686,7 +700,7 @@ choose_next_subplan_for_worker(AppendState *node)
 	}
 
 	/* If non-partial, immediately mark as finished. */
-	if (node->as_whichplan < append->first_partial_plan)
+	if (node->as_whichplan < node->as_first_partial_plan)
 		node->as_pstate->pa_finished[node->as_whichplan] = true;
 
 	LWLockRelease(&pstate->pa_lock);
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index deab875466..cff64337e2 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -1150,6 +1150,8 @@ struct AppendState
 	PlanState **appendplans;	/* array of PlanStates for my inputs */
 	int			as_nplans;
 	int			as_whichplan;
+	int			as_first_partial_plan; /* Index of 'appendplans' containing
+										* the first partial plan */
 	ParallelAppendState *as_pstate; /* parallel coordination info */
 	Size		pstate_len;		/* size of parallel coordination info */
 	struct PartitionPruneState *as_prune_state;