v5-0001-Add-parallel-columns-for-pg_stat_all_tables-index.patch

From 92474720b3178f74517958fededcf6797de58552 Mon Sep 17 00:00:00 2001
From: Guillaume Lelarge <guillaume.lelarge@dalibo.com>
Date: Sun, 6 Oct 2024 21:50:17 +0200
Subject: [PATCH v5] Add parallel columns for pg_stat_all_tables,indexes

pg_stat_all_tables gets 4 new columns: parallel_seq_scan,
last_parallel_seq_scan, parallel_idx_scan, last_parallel_idx_scan.

pg_stat_all_indexes gets 2 new columns: parallel_idx_scan,
last_parallel_idx_scan.
---
 doc/src/sgml/monitoring.sgml                 |  69 ++++++-
 src/backend/access/brin/brin.c               |   2 +-
 src/backend/access/gin/ginscan.c             |   2 +-
 src/backend/access/gist/gistget.c            |   4 +-
 src/backend/access/hash/hashsearch.c         |   2 +-
 src/backend/access/heap/heapam.c             |   2 +-
 src/backend/access/nbtree/nbtsearch.c        |  12 +-
 src/backend/access/spgist/spgscan.c          |   2 +-
 src/backend/catalog/system_views.sql         |   6 +
 src/backend/utils/activity/pgstat_relation.c |   8 +
 src/backend/utils/adt/pgstatfuncs.c          |   6 +
 src/include/catalog/pg_proc.dat              |   8 +
 src/include/pgstat.h                         |  17 +-
 src/test/regress/expected/rules.out          |  18 ++
 src/test/regress/expected/stats.out          | 194 +++++++++++++++++++
 src/test/regress/sql/stats.sql               |  92 +++++++++
 16 files changed, 421 insertions(+), 23 deletions(-)

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 331315f8d3..aeaabb0ffe 100644
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -3803,7 +3803,7 @@ description | Waiting for a newly initialized WAL file to reach durable storage
        <structfield>seq_scan</structfield> <type>bigint</type>
       </para>
       <para>
-       Number of sequential scans initiated on this table
+       Number of sequential scans (including parallel ones) initiated on this table
       </para></entry>
      </row>
 
@@ -3812,7 +3812,26 @@ description | Waiting for a newly initialized WAL file to reach durable storage
        <structfield>last_seq_scan</structfield> <type>timestamp with time zone</type>
       </para>
       <para>
-       The time of the last sequential scan on this table, based on the
+       The time of the last sequential scan (including parallel ones) on this table, based on the
+       most recent transaction stop time
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>parallel_seq_scan</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Number of parallel sequential scans initiated on this table
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>last_parallel_seq_scan</structfield> <type>timestamp with time zone</type>
+      </para>
+      <para>
+       The time of the last parallel sequential scan on this table, based on the
        most recent transaction stop time
       </para></entry>
      </row>
@@ -3831,7 +3850,7 @@ description | Waiting for a newly initialized WAL file to reach durable storage
        <structfield>idx_scan</structfield> <type>bigint</type>
       </para>
       <para>
-       Number of index scans initiated on this table
+       Number of index scans (including parallel ones) initiated on this table
       </para></entry>
      </row>
 
@@ -3840,7 +3859,26 @@ description | Waiting for a newly initialized WAL file to reach durable storage
        <structfield>last_idx_scan</structfield> <type>timestamp with time zone</type>
       </para>
       <para>
-       The time of the last index scan on this table, based on the
+       The time of the last index scan (including parallel ones) on this table, based on the
+       most recent transaction stop time
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>parallel_idx_scan</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Number of parallel index scans initiated on this table
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>last_parallel_idx_scan</structfield> <type>timestamp with time zone</type>
+      </para>
+      <para>
+       The time of the last parallel index scan on this table, based on the
        most recent transaction stop time
       </para></entry>
      </row>
@@ -4110,7 +4148,7 @@ description | Waiting for a newly initialized WAL file to reach durable storage
        <structfield>idx_scan</structfield> <type>bigint</type>
       </para>
       <para>
-       Number of index scans initiated on this index
+       Number of index scans (including parallel ones) initiated on this index
       </para></entry>
      </row>
 
@@ -4119,7 +4157,26 @@ description | Waiting for a newly initialized WAL file to reach durable storage
        <structfield>last_idx_scan</structfield> <type>timestamp with time zone</type>
       </para>
       <para>
-       The time of the last scan on this index, based on the
+       The time of the last scan on this index(including parallel ones), based
+       on the most recent transaction stop time
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>parallel_idx_scan</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Number of parallel index scans initiated on this index
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>last_parallel_idx_scan</structfield> <type>timestamp with time zone</type>
+      </para>
+      <para>
+       The time of the last parallel scan on this index, based on the
        most recent transaction stop time
       </para></entry>
      </row>
diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c
index c0b978119a..0fffa67301 100644
--- a/src/backend/access/brin/brin.c
+++ b/src/backend/access/brin/brin.c
@@ -584,7 +584,7 @@ bringetbitmap(IndexScanDesc scan, TIDBitmap *tbm)
 
 	opaque = (BrinOpaque *) scan->opaque;
 	bdesc = opaque->bo_bdesc;
-	pgstat_count_index_scan(idxRel);
+	pgstat_count_index_scan(idxRel, false);
 
 	/*
 	 * We need to know the size of the table so that we know how long to
diff --git a/src/backend/access/gin/ginscan.c b/src/backend/access/gin/ginscan.c
index f2fd62afbb..d2001d6054 100644
--- a/src/backend/access/gin/ginscan.c
+++ b/src/backend/access/gin/ginscan.c
@@ -435,7 +435,7 @@ ginNewScanKey(IndexScanDesc scan)
 
 	MemoryContextSwitchTo(oldCtx);
 
-	pgstat_count_index_scan(scan->indexRelation);
+	pgstat_count_index_scan(scan->indexRelation, false);
 }
 
 void
diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c
index b35b8a9757..7e89382ce5 100644
--- a/src/backend/access/gist/gistget.c
+++ b/src/backend/access/gist/gistget.c
@@ -624,7 +624,7 @@ gistgettuple(IndexScanDesc scan, ScanDirection dir)
 		/* Begin the scan by processing the root page */
 		GISTSearchItem fakeItem;
 
-		pgstat_count_index_scan(scan->indexRelation);
+		pgstat_count_index_scan(scan->indexRelation, false);
 
 		so->firstCall = false;
 		so->curPageData = so->nPageData = 0;
@@ -749,7 +749,7 @@ gistgetbitmap(IndexScanDesc scan, TIDBitmap *tbm)
 	if (!so->qual_ok)
 		return 0;
 
-	pgstat_count_index_scan(scan->indexRelation);
+	pgstat_count_index_scan(scan->indexRelation, false);
 
 	/* Begin the scan by processing the root page */
 	so->curPageData = so->nPageData = 0;
diff --git a/src/backend/access/hash/hashsearch.c b/src/backend/access/hash/hashsearch.c
index 0d99d6abc8..a63edc8372 100644
--- a/src/backend/access/hash/hashsearch.c
+++ b/src/backend/access/hash/hashsearch.c
@@ -297,7 +297,7 @@ _hash_first(IndexScanDesc scan, ScanDirection dir)
 	HashPageOpaque opaque;
 	HashScanPosItem *currItem;
 
-	pgstat_count_index_scan(rel);
+	pgstat_count_index_scan(rel, false);
 
 	/*
 	 * We do not support hash scans with no index qualification, because we
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index da5e656a08..099b08242f 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -400,7 +400,7 @@ initscan(HeapScanDesc scan, ScanKey key, bool keep_startblock)
 	 * and for sample scans we update stats for tuple fetches).
 	 */
 	if (scan->rs_base.rs_flags & SO_TYPE_SEQSCAN)
-		pgstat_count_heap_scan(scan->rs_base.rs_rd);
+		pgstat_count_heap_scan(scan->rs_base.rs_rd, (scan->rs_base.rs_parallel != NULL));
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index fff7c89ead..8115b0fa2d 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -912,6 +912,12 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 		return false;
 	}
 
+	/*
+	 * Count an indexscan for stats, now that we know that we'll call
+	 * _bt_search/_bt_endpoint below
+	 */
+	pgstat_count_index_scan(rel, (scan->parallel_scan != NULL));
+
 	/*
 	 * For parallel scans, get the starting page from shared state. If the
 	 * scan has not started, proceed to find out first leaf page in the usual
@@ -958,12 +964,6 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 		_bt_start_array_keys(scan, dir);
 	}
 
-	/*
-	 * Count an indexscan for stats, now that we know that we'll call
-	 * _bt_search/_bt_endpoint below
-	 */
-	pgstat_count_index_scan(rel);
-
 	/*----------
 	 * Examine the scan keys to discover where we need to start the scan.
 	 *
diff --git a/src/backend/access/spgist/spgscan.c b/src/backend/access/spgist/spgscan.c
index 3017861859..fe3c9979df 100644
--- a/src/backend/access/spgist/spgscan.c
+++ b/src/backend/access/spgist/spgscan.c
@@ -420,7 +420,7 @@ spgrescan(IndexScanDesc scan, ScanKey scankey, int nscankeys,
 	resetSpGistScanOpaque(so);
 
 	/* count an indexscan for stats */
-	pgstat_count_index_scan(scan->indexRelation);
+	pgstat_count_index_scan(scan->indexRelation, false);
 }
 
 void
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 3456b821bc..b062af32fb 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -670,9 +670,13 @@ CREATE VIEW pg_stat_all_tables AS
             C.relname AS relname,
             pg_stat_get_numscans(C.oid) AS seq_scan,
             pg_stat_get_lastscan(C.oid) AS last_seq_scan,
+            pg_stat_get_parallelnumscans(C.oid) AS parallel_seq_scan,
+            pg_stat_get_parallellastscan(C.oid) AS last_parallel_seq_scan,
             pg_stat_get_tuples_returned(C.oid) AS seq_tup_read,
             sum(pg_stat_get_numscans(I.indexrelid))::bigint AS idx_scan,
             max(pg_stat_get_lastscan(I.indexrelid)) AS last_idx_scan,
+            sum(pg_stat_get_parallelnumscans(I.indexrelid))::bigint AS parallel_idx_scan,
+            max(pg_stat_get_parallellastscan(I.indexrelid)) AS last_parallel_idx_scan,
             sum(pg_stat_get_tuples_fetched(I.indexrelid))::bigint +
             pg_stat_get_tuples_fetched(C.oid) AS idx_tup_fetch,
             pg_stat_get_tuples_inserted(C.oid) AS n_tup_ins,
@@ -792,6 +796,8 @@ CREATE VIEW pg_stat_all_indexes AS
             I.relname AS indexrelname,
             pg_stat_get_numscans(I.oid) AS idx_scan,
             pg_stat_get_lastscan(I.oid) AS last_idx_scan,
+            pg_stat_get_parallelnumscans(I.oid) AS parallel_idx_scan,
+            pg_stat_get_parallellastscan(I.oid) AS last_parallel_idx_scan,
             pg_stat_get_tuples_returned(I.oid) AS idx_tup_read,
             pg_stat_get_tuples_fetched(I.oid) AS idx_tup_fetch
     FROM pg_class C JOIN
diff --git a/src/backend/utils/activity/pgstat_relation.c b/src/backend/utils/activity/pgstat_relation.c
index 8a3f7d434c..766c56524e 100644
--- a/src/backend/utils/activity/pgstat_relation.c
+++ b/src/backend/utils/activity/pgstat_relation.c
@@ -829,12 +829,20 @@ pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait)
 	tabentry = &shtabstats->stats;
 
 	tabentry->numscans += lstats->counts.numscans;
+	tabentry->parallelnumscans += lstats->counts.parallelnumscans;
+
+	/*
+	 * Don't check counts.parallelnumscans because counts.numscans includes
+	 * counts.parallelnumscans.
+	 */
 	if (lstats->counts.numscans)
 	{
 		TimestampTz t = GetCurrentTransactionStopTimestamp();
 
 		if (t > tabentry->lastscan)
 			tabentry->lastscan = t;
+		if (t > tabentry->parallellastscan && lstats->counts.parallelnumscans)
+			tabentry->parallellastscan = t;
 	}
 	tabentry->tuples_returned += lstats->counts.tuples_returned;
 	tabentry->tuples_fetched += lstats->counts.tuples_fetched;
diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c
index f7b50e0b5a..2bb2e7bdbc 100644
--- a/src/backend/utils/adt/pgstatfuncs.c
+++ b/src/backend/utils/adt/pgstatfuncs.c
@@ -82,6 +82,9 @@ PG_STAT_GET_RELENTRY_INT64(mod_since_analyze)
 /* pg_stat_get_numscans */
 PG_STAT_GET_RELENTRY_INT64(numscans)
 
+/* pg_stat_get_parallelnumscans */
+PG_STAT_GET_RELENTRY_INT64(parallelnumscans)
+
 /* pg_stat_get_tuples_deleted */
 PG_STAT_GET_RELENTRY_INT64(tuples_deleted)
 
@@ -140,6 +143,9 @@ PG_STAT_GET_RELENTRY_TIMESTAMPTZ(last_vacuum_time)
 /* pg_stat_get_lastscan */
 PG_STAT_GET_RELENTRY_TIMESTAMPTZ(lastscan)
 
+/* pg_stat_get_parallellastscan */
+PG_STAT_GET_RELENTRY_TIMESTAMPTZ(parallellastscan)
+
 Datum
 pg_stat_get_function_calls(PG_FUNCTION_ARGS)
 {
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 77f54a79e6..e92a924dd2 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5443,6 +5443,14 @@
   proname => 'pg_stat_get_lastscan', provolatile => 's', proparallel => 'r',
   prorettype => 'timestamptz', proargtypes => 'oid',
   prosrc => 'pg_stat_get_lastscan' },
+{ oid => '9000', descr => 'statistics: number of parallel scans done for table/index',
+  proname => 'pg_stat_get_parallelnumscans', provolatile => 's', proparallel => 'r',
+  prorettype => 'int8', proargtypes => 'oid',
+  prosrc => 'pg_stat_get_parallelnumscans' },
+{ oid => '9001', descr => 'statistics: time of the last parallel scan for table/index',
+  proname => 'pg_stat_get_parallellastscan', provolatile => 's', proparallel => 'r',
+  prorettype => 'timestamptz', proargtypes => 'oid',
+  prosrc => 'pg_stat_get_parallellastscan' },
 { oid => '1929', descr => 'statistics: number of tuples read by seqscan',
   proname => 'pg_stat_get_tuples_returned', provolatile => 's',
   proparallel => 'r', prorettype => 'int8', proargtypes => 'oid',
diff --git a/src/include/pgstat.h b/src/include/pgstat.h
index df53fa2d4f..55dbeefd24 100644
--- a/src/include/pgstat.h
+++ b/src/include/pgstat.h
@@ -192,6 +192,7 @@ typedef struct PgStat_BackendSubEntry
 typedef struct PgStat_TableCounts
 {
 	PgStat_Counter numscans;
+	PgStat_Counter parallelnumscans;
 
 	PgStat_Counter tuples_returned;
 	PgStat_Counter tuples_fetched;
@@ -435,6 +436,8 @@ typedef struct PgStat_StatTabEntry
 {
 	PgStat_Counter numscans;
 	TimestampTz lastscan;
+	PgStat_Counter parallelnumscans;
+	TimestampTz parallellastscan;
 
 	PgStat_Counter tuples_returned;
 	PgStat_Counter tuples_fetched;
@@ -642,10 +645,13 @@ extern void pgstat_report_analyze(Relation rel,
 
 /* nontransactional event counts are simple enough to inline */
 
-#define pgstat_count_heap_scan(rel)									\
+#define pgstat_count_heap_scan(rel, parallel)						\
 	do {															\
-		if (pgstat_should_count_relation(rel))						\
+		if (pgstat_should_count_relation(rel)) {					\
 			(rel)->pgstat_info->counts.numscans++;					\
+			if (parallel)											\
+				(rel)->pgstat_info->counts.parallelnumscans++;		\
+		}															\
 	} while (0)
 #define pgstat_count_heap_getnext(rel)								\
 	do {															\
@@ -657,10 +663,13 @@ extern void pgstat_report_analyze(Relation rel,
 		if (pgstat_should_count_relation(rel))						\
 			(rel)->pgstat_info->counts.tuples_fetched++;			\
 	} while (0)
-#define pgstat_count_index_scan(rel)								\
+#define pgstat_count_index_scan(rel, parallel)						\
 	do {															\
-		if (pgstat_should_count_relation(rel))						\
+		if (pgstat_should_count_relation(rel)) {					\
 			(rel)->pgstat_info->counts.numscans++;					\
+			if (parallel)											\
+				(rel)->pgstat_info->counts.parallelnumscans++;		\
+		}															\
 	} while (0)
 #define pgstat_count_index_tuples(rel, n)							\
 	do {															\
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 2b47013f11..a8c390fd89 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1772,6 +1772,8 @@ pg_stat_all_indexes| SELECT c.oid AS relid,
     i.relname AS indexrelname,
     pg_stat_get_numscans(i.oid) AS idx_scan,
     pg_stat_get_lastscan(i.oid) AS last_idx_scan,
+    pg_stat_get_parallelnumscans(i.oid) AS parallel_idx_scan,
+    pg_stat_get_parallellastscan(i.oid) AS last_parallel_idx_scan,
     pg_stat_get_tuples_returned(i.oid) AS idx_tup_read,
     pg_stat_get_tuples_fetched(i.oid) AS idx_tup_fetch
    FROM (((pg_class c
@@ -1784,9 +1786,13 @@ pg_stat_all_tables| SELECT c.oid AS relid,
     c.relname,
     pg_stat_get_numscans(c.oid) AS seq_scan,
     pg_stat_get_lastscan(c.oid) AS last_seq_scan,
+    pg_stat_get_parallelnumscans(c.oid) AS parallel_seq_scan,
+    pg_stat_get_parallellastscan(c.oid) AS last_parallel_seq_scan,
     pg_stat_get_tuples_returned(c.oid) AS seq_tup_read,
     (sum(pg_stat_get_numscans(i.indexrelid)))::bigint AS idx_scan,
     max(pg_stat_get_lastscan(i.indexrelid)) AS last_idx_scan,
+    (sum(pg_stat_get_parallelnumscans(i.indexrelid)))::bigint AS parallel_idx_scan,
+    max(pg_stat_get_parallellastscan(i.indexrelid)) AS last_parallel_idx_scan,
     ((sum(pg_stat_get_tuples_fetched(i.indexrelid)))::bigint + pg_stat_get_tuples_fetched(c.oid)) AS idx_tup_fetch,
     pg_stat_get_tuples_inserted(c.oid) AS n_tup_ins,
     pg_stat_get_tuples_updated(c.oid) AS n_tup_upd,
@@ -2157,6 +2163,8 @@ pg_stat_sys_indexes| SELECT relid,
     indexrelname,
     idx_scan,
     last_idx_scan,
+    parallel_idx_scan,
+    last_parallel_idx_scan,
     idx_tup_read,
     idx_tup_fetch
    FROM pg_stat_all_indexes
@@ -2166,9 +2174,13 @@ pg_stat_sys_tables| SELECT relid,
     relname,
     seq_scan,
     last_seq_scan,
+    parallel_seq_scan,
+    last_parallel_seq_scan,
     seq_tup_read,
     idx_scan,
     last_idx_scan,
+    parallel_idx_scan,
+    last_parallel_idx_scan,
     idx_tup_fetch,
     n_tup_ins,
     n_tup_upd,
@@ -2205,6 +2217,8 @@ pg_stat_user_indexes| SELECT relid,
     indexrelname,
     idx_scan,
     last_idx_scan,
+    parallel_idx_scan,
+    last_parallel_idx_scan,
     idx_tup_read,
     idx_tup_fetch
    FROM pg_stat_all_indexes
@@ -2214,9 +2228,13 @@ pg_stat_user_tables| SELECT relid,
     relname,
     seq_scan,
     last_seq_scan,
+    parallel_seq_scan,
+    last_parallel_seq_scan,
     seq_tup_read,
     idx_scan,
     last_idx_scan,
+    parallel_idx_scan,
+    last_parallel_idx_scan,
     idx_tup_fetch,
     n_tup_ins,
     n_tup_upd,
diff --git a/src/test/regress/expected/stats.out b/src/test/regress/expected/stats.out
index 56771f83ed..2fe229dd5a 100644
--- a/src/test/regress/expected/stats.out
+++ b/src/test/regress/expected/stats.out
@@ -764,6 +764,200 @@ FROM pg_stat_all_tables WHERE relid = 'test_last_scan'::regclass;
         2 | t      |        3 | t
 (1 row)
 
+-----
+-- Test that parallel_seq_scan, last_parallel_seq_scan, parallel_idx_scan, last_parallel_idx_scan are correctly maintained
+--
+-- We can't use a temporary table for parallel test. So, perform test using a permanent table,
+-- but disable autovacuum on it. That way autovacuum etc won't
+-- interfere. To be able to check that timestamps increase, we sleep for 100ms
+-- between tests, assuming that there aren't systems with a coarser timestamp
+-- granularity.
+-----
+BEGIN;
+CREATE TABLE test_parallel_scan(idx_col int primary key, noidx_col int) WITH (autovacuum_enabled = false);
+INSERT INTO test_parallel_scan(idx_col, noidx_col) SELECT i, i FROM generate_series(1, 10_000) i;
+COMMIT;
+VACUUM ANALYZE test_parallel_scan;
+SELECT pg_stat_force_next_flush();
+ pg_stat_force_next_flush 
+--------------------------
+ 
+(1 row)
+
+SELECT parallel_seq_scan, last_parallel_seq_scan, parallel_idx_scan, last_parallel_idx_scan
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass;
+ parallel_seq_scan | last_parallel_seq_scan | parallel_idx_scan | last_parallel_idx_scan 
+-------------------+------------------------+-------------------+------------------------
+                 0 |                        |                 0 | 
+(1 row)
+
+-- ensure we start out with exactly one parallel index and parallel sequential scan
+BEGIN;
+SET LOCAL parallel_setup_cost TO 0;
+SET LOCAL min_parallel_table_scan_size TO '100kB';
+SET LOCAL min_parallel_index_scan_size TO '100kB';
+SET LOCAL enable_seqscan TO on;
+SET LOCAL enable_indexscan TO on;
+SET LOCAL enable_bitmapscan TO off;
+SET LOCAL enable_indexonlyscan TO off;
+EXPLAIN (COSTS off) SELECT count(*) FROM test_parallel_scan WHERE noidx_col = 1;
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Aggregate
+   ->  Gather
+         Workers Planned: 2
+         ->  Parallel Seq Scan on test_parallel_scan
+               Filter: (noidx_col = 1)
+(5 rows)
+
+SELECT count(*) FROM test_parallel_scan WHERE noidx_col = 1;
+ count 
+-------
+     1
+(1 row)
+
+SET LOCAL enable_seqscan TO off;
+EXPLAIN (COSTS off) SELECT count(*) FROM test_parallel_scan WHERE idx_col BETWEEN 1 AND 6000;
+                                        QUERY PLAN                                         
+-------------------------------------------------------------------------------------------
+ Finalize Aggregate
+   ->  Gather
+         Workers Planned: 1
+         ->  Partial Aggregate
+               ->  Parallel Index Scan using test_parallel_scan_pkey on test_parallel_scan
+                     Index Cond: ((idx_col >= 1) AND (idx_col <= 6000))
+(6 rows)
+
+SELECT count(*) FROM test_parallel_scan WHERE idx_col BETWEEN 1 AND 6000;
+ count 
+-------
+  6000
+(1 row)
+
+SELECT pg_stat_force_next_flush();
+ pg_stat_force_next_flush 
+--------------------------
+ 
+(1 row)
+
+COMMIT;
+-- fetch timestamps from before the next test
+SELECT parallel_seq_scan, parallel_idx_scan
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass;
+ parallel_seq_scan | parallel_idx_scan 
+-------------------+-------------------
+                 3 |                 2
+(1 row)
+
+SELECT last_parallel_seq_scan AS test_last_seq, last_parallel_idx_scan AS test_last_idx
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass \gset
+SELECT pg_sleep(0.1); -- assume a minimum timestamp granularity of 100ms
+ pg_sleep 
+----------
+ 
+(1 row)
+
+-- cause one parallel sequential scan
+BEGIN;
+SET LOCAL parallel_setup_cost TO 0;
+SET LOCAL min_parallel_table_scan_size TO '100kB';
+SET LOCAL min_parallel_index_scan_size TO '100kB';
+SET LOCAL enable_seqscan TO on;
+SET LOCAL enable_indexscan TO off;
+SET LOCAL enable_bitmapscan TO off;
+SET LOCAL enable_indexonlyscan TO off;
+EXPLAIN (COSTS off) SELECT count(*) FROM test_parallel_scan WHERE noidx_col = 1;
+                     QUERY PLAN                      
+-----------------------------------------------------
+ Aggregate
+   ->  Gather
+         Workers Planned: 2
+         ->  Parallel Seq Scan on test_parallel_scan
+               Filter: (noidx_col = 1)
+(5 rows)
+
+SELECT count(*) FROM test_parallel_scan WHERE noidx_col = 1;
+ count 
+-------
+     1
+(1 row)
+
+SELECT pg_stat_force_next_flush();
+ pg_stat_force_next_flush 
+--------------------------
+ 
+(1 row)
+
+COMMIT;
+-- check that just sequential scan stats were incremented
+SELECT parallel_seq_scan, :'test_last_seq' < last_parallel_seq_scan AS seq_ok,
+       parallel_idx_scan, :'test_last_idx' = last_parallel_idx_scan AS idx_ok
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass;
+ parallel_seq_scan | seq_ok | parallel_idx_scan | idx_ok 
+-------------------+--------+-------------------+--------
+                 6 | t      |                 2 | t
+(1 row)
+
+-- fetch timestamps from before the next test
+SELECT last_parallel_seq_scan AS test_last_seq, last_parallel_idx_scan AS test_last_idx
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass \gset
+SELECT pg_sleep(0.1);
+ pg_sleep 
+----------
+ 
+(1 row)
+
+-- cause one parallel index scan
+BEGIN;
+SET LOCAL parallel_setup_cost TO 0;
+SET LOCAL min_parallel_table_scan_size TO '100kB';
+SET LOCAL min_parallel_index_scan_size TO '100kB';
+SET LOCAL enable_seqscan TO off;
+SET LOCAL enable_indexscan TO on;
+SET LOCAL enable_bitmapscan TO off;
+SET LOCAL enable_indexonlyscan TO off;
+EXPLAIN (COSTS off) SELECT count(*) FROM test_parallel_scan WHERE idx_col BETWEEN 1 AND 6000;
+                                        QUERY PLAN                                         
+-------------------------------------------------------------------------------------------
+ Finalize Aggregate
+   ->  Gather
+         Workers Planned: 1
+         ->  Partial Aggregate
+               ->  Parallel Index Scan using test_parallel_scan_pkey on test_parallel_scan
+                     Index Cond: ((idx_col >= 1) AND (idx_col <= 6000))
+(6 rows)
+
+SELECT count(*) FROM test_parallel_scan WHERE idx_col BETWEEN 1 AND 6000;
+ count 
+-------
+  6000
+(1 row)
+
+SELECT pg_stat_force_next_flush();
+ pg_stat_force_next_flush 
+--------------------------
+ 
+(1 row)
+
+COMMIT;
+-- check that just index scan stats were incremented
+SELECT parallel_seq_scan, :'test_last_seq' = last_parallel_seq_scan AS seq_ok,
+       parallel_idx_scan, :'test_last_idx' < last_parallel_idx_scan AS idx_ok
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass;
+ parallel_seq_scan | seq_ok | parallel_idx_scan | idx_ok 
+-------------------+--------+-------------------+--------
+                 6 | t      |                 4 | t
+(1 row)
+
+-- fetch timestamps from before the next test
+SELECT last_parallel_seq_scan AS test_last_seq, last_parallel_idx_scan AS test_last_idx
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass \gset
+SELECT pg_sleep(0.1);
+ pg_sleep 
+----------
+ 
+(1 row)
+
 -----
 -- Test reset of some stats for shared table
 -----
diff --git a/src/test/regress/sql/stats.sql b/src/test/regress/sql/stats.sql
index 7147cc2f89..5eb92fbf55 100644
--- a/src/test/regress/sql/stats.sql
+++ b/src/test/regress/sql/stats.sql
@@ -376,6 +376,98 @@ COMMIT;
 SELECT seq_scan, :'test_last_seq' = last_seq_scan AS seq_ok, idx_scan, :'test_last_idx' < last_idx_scan AS idx_ok
 FROM pg_stat_all_tables WHERE relid = 'test_last_scan'::regclass;
 
+-----
+-- Test that parallel_seq_scan, last_parallel_seq_scan, parallel_idx_scan, last_parallel_idx_scan are correctly maintained
+--
+-- We can't use a temporary table for parallel test. So, perform test using a permanent table,
+-- but disable autovacuum on it. That way autovacuum etc won't
+-- interfere. To be able to check that timestamps increase, we sleep for 100ms
+-- between tests, assuming that there aren't systems with a coarser timestamp
+-- granularity.
+-----
+
+BEGIN;
+CREATE TABLE test_parallel_scan(idx_col int primary key, noidx_col int) WITH (autovacuum_enabled = false);
+INSERT INTO test_parallel_scan(idx_col, noidx_col) SELECT i, i FROM generate_series(1, 10_000) i;
+COMMIT;
+
+VACUUM ANALYZE test_parallel_scan;
+
+SELECT pg_stat_force_next_flush();
+
+SELECT parallel_seq_scan, last_parallel_seq_scan, parallel_idx_scan, last_parallel_idx_scan
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass;
+
+-- ensure we start out with exactly one parallel index and parallel sequential scan
+BEGIN;
+SET LOCAL parallel_setup_cost TO 0;
+SET LOCAL min_parallel_table_scan_size TO '100kB';
+SET LOCAL min_parallel_index_scan_size TO '100kB';
+SET LOCAL enable_seqscan TO on;
+SET LOCAL enable_indexscan TO on;
+SET LOCAL enable_bitmapscan TO off;
+SET LOCAL enable_indexonlyscan TO off;
+EXPLAIN (COSTS off) SELECT count(*) FROM test_parallel_scan WHERE noidx_col = 1;
+SELECT count(*) FROM test_parallel_scan WHERE noidx_col = 1;
+SET LOCAL enable_seqscan TO off;
+EXPLAIN (COSTS off) SELECT count(*) FROM test_parallel_scan WHERE idx_col BETWEEN 1 AND 6000;
+SELECT count(*) FROM test_parallel_scan WHERE idx_col BETWEEN 1 AND 6000;
+SELECT pg_stat_force_next_flush();
+COMMIT;
+
+-- fetch timestamps from before the next test
+SELECT parallel_seq_scan, parallel_idx_scan
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass;
+SELECT last_parallel_seq_scan AS test_last_seq, last_parallel_idx_scan AS test_last_idx
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass \gset
+SELECT pg_sleep(0.1); -- assume a minimum timestamp granularity of 100ms
+
+-- cause one parallel sequential scan
+BEGIN;
+SET LOCAL parallel_setup_cost TO 0;
+SET LOCAL min_parallel_table_scan_size TO '100kB';
+SET LOCAL min_parallel_index_scan_size TO '100kB';
+SET LOCAL enable_seqscan TO on;
+SET LOCAL enable_indexscan TO off;
+SET LOCAL enable_bitmapscan TO off;
+SET LOCAL enable_indexonlyscan TO off;
+EXPLAIN (COSTS off) SELECT count(*) FROM test_parallel_scan WHERE noidx_col = 1;
+SELECT count(*) FROM test_parallel_scan WHERE noidx_col = 1;
+SELECT pg_stat_force_next_flush();
+COMMIT;
+-- check that just sequential scan stats were incremented
+SELECT parallel_seq_scan, :'test_last_seq' < last_parallel_seq_scan AS seq_ok,
+       parallel_idx_scan, :'test_last_idx' = last_parallel_idx_scan AS idx_ok
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass;
+
+-- fetch timestamps from before the next test
+SELECT last_parallel_seq_scan AS test_last_seq, last_parallel_idx_scan AS test_last_idx
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass \gset
+SELECT pg_sleep(0.1);
+
+-- cause one parallel index scan
+BEGIN;
+SET LOCAL parallel_setup_cost TO 0;
+SET LOCAL min_parallel_table_scan_size TO '100kB';
+SET LOCAL min_parallel_index_scan_size TO '100kB';
+SET LOCAL enable_seqscan TO off;
+SET LOCAL enable_indexscan TO on;
+SET LOCAL enable_bitmapscan TO off;
+SET LOCAL enable_indexonlyscan TO off;
+EXPLAIN (COSTS off) SELECT count(*) FROM test_parallel_scan WHERE idx_col BETWEEN 1 AND 6000;
+SELECT count(*) FROM test_parallel_scan WHERE idx_col BETWEEN 1 AND 6000;
+SELECT pg_stat_force_next_flush();
+COMMIT;
+-- check that just index scan stats were incremented
+SELECT parallel_seq_scan, :'test_last_seq' = last_parallel_seq_scan AS seq_ok,
+       parallel_idx_scan, :'test_last_idx' < last_parallel_idx_scan AS idx_ok
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass;
+
+-- fetch timestamps from before the next test
+SELECT last_parallel_seq_scan AS test_last_seq, last_parallel_idx_scan AS test_last_idx
+FROM pg_stat_all_tables WHERE relid = 'test_parallel_scan'::regclass \gset
+SELECT pg_sleep(0.1);
+
 -----
 -- Test reset of some stats for shared table
 -----
-- 
2.46.2