Report index vacuum progress.

This commit adds two columns: indexes_total and indexes_processed, to
pg_stat_progress_vacuum system view to show the index vacuum
progress. These numbers are reported in the "vacuuming indexes" and
"cleaning up indexes" phases.

This uses the new parallel message type for progress reporting added
by be06506e7.

Bump catversion because this changes the definition of
pg_stat_progress_vacuum.

Author: Sami Imseih
Reviewed by: Masahiko Sawada, Michael Paquier, Nathan Bossart, Andres Freund
Discussion: https://www.postgresql.org/message-id/flat/5478DFCD-2333-401A-B2F0-0D186AB09228@amazon.com

diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml
index 506aeaa87999349be717180da69a5482c35e4686..588b720f57e3f93be7c8f887a8da87eb73ad86ea 100644 (file)
--- a/doc/src/sgml/monitoring.sgml
+++ b/doc/src/sgml/monitoring.sgml
@@ -6110,6 +6110,29 @@ FROM pg_stat_get_backend_idset() AS backendid;
        Number of dead tuples collected since the last index vacuum cycle.
       </para></entry>
      </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>indexes_total</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Total number of indexes that will be vacuumed or cleaned up. This
+       number is reported at the beginning of the
+       <literal>vacuuming indexes</literal> phase or the
+       <literal>cleaning up indexes</literal> phase.
+      </para></entry>
+     </row>
+
+     <row>
+      <entry role="catalog_table_entry"><para role="column_definition">
+       <structfield>indexes_processed</structfield> <type>bigint</type>
+      </para>
+      <para>
+       Number of indexes processed. This counter only advances when the
+       phase is <literal>vacuuming indexes</literal> or
+       <literal>cleaning up indexes</literal>.
+      </para></entry>
+     </row>
     </tbody>
    </tgroup>
   </table>

diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 4eb953f904747472d849c71a7111ef8206fe09b3..6a41ee635d345335241adb4ad9124d5a1269a8fa 100644 (file)
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -2319,6 +2319,17 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
 {
        bool            allindexes = true;
        double          old_live_tuples = vacrel->rel->rd_rel->reltuples;
+       const int       progress_start_index[] = {
+               PROGRESS_VACUUM_PHASE,
+               PROGRESS_VACUUM_INDEXES_TOTAL
+       };
+       const int       progress_end_index[] = {
+               PROGRESS_VACUUM_INDEXES_TOTAL,
+               PROGRESS_VACUUM_INDEXES_PROCESSED,
+               PROGRESS_VACUUM_NUM_INDEX_VACUUMS
+       };
+       int64           progress_start_val[2];
+       int64           progress_end_val[3];
 
        Assert(vacrel->nindexes > 0);
        Assert(vacrel->do_index_vacuuming);
@@ -2331,9 +2342,13 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
                return false;
        }
 
-       /* Report that we are now vacuuming indexes */
-       pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
-                                                                PROGRESS_VACUUM_PHASE_VACUUM_INDEX);
+       /*
+        * Report that we are now vacuuming indexes and the number of indexes to
+        * vacuum.
+        */
+       progress_start_val[0] = PROGRESS_VACUUM_PHASE_VACUUM_INDEX;
+       progress_start_val[1] = vacrel->nindexes;
+       pgstat_progress_update_multi_param(2, progress_start_index, progress_start_val);
 
        if (!ParallelVacuumIsActive(vacrel))
        {
@@ -2346,6 +2361,10 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
                                                                                                                  old_live_tuples,
                                                                                                                  vacrel);
 
+                       /* Report the number of indexes vacuumed */
+                       pgstat_progress_update_param(PROGRESS_VACUUM_INDEXES_PROCESSED,
+                                                                                idx + 1);
+
                        if (lazy_check_wraparound_failsafe(vacrel))
                        {
                                /* Wraparound emergency -- end current index scan */
@@ -2380,14 +2399,17 @@ lazy_vacuum_all_indexes(LVRelState *vacrel)
        Assert(allindexes || VacuumFailsafeActive);
 
        /*
-        * Increase and report the number of index scans.
+        * Increase and report the number of index scans.  Also, we reset
+        * PROGRESS_VACUUM_INDEXES_TOTAL and PROGRESS_VACUUM_INDEXES_PROCESSED.
         *
         * We deliberately include the case where we started a round of bulk
         * deletes that we weren't able to finish due to the failsafe triggering.
         */
        vacrel->num_index_scans++;
-       pgstat_progress_update_param(PROGRESS_VACUUM_NUM_INDEX_VACUUMS,
-                                                                vacrel->num_index_scans);
+       progress_end_val[0] = 0;
+       progress_end_val[1] = 0;
+       progress_end_val[2] = vacrel->num_index_scans;
+       pgstat_progress_update_multi_param(3, progress_end_index, progress_end_val);
 
        return allindexes;
 }
@@ -2624,6 +2646,12 @@ lazy_check_wraparound_failsafe(LVRelState *vacrel)
 
        if (unlikely(vacuum_xid_failsafe_check(&vacrel->cutoffs)))
        {
+               const int       progress_index[] = {
+                       PROGRESS_VACUUM_INDEXES_TOTAL,
+                       PROGRESS_VACUUM_INDEXES_PROCESSED
+               };
+               int64           progress_val[2] = {0, 0};
+
                VacuumFailsafeActive = true;
 
                /*
@@ -2638,6 +2666,9 @@ lazy_check_wraparound_failsafe(LVRelState *vacrel)
                vacrel->do_index_cleanup = false;
                vacrel->do_rel_truncate = false;
 
+               /* Reset the progress counters */
+               pgstat_progress_update_multi_param(2, progress_index, progress_val);
+
                ereport(WARNING,
                                (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
                                                vacrel->dbname, vacrel->relnamespace, vacrel->relname,
@@ -2664,13 +2695,27 @@ lazy_cleanup_all_indexes(LVRelState *vacrel)
 {
        double          reltuples = vacrel->new_rel_tuples;
        bool            estimated_count = vacrel->scanned_pages < vacrel->rel_pages;
+       const int       progress_start_index[] = {
+               PROGRESS_VACUUM_PHASE,
+               PROGRESS_VACUUM_INDEXES_TOTAL
+       };
+       const int       progress_end_index[] = {
+               PROGRESS_VACUUM_INDEXES_TOTAL,
+               PROGRESS_VACUUM_INDEXES_PROCESSED
+       };
+       int64           progress_start_val[2];
+       int64           progress_end_val[2] = {0, 0};
 
        Assert(vacrel->do_index_cleanup);
        Assert(vacrel->nindexes > 0);
 
-       /* Report that we are now cleaning up indexes */
-       pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
-                                                                PROGRESS_VACUUM_PHASE_INDEX_CLEANUP);
+       /*
+        * Report that we are now cleaning up indexes and the number of indexes to
+        * cleanup.
+        */
+       progress_start_val[0] = PROGRESS_VACUUM_PHASE_INDEX_CLEANUP;
+       progress_start_val[1] = vacrel->nindexes;
+       pgstat_progress_update_multi_param(2, progress_start_index, progress_start_val);
 
        if (!ParallelVacuumIsActive(vacrel))
        {
@@ -2682,6 +2727,10 @@ lazy_cleanup_all_indexes(LVRelState *vacrel)
                        vacrel->indstats[idx] =
                                lazy_cleanup_one_index(indrel, istat, reltuples,
                                                                           estimated_count, vacrel);
+
+                       /* Report the number of indexes cleaned up */
+                       pgstat_progress_update_param(PROGRESS_VACUUM_INDEXES_PROCESSED,
+                                                                                idx + 1);
                }
        }
        else
@@ -2691,6 +2740,9 @@ lazy_cleanup_all_indexes(LVRelState *vacrel)
                                                                                        vacrel->num_index_scans,
                                                                                        estimated_count);
        }
+
+       /* Reset the progress counters */
+       pgstat_progress_update_multi_param(2, progress_end_index, progress_end_val);
 }
 
 /*

diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index c18fea8362dff57d40ca50193cd016802c950913..af65af6bdd5c2f21a4c50bb0896a1ccda61525dd 100644 (file)
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1192,7 +1192,8 @@ CREATE VIEW pg_stat_progress_vacuum AS
                       END AS phase,
         S.param2 AS heap_blks_total, S.param3 AS heap_blks_scanned,
         S.param4 AS heap_blks_vacuumed, S.param5 AS index_vacuum_count,
-        S.param6 AS max_dead_tuples, S.param7 AS num_dead_tuples
+        S.param6 AS max_dead_tuples, S.param7 AS num_dead_tuples,
+        S.param8 AS indexes_total, S.param9 AS indexes_processed
     FROM pg_stat_get_progress_info('VACUUM') AS S
         LEFT JOIN pg_database D ON S.datid = D.oid;
 

diff --git a/src/backend/commands/vacuumparallel.c b/src/backend/commands/vacuumparallel.c
index a79067fd461deaff4fbb599decf6552d251a2342..351ab4957af06813fb97626c27f6a4da2e32c5b6 100644 (file)
--- a/src/backend/commands/vacuumparallel.c
+++ b/src/backend/commands/vacuumparallel.c
@@ -30,6 +30,7 @@
 #include "access/table.h"
 #include "access/xact.h"
 #include "catalog/index.h"
+#include "commands/progress.h"
 #include "commands/vacuum.h"
 #include "optimizer/paths.h"
 #include "pgstat.h"
@@ -631,7 +632,7 @@ parallel_vacuum_process_all_indexes(ParallelVacuumState *pvs, int num_index_scan
                                                                                                        vacuum));
        }
 
-       /* Reset the parallel index processing counter */
+       /* Reset the parallel index processing and progress counters */
        pg_atomic_write_u32(&(pvs->shared->idx), 0);
 
        /* Setup the shared cost-based vacuum delay and launch workers */
@@ -902,6 +903,12 @@ parallel_vacuum_process_one_index(ParallelVacuumState *pvs, Relation indrel,
        pvs->status = PARALLEL_INDVAC_STATUS_COMPLETED;
        pfree(pvs->indname);
        pvs->indname = NULL;
+
+       /*
+        * Call the parallel variant of pgstat_progress_incr_param so workers can
+        * report progress of index vacuum to the leader.
+        */
+       pgstat_progress_parallel_incr_param(PROGRESS_VACUUM_INDEXES_PROCESSED, 1);
 }
 
 /*

diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
index 83f3a7c2eca5b6a4220d6c34b55bfe67620472a0..d5969e6aea2fc23a6b0d57ce8da5951171706f76 100644 (file)
--- a/src/include/catalog/catversion.h
+++ b/src/include/catalog/catversion.h
@@ -57,6 +57,6 @@
  */
 
 /*                                                     yyyymmddN */
-#define CATALOG_VERSION_NO     202307072
+#define CATALOG_VERSION_NO     202307111
 
 #endif

diff --git a/src/include/commands/progress.h b/src/include/commands/progress.h
index e5add41352732c280eac7427761625796d288575..2478e874258d0c8022e20564d3b03b5494639e25 100644 (file)
--- a/src/include/commands/progress.h
+++ b/src/include/commands/progress.h
@@ -25,6 +25,8 @@
 #define PROGRESS_VACUUM_NUM_INDEX_VACUUMS              4
 #define PROGRESS_VACUUM_MAX_DEAD_TUPLES                        5
 #define PROGRESS_VACUUM_NUM_DEAD_TUPLES                        6
+#define PROGRESS_VACUUM_INDEXES_TOTAL                  7
+#define PROGRESS_VACUUM_INDEXES_PROCESSED              8
 
 /* Phases of vacuum (as advertised via PROGRESS_VACUUM_PHASE) */
 #define PROGRESS_VACUUM_PHASE_SCAN_HEAP                        1

diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 7fd81e6a7d007275f11d18a74531c2794ddef743..e07afcd4aa62eaab6084782789df05df835d3ef6 100644 (file)
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -2044,7 +2044,9 @@ pg_stat_progress_vacuum| SELECT s.pid,
     s.param4 AS heap_blks_vacuumed,
     s.param5 AS index_vacuum_count,
     s.param6 AS max_dead_tuples,
-    s.param7 AS num_dead_tuples
+    s.param7 AS num_dead_tuples,
+    s.param8 AS indexes_total,
+    s.param9 AS indexes_processed
    FROM (pg_stat_get_progress_info('VACUUM'::text) s(pid, datid, relid, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20)
      LEFT JOIN pg_database d ON ((s.datid = d.oid)));
 pg_stat_recovery_prefetch| SELECT stats_reset,