LCOV - code coverage report
Current view: top level - src/backend/commands - vacuum.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 640 717 89.3 %
Date: 2024-04-13 10:11:43 Functions: 21 22 95.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * vacuum.c
       4             :  *    The postgres vacuum cleaner.
       5             :  *
       6             :  * This file includes (a) control and dispatch code for VACUUM and ANALYZE
       7             :  * commands, (b) code to compute various vacuum thresholds, and (c) index
       8             :  * vacuum code.
       9             :  *
      10             :  * VACUUM for heap AM is implemented in vacuumlazy.c, parallel vacuum in
      11             :  * vacuumparallel.c, ANALYZE in analyze.c, and VACUUM FULL is a variant of
      12             :  * CLUSTER, handled in cluster.c.
      13             :  *
      14             :  *
      15             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
      16             :  * Portions Copyright (c) 1994, Regents of the University of California
      17             :  *
      18             :  *
      19             :  * IDENTIFICATION
      20             :  *    src/backend/commands/vacuum.c
      21             :  *
      22             :  *-------------------------------------------------------------------------
      23             :  */
      24             : #include "postgres.h"
      25             : 
      26             : #include <math.h>
      27             : 
      28             : #include "access/clog.h"
      29             : #include "access/commit_ts.h"
      30             : #include "access/genam.h"
      31             : #include "access/heapam.h"
      32             : #include "access/htup_details.h"
      33             : #include "access/multixact.h"
      34             : #include "access/tableam.h"
      35             : #include "access/transam.h"
      36             : #include "access/xact.h"
      37             : #include "catalog/index.h"
      38             : #include "catalog/namespace.h"
      39             : #include "catalog/pg_database.h"
      40             : #include "catalog/pg_inherits.h"
      41             : #include "commands/cluster.h"
      42             : #include "commands/defrem.h"
      43             : #include "commands/vacuum.h"
      44             : #include "miscadmin.h"
      45             : #include "nodes/makefuncs.h"
      46             : #include "pgstat.h"
      47             : #include "postmaster/autovacuum.h"
      48             : #include "postmaster/bgworker_internals.h"
      49             : #include "postmaster/interrupt.h"
      50             : #include "storage/bufmgr.h"
      51             : #include "storage/lmgr.h"
      52             : #include "storage/pmsignal.h"
      53             : #include "storage/proc.h"
      54             : #include "storage/procarray.h"
      55             : #include "utils/acl.h"
      56             : #include "utils/fmgroids.h"
      57             : #include "utils/guc.h"
      58             : #include "utils/guc_hooks.h"
      59             : #include "utils/memutils.h"
      60             : #include "utils/snapmgr.h"
      61             : #include "utils/syscache.h"
      62             : 
      63             : 
      64             : /*
      65             :  * GUC parameters
      66             :  */
      67             : int         vacuum_freeze_min_age;
      68             : int         vacuum_freeze_table_age;
      69             : int         vacuum_multixact_freeze_min_age;
      70             : int         vacuum_multixact_freeze_table_age;
      71             : int         vacuum_failsafe_age;
      72             : int         vacuum_multixact_failsafe_age;
      73             : 
      74             : /*
      75             :  * Variables for cost-based vacuum delay. The defaults differ between
      76             :  * autovacuum and vacuum. They should be set with the appropriate GUC value in
      77             :  * vacuum code. They are initialized here to the defaults for client backends
      78             :  * executing VACUUM or ANALYZE.
      79             :  */
      80             : double      vacuum_cost_delay = 0;
      81             : int         vacuum_cost_limit = 200;
      82             : 
      83             : /*
      84             :  * VacuumFailsafeActive is a defined as a global so that we can determine
      85             :  * whether or not to re-enable cost-based vacuum delay when vacuuming a table.
      86             :  * If failsafe mode has been engaged, we will not re-enable cost-based delay
      87             :  * for the table until after vacuuming has completed, regardless of other
      88             :  * settings.
      89             :  *
      90             :  * Only VACUUM code should inspect this variable and only table access methods
      91             :  * should set it to true. In Table AM-agnostic VACUUM code, this variable is
      92             :  * inspected to determine whether or not to allow cost-based delays. Table AMs
      93             :  * are free to set it if they desire this behavior, but it is false by default
      94             :  * and reset to false in between vacuuming each relation.
      95             :  */
      96             : bool        VacuumFailsafeActive = false;
      97             : 
      98             : /*
      99             :  * Variables for cost-based parallel vacuum.  See comments atop
     100             :  * compute_parallel_delay to understand how it works.
     101             :  */
     102             : pg_atomic_uint32 *VacuumSharedCostBalance = NULL;
     103             : pg_atomic_uint32 *VacuumActiveNWorkers = NULL;
     104             : int         VacuumCostBalanceLocal = 0;
     105             : 
     106             : /* non-export function prototypes */
     107             : static List *expand_vacuum_rel(VacuumRelation *vrel,
     108             :                                MemoryContext vac_context, int options);
     109             : static List *get_all_vacuum_rels(MemoryContext vac_context, int options);
     110             : static void vac_truncate_clog(TransactionId frozenXID,
     111             :                               MultiXactId minMulti,
     112             :                               TransactionId lastSaneFrozenXid,
     113             :                               MultiXactId lastSaneMinMulti);
     114             : static bool vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params,
     115             :                        BufferAccessStrategy bstrategy);
     116             : static double compute_parallel_delay(void);
     117             : static VacOptValue get_vacoptval_from_boolean(DefElem *def);
     118             : static bool vac_tid_reaped(ItemPointer itemptr, void *state);
     119             : 
     120             : /*
     121             :  * GUC check function to ensure GUC value specified is within the allowable
     122             :  * range.
     123             :  */
     124             : bool
     125        1830 : check_vacuum_buffer_usage_limit(int *newval, void **extra,
     126             :                                 GucSource source)
     127             : {
     128             :     /* Value upper and lower hard limits are inclusive */
     129        1830 :     if (*newval == 0 || (*newval >= MIN_BAS_VAC_RING_SIZE_KB &&
     130        1830 :                          *newval <= MAX_BAS_VAC_RING_SIZE_KB))
     131        1830 :         return true;
     132             : 
     133             :     /* Value does not fall within any allowable range */
     134           0 :     GUC_check_errdetail("vacuum_buffer_usage_limit must be 0 or between %d kB and %d kB",
     135             :                         MIN_BAS_VAC_RING_SIZE_KB, MAX_BAS_VAC_RING_SIZE_KB);
     136             : 
     137           0 :     return false;
     138             : }
     139             : 
     140             : /*
     141             :  * Primary entry point for manual VACUUM and ANALYZE commands
     142             :  *
     143             :  * This is mainly a preparation wrapper for the real operations that will
     144             :  * happen in vacuum().
     145             :  */
     146             : void
     147       10420 : ExecVacuum(ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel)
     148             : {
     149             :     VacuumParams params;
     150       10420 :     BufferAccessStrategy bstrategy = NULL;
     151       10420 :     bool        verbose = false;
     152       10420 :     bool        skip_locked = false;
     153       10420 :     bool        analyze = false;
     154       10420 :     bool        freeze = false;
     155       10420 :     bool        full = false;
     156       10420 :     bool        disable_page_skipping = false;
     157       10420 :     bool        process_main = true;
     158       10420 :     bool        process_toast = true;
     159             :     int         ring_size;
     160       10420 :     bool        skip_database_stats = false;
     161       10420 :     bool        only_database_stats = false;
     162             :     MemoryContext vac_context;
     163             :     ListCell   *lc;
     164             : 
     165             :     /* index_cleanup and truncate values unspecified for now */
     166       10420 :     params.index_cleanup = VACOPTVALUE_UNSPECIFIED;
     167       10420 :     params.truncate = VACOPTVALUE_UNSPECIFIED;
     168             : 
     169             :     /* By default parallel vacuum is enabled */
     170       10420 :     params.nworkers = 0;
     171             : 
     172             :     /* Will be set later if we recurse to a TOAST table. */
     173       10420 :     params.toast_parent = InvalidOid;
     174             : 
     175             :     /*
     176             :      * Set this to an invalid value so it is clear whether or not a
     177             :      * BUFFER_USAGE_LIMIT was specified when making the access strategy.
     178             :      */
     179       10420 :     ring_size = -1;
     180             : 
     181             :     /* Parse options list */
     182       19362 :     foreach(lc, vacstmt->options)
     183             :     {
     184        8978 :         DefElem    *opt = (DefElem *) lfirst(lc);
     185             : 
     186             :         /* Parse common options for VACUUM and ANALYZE */
     187        8978 :         if (strcmp(opt->defname, "verbose") == 0)
     188          38 :             verbose = defGetBoolean(opt);
     189        8940 :         else if (strcmp(opt->defname, "skip_locked") == 0)
     190         334 :             skip_locked = defGetBoolean(opt);
     191        8606 :         else if (strcmp(opt->defname, "buffer_usage_limit") == 0)
     192             :         {
     193             :             const char *hintmsg;
     194             :             int         result;
     195             :             char       *vac_buffer_size;
     196             : 
     197          54 :             vac_buffer_size = defGetString(opt);
     198             : 
     199             :             /*
     200             :              * Check that the specified value is valid and the size falls
     201             :              * within the hard upper and lower limits if it is not 0.
     202             :              */
     203          54 :             if (!parse_int(vac_buffer_size, &result, GUC_UNIT_KB, &hintmsg) ||
     204          48 :                 (result != 0 &&
     205          36 :                  (result < MIN_BAS_VAC_RING_SIZE_KB || result > MAX_BAS_VAC_RING_SIZE_KB)))
     206             :             {
     207          18 :                 ereport(ERROR,
     208             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     209             :                          errmsg("BUFFER_USAGE_LIMIT option must be 0 or between %d kB and %d kB",
     210             :                                 MIN_BAS_VAC_RING_SIZE_KB, MAX_BAS_VAC_RING_SIZE_KB),
     211             :                          hintmsg ? errhint("%s", _(hintmsg)) : 0));
     212             :             }
     213             : 
     214          36 :             ring_size = result;
     215             :         }
     216        8552 :         else if (!vacstmt->is_vacuumcmd)
     217           6 :             ereport(ERROR,
     218             :                     (errcode(ERRCODE_SYNTAX_ERROR),
     219             :                      errmsg("unrecognized ANALYZE option \"%s\"", opt->defname),
     220             :                      parser_errposition(pstate, opt->location)));
     221             : 
     222             :         /* Parse options available on VACUUM */
     223        8546 :         else if (strcmp(opt->defname, "analyze") == 0)
     224        1370 :             analyze = defGetBoolean(opt);
     225        7176 :         else if (strcmp(opt->defname, "freeze") == 0)
     226        1148 :             freeze = defGetBoolean(opt);
     227        6028 :         else if (strcmp(opt->defname, "full") == 0)
     228         356 :             full = defGetBoolean(opt);
     229        5672 :         else if (strcmp(opt->defname, "disable_page_skipping") == 0)
     230         182 :             disable_page_skipping = defGetBoolean(opt);
     231        5490 :         else if (strcmp(opt->defname, "index_cleanup") == 0)
     232             :         {
     233             :             /* Interpret no string as the default, which is 'auto' */
     234         174 :             if (!opt->arg)
     235           0 :                 params.index_cleanup = VACOPTVALUE_AUTO;
     236             :             else
     237             :             {
     238         174 :                 char       *sval = defGetString(opt);
     239             : 
     240             :                 /* Try matching on 'auto' string, or fall back on boolean */
     241         174 :                 if (pg_strcasecmp(sval, "auto") == 0)
     242           6 :                     params.index_cleanup = VACOPTVALUE_AUTO;
     243             :                 else
     244         168 :                     params.index_cleanup = get_vacoptval_from_boolean(opt);
     245             :             }
     246             :         }
     247        5316 :         else if (strcmp(opt->defname, "process_main") == 0)
     248         154 :             process_main = defGetBoolean(opt);
     249        5162 :         else if (strcmp(opt->defname, "process_toast") == 0)
     250         160 :             process_toast = defGetBoolean(opt);
     251        5002 :         else if (strcmp(opt->defname, "truncate") == 0)
     252         148 :             params.truncate = get_vacoptval_from_boolean(opt);
     253        4854 :         else if (strcmp(opt->defname, "parallel") == 0)
     254             :         {
     255         338 :             if (opt->arg == NULL)
     256             :             {
     257           6 :                 ereport(ERROR,
     258             :                         (errcode(ERRCODE_SYNTAX_ERROR),
     259             :                          errmsg("parallel option requires a value between 0 and %d",
     260             :                                 MAX_PARALLEL_WORKER_LIMIT),
     261             :                          parser_errposition(pstate, opt->location)));
     262             :             }
     263             :             else
     264             :             {
     265             :                 int         nworkers;
     266             : 
     267         332 :                 nworkers = defGetInt32(opt);
     268         332 :                 if (nworkers < 0 || nworkers > MAX_PARALLEL_WORKER_LIMIT)
     269           6 :                     ereport(ERROR,
     270             :                             (errcode(ERRCODE_SYNTAX_ERROR),
     271             :                              errmsg("parallel workers for vacuum must be between 0 and %d",
     272             :                                     MAX_PARALLEL_WORKER_LIMIT),
     273             :                              parser_errposition(pstate, opt->location)));
     274             : 
     275             :                 /*
     276             :                  * Disable parallel vacuum, if user has specified parallel
     277             :                  * degree as zero.
     278             :                  */
     279         326 :                 if (nworkers == 0)
     280         154 :                     params.nworkers = -1;
     281             :                 else
     282         172 :                     params.nworkers = nworkers;
     283             :             }
     284             :         }
     285        4516 :         else if (strcmp(opt->defname, "skip_database_stats") == 0)
     286        4398 :             skip_database_stats = defGetBoolean(opt);
     287         118 :         else if (strcmp(opt->defname, "only_database_stats") == 0)
     288         118 :             only_database_stats = defGetBoolean(opt);
     289             :         else
     290           0 :             ereport(ERROR,
     291             :                     (errcode(ERRCODE_SYNTAX_ERROR),
     292             :                      errmsg("unrecognized VACUUM option \"%s\"", opt->defname),
     293             :                      parser_errposition(pstate, opt->location)));
     294             :     }
     295             : 
     296             :     /* Set vacuum options */
     297       10384 :     params.options =
     298       10384 :         (vacstmt->is_vacuumcmd ? VACOPT_VACUUM : VACOPT_ANALYZE) |
     299       10384 :         (verbose ? VACOPT_VERBOSE : 0) |
     300       10384 :         (skip_locked ? VACOPT_SKIP_LOCKED : 0) |
     301       10384 :         (analyze ? VACOPT_ANALYZE : 0) |
     302       10384 :         (freeze ? VACOPT_FREEZE : 0) |
     303       10384 :         (full ? VACOPT_FULL : 0) |
     304       10384 :         (disable_page_skipping ? VACOPT_DISABLE_PAGE_SKIPPING : 0) |
     305       10384 :         (process_main ? VACOPT_PROCESS_MAIN : 0) |
     306       10384 :         (process_toast ? VACOPT_PROCESS_TOAST : 0) |
     307       10384 :         (skip_database_stats ? VACOPT_SKIP_DATABASE_STATS : 0) |
     308       10384 :         (only_database_stats ? VACOPT_ONLY_DATABASE_STATS : 0);
     309             : 
     310             :     /* sanity checks on options */
     311             :     Assert(params.options & (VACOPT_VACUUM | VACOPT_ANALYZE));
     312             :     Assert((params.options & VACOPT_VACUUM) ||
     313             :            !(params.options & (VACOPT_FULL | VACOPT_FREEZE)));
     314             : 
     315       10384 :     if ((params.options & VACOPT_FULL) && params.nworkers > 0)
     316           6 :         ereport(ERROR,
     317             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     318             :                  errmsg("VACUUM FULL cannot be performed in parallel")));
     319             : 
     320             :     /*
     321             :      * BUFFER_USAGE_LIMIT does nothing for VACUUM (FULL) so just raise an
     322             :      * ERROR for that case.  VACUUM (FULL, ANALYZE) does make use of it, so
     323             :      * we'll permit that.
     324             :      */
     325       10378 :     if (ring_size != -1 && (params.options & VACOPT_FULL) &&
     326           6 :         !(params.options & VACOPT_ANALYZE))
     327           6 :         ereport(ERROR,
     328             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     329             :                  errmsg("BUFFER_USAGE_LIMIT cannot be specified for VACUUM FULL")));
     330             : 
     331             :     /*
     332             :      * Make sure VACOPT_ANALYZE is specified if any column lists are present.
     333             :      */
     334       10372 :     if (!(params.options & VACOPT_ANALYZE))
     335             :     {
     336        9018 :         foreach(lc, vacstmt->rels)
     337             :         {
     338        4430 :             VacuumRelation *vrel = lfirst_node(VacuumRelation, lc);
     339             : 
     340        4430 :             if (vrel->va_cols != NIL)
     341           6 :                 ereport(ERROR,
     342             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     343             :                          errmsg("ANALYZE option must be specified when a column list is provided")));
     344             :         }
     345             :     }
     346             : 
     347             : 
     348             :     /*
     349             :      * Sanity check DISABLE_PAGE_SKIPPING option.
     350             :      */
     351       10366 :     if ((params.options & VACOPT_FULL) != 0 &&
     352         332 :         (params.options & VACOPT_DISABLE_PAGE_SKIPPING) != 0)
     353           0 :         ereport(ERROR,
     354             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     355             :                  errmsg("VACUUM option DISABLE_PAGE_SKIPPING cannot be used with FULL")));
     356             : 
     357             :     /* sanity check for PROCESS_TOAST */
     358       10366 :     if ((params.options & VACOPT_FULL) != 0 &&
     359         332 :         (params.options & VACOPT_PROCESS_TOAST) == 0)
     360           6 :         ereport(ERROR,
     361             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     362             :                  errmsg("PROCESS_TOAST required with VACUUM FULL")));
     363             : 
     364             :     /* sanity check for ONLY_DATABASE_STATS */
     365       10360 :     if (params.options & VACOPT_ONLY_DATABASE_STATS)
     366             :     {
     367             :         Assert(params.options & VACOPT_VACUUM);
     368         118 :         if (vacstmt->rels != NIL)
     369           6 :             ereport(ERROR,
     370             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     371             :                      errmsg("ONLY_DATABASE_STATS cannot be specified with a list of tables")));
     372             :         /* don't require people to turn off PROCESS_TOAST/MAIN explicitly */
     373         112 :         if (params.options & ~(VACOPT_VACUUM |
     374             :                                VACOPT_VERBOSE |
     375             :                                VACOPT_PROCESS_MAIN |
     376             :                                VACOPT_PROCESS_TOAST |
     377             :                                VACOPT_ONLY_DATABASE_STATS))
     378           0 :             ereport(ERROR,
     379             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     380             :                      errmsg("ONLY_DATABASE_STATS cannot be specified with other VACUUM options")));
     381             :     }
     382             : 
     383             :     /*
     384             :      * All freeze ages are zero if the FREEZE option is given; otherwise pass
     385             :      * them as -1 which means to use the default values.
     386             :      */
     387       10354 :     if (params.options & VACOPT_FREEZE)
     388             :     {
     389        1148 :         params.freeze_min_age = 0;
     390        1148 :         params.freeze_table_age = 0;
     391        1148 :         params.multixact_freeze_min_age = 0;
     392        1148 :         params.multixact_freeze_table_age = 0;
     393             :     }
     394             :     else
     395             :     {
     396        9206 :         params.freeze_min_age = -1;
     397        9206 :         params.freeze_table_age = -1;
     398        9206 :         params.multixact_freeze_min_age = -1;
     399        9206 :         params.multixact_freeze_table_age = -1;
     400             :     }
     401             : 
     402             :     /* user-invoked vacuum is never "for wraparound" */
     403       10354 :     params.is_wraparound = false;
     404             : 
     405             :     /* user-invoked vacuum uses VACOPT_VERBOSE instead of log_min_duration */
     406       10354 :     params.log_min_duration = -1;
     407             : 
     408             :     /*
     409             :      * Create special memory context for cross-transaction storage.
     410             :      *
     411             :      * Since it is a child of PortalContext, it will go away eventually even
     412             :      * if we suffer an error; there's no need for special abort cleanup logic.
     413             :      */
     414       10354 :     vac_context = AllocSetContextCreate(PortalContext,
     415             :                                         "Vacuum",
     416             :                                         ALLOCSET_DEFAULT_SIZES);
     417             : 
     418             :     /*
     419             :      * Make a buffer strategy object in the cross-transaction memory context.
     420             :      * We needn't bother making this for VACUUM (FULL) or VACUUM
     421             :      * (ONLY_DATABASE_STATS) as they'll not make use of it.  VACUUM (FULL,
     422             :      * ANALYZE) is possible, so we'd better ensure that we make a strategy
     423             :      * when we see ANALYZE.
     424             :      */
     425       10354 :     if ((params.options & (VACOPT_ONLY_DATABASE_STATS |
     426         438 :                            VACOPT_FULL)) == 0 ||
     427         438 :         (params.options & VACOPT_ANALYZE) != 0)
     428             :     {
     429             : 
     430        9922 :         MemoryContext old_context = MemoryContextSwitchTo(vac_context);
     431             : 
     432             :         Assert(ring_size >= -1);
     433             : 
     434             :         /*
     435             :          * If BUFFER_USAGE_LIMIT was specified by the VACUUM or ANALYZE
     436             :          * command, it overrides the value of VacuumBufferUsageLimit.  Either
     437             :          * value may be 0, in which case GetAccessStrategyWithSize() will
     438             :          * return NULL, effectively allowing full use of shared buffers.
     439             :          */
     440        9922 :         if (ring_size == -1)
     441        9892 :             ring_size = VacuumBufferUsageLimit;
     442             : 
     443        9922 :         bstrategy = GetAccessStrategyWithSize(BAS_VACUUM, ring_size);
     444             : 
     445        9922 :         MemoryContextSwitchTo(old_context);
     446             :     }
     447             : 
     448             :     /* Now go through the common routine */
     449       10354 :     vacuum(vacstmt->rels, &params, bstrategy, vac_context, isTopLevel);
     450             : 
     451             :     /* Finally, clean up the vacuum memory context */
     452       10230 :     MemoryContextDelete(vac_context);
     453       10230 : }
     454             : 
     455             : /*
     456             :  * Internal entry point for autovacuum and the VACUUM / ANALYZE commands.
     457             :  *
     458             :  * relations, if not NIL, is a list of VacuumRelation to process; otherwise,
     459             :  * we process all relevant tables in the database.  For each VacuumRelation,
     460             :  * if a valid OID is supplied, the table with that OID is what to process;
     461             :  * otherwise, the VacuumRelation's RangeVar indicates what to process.
     462             :  *
     463             :  * params contains a set of parameters that can be used to customize the
     464             :  * behavior.
     465             :  *
     466             :  * bstrategy may be passed in as NULL when the caller does not want to
     467             :  * restrict the number of shared_buffers that VACUUM / ANALYZE can use,
     468             :  * otherwise, the caller must build a BufferAccessStrategy with the number of
     469             :  * shared_buffers that VACUUM / ANALYZE should try to limit themselves to
     470             :  * using.
     471             :  *
     472             :  * isTopLevel should be passed down from ProcessUtility.
     473             :  *
     474             :  * It is the caller's responsibility that all parameters are allocated in a
     475             :  * memory context that will not disappear at transaction commit.
     476             :  */
     477             : void
     478       10422 : vacuum(List *relations, VacuumParams *params, BufferAccessStrategy bstrategy,
     479             :        MemoryContext vac_context, bool isTopLevel)
     480             : {
     481             :     static bool in_vacuum = false;
     482             : 
     483             :     const char *stmttype;
     484             :     volatile bool in_outer_xact,
     485             :                 use_own_xacts;
     486             : 
     487             :     Assert(params != NULL);
     488             : 
     489       10422 :     stmttype = (params->options & VACOPT_VACUUM) ? "VACUUM" : "ANALYZE";
     490             : 
     491             :     /*
     492             :      * We cannot run VACUUM inside a user transaction block; if we were inside
     493             :      * a transaction, then our commit- and start-transaction-command calls
     494             :      * would not have the intended effect!  There are numerous other subtle
     495             :      * dependencies on this, too.
     496             :      *
     497             :      * ANALYZE (without VACUUM) can run either way.
     498             :      */
     499       10422 :     if (params->options & VACOPT_VACUUM)
     500             :     {
     501        5972 :         PreventInTransactionBlock(isTopLevel, stmttype);
     502        5960 :         in_outer_xact = false;
     503             :     }
     504             :     else
     505        4450 :         in_outer_xact = IsInTransactionBlock(isTopLevel);
     506             : 
     507             :     /*
     508             :      * Check for and disallow recursive calls.  This could happen when VACUUM
     509             :      * FULL or ANALYZE calls a hostile index expression that itself calls
     510             :      * ANALYZE.
     511             :      */
     512       10410 :     if (in_vacuum)
     513          12 :         ereport(ERROR,
     514             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     515             :                  errmsg("%s cannot be executed from VACUUM or ANALYZE",
     516             :                         stmttype)));
     517             : 
     518             :     /*
     519             :      * Build list of relation(s) to process, putting any new data in
     520             :      * vac_context for safekeeping.
     521             :      */
     522       10398 :     if (params->options & VACOPT_ONLY_DATABASE_STATS)
     523             :     {
     524             :         /* We don't process any tables in this case */
     525             :         Assert(relations == NIL);
     526             :     }
     527       10286 :     else if (relations != NIL)
     528             :     {
     529       10118 :         List       *newrels = NIL;
     530             :         ListCell   *lc;
     531             : 
     532       20324 :         foreach(lc, relations)
     533             :         {
     534       10242 :             VacuumRelation *vrel = lfirst_node(VacuumRelation, lc);
     535             :             List       *sublist;
     536             :             MemoryContext old_context;
     537             : 
     538       10242 :             sublist = expand_vacuum_rel(vrel, vac_context, params->options);
     539       10206 :             old_context = MemoryContextSwitchTo(vac_context);
     540       10206 :             newrels = list_concat(newrels, sublist);
     541       10206 :             MemoryContextSwitchTo(old_context);
     542             :         }
     543       10082 :         relations = newrels;
     544             :     }
     545             :     else
     546         168 :         relations = get_all_vacuum_rels(vac_context, params->options);
     547             : 
     548             :     /*
     549             :      * Decide whether we need to start/commit our own transactions.
     550             :      *
     551             :      * For VACUUM (with or without ANALYZE): always do so, so that we can
     552             :      * release locks as soon as possible.  (We could possibly use the outer
     553             :      * transaction for a one-table VACUUM, but handling TOAST tables would be
     554             :      * problematic.)
     555             :      *
     556             :      * For ANALYZE (no VACUUM): if inside a transaction block, we cannot
     557             :      * start/commit our own transactions.  Also, there's no need to do so if
     558             :      * only processing one relation.  For multiple relations when not within a
     559             :      * transaction block, and also in an autovacuum worker, use own
     560             :      * transactions so we can release locks sooner.
     561             :      */
     562       10362 :     if (params->options & VACOPT_VACUUM)
     563        5948 :         use_own_xacts = true;
     564             :     else
     565             :     {
     566             :         Assert(params->options & VACOPT_ANALYZE);
     567        4414 :         if (AmAutoVacuumWorkerProcess())
     568          42 :             use_own_xacts = true;
     569        4372 :         else if (in_outer_xact)
     570         214 :             use_own_xacts = false;
     571        4158 :         else if (list_length(relations) > 1)
     572         626 :             use_own_xacts = true;
     573             :         else
     574        3532 :             use_own_xacts = false;
     575             :     }
     576             : 
     577             :     /*
     578             :      * vacuum_rel expects to be entered with no transaction active; it will
     579             :      * start and commit its own transaction.  But we are called by an SQL
     580             :      * command, and so we are executing inside a transaction already. We
     581             :      * commit the transaction started in PostgresMain() here, and start
     582             :      * another one before exiting to match the commit waiting for us back in
     583             :      * PostgresMain().
     584             :      */
     585       10362 :     if (use_own_xacts)
     586             :     {
     587             :         Assert(!in_outer_xact);
     588             : 
     589             :         /* ActiveSnapshot is not set by autovacuum */
     590        6616 :         if (ActiveSnapshotSet())
     591        6548 :             PopActiveSnapshot();
     592             : 
     593             :         /* matches the StartTransaction in PostgresMain() */
     594        6616 :         CommitTransactionCommand();
     595             :     }
     596             : 
     597             :     /* Turn vacuum cost accounting on or off, and set/clear in_vacuum */
     598       10362 :     PG_TRY();
     599             :     {
     600             :         ListCell   *cur;
     601             : 
     602       10362 :         in_vacuum = true;
     603       10362 :         VacuumFailsafeActive = false;
     604       10362 :         VacuumUpdateCosts();
     605       10362 :         VacuumCostBalance = 0;
     606       10362 :         VacuumPageHit = 0;
     607       10362 :         VacuumPageMiss = 0;
     608       10362 :         VacuumPageDirty = 0;
     609       10362 :         VacuumCostBalanceLocal = 0;
     610       10362 :         VacuumSharedCostBalance = NULL;
     611       10362 :         VacuumActiveNWorkers = NULL;
     612             : 
     613             :         /*
     614             :          * Loop to process each selected relation.
     615             :          */
     616       34348 :         foreach(cur, relations)
     617             :         {
     618       24050 :             VacuumRelation *vrel = lfirst_node(VacuumRelation, cur);
     619             : 
     620       24050 :             if (params->options & VACOPT_VACUUM)
     621             :             {
     622       13000 :                 if (!vacuum_rel(vrel->oid, vrel->relation, params, bstrategy))
     623          98 :                     continue;
     624             :             }
     625             : 
     626       23946 :             if (params->options & VACOPT_ANALYZE)
     627             :             {
     628             :                 /*
     629             :                  * If using separate xacts, start one for analyze. Otherwise,
     630             :                  * we can use the outer transaction.
     631             :                  */
     632       12456 :                 if (use_own_xacts)
     633             :                 {
     634        8772 :                     StartTransactionCommand();
     635             :                     /* functions in indexes may want a snapshot set */
     636        8772 :                     PushActiveSnapshot(GetTransactionSnapshot());
     637             :                 }
     638             : 
     639       12456 :                 analyze_rel(vrel->oid, vrel->relation, params,
     640             :                             vrel->va_cols, in_outer_xact, bstrategy);
     641             : 
     642       12398 :                 if (use_own_xacts)
     643             :                 {
     644        8734 :                     PopActiveSnapshot();
     645        8734 :                     CommitTransactionCommand();
     646             :                 }
     647             :                 else
     648             :                 {
     649             :                     /*
     650             :                      * If we're not using separate xacts, better separate the
     651             :                      * ANALYZE actions with CCIs.  This avoids trouble if user
     652             :                      * says "ANALYZE t, t".
     653             :                      */
     654        3664 :                     CommandCounterIncrement();
     655             :                 }
     656             :             }
     657             : 
     658             :             /*
     659             :              * Ensure VacuumFailsafeActive has been reset before vacuuming the
     660             :              * next relation.
     661             :              */
     662       23888 :             VacuumFailsafeActive = false;
     663             :         }
     664             :     }
     665          64 :     PG_FINALLY();
     666             :     {
     667       10362 :         in_vacuum = false;
     668       10362 :         VacuumCostActive = false;
     669       10362 :         VacuumFailsafeActive = false;
     670       10362 :         VacuumCostBalance = 0;
     671             :     }
     672       10362 :     PG_END_TRY();
     673             : 
     674             :     /*
     675             :      * Finish up processing.
     676             :      */
     677       10298 :     if (use_own_xacts)
     678             :     {
     679             :         /* here, we are not in a transaction */
     680             : 
     681             :         /*
     682             :          * This matches the CommitTransaction waiting for us in
     683             :          * PostgresMain().
     684             :          */
     685        6572 :         StartTransactionCommand();
     686             :     }
     687             : 
     688       10298 :     if ((params->options & VACOPT_VACUUM) &&
     689        5916 :         !(params->options & VACOPT_SKIP_DATABASE_STATS))
     690             :     {
     691             :         /*
     692             :          * Update pg_database.datfrozenxid, and truncate pg_xact if possible.
     693             :          */
     694        1494 :         vac_update_datfrozenxid();
     695             :     }
     696             : 
     697       10298 : }
     698             : 
     699             : /*
     700             :  * Check if the current user has privileges to vacuum or analyze the relation.
     701             :  * If not, issue a WARNING log message and return false to let the caller
     702             :  * decide what to do with this relation.  This routine is used to decide if a
     703             :  * relation can be processed for VACUUM or ANALYZE.
     704             :  */
     705             : bool
     706       54674 : vacuum_is_permitted_for_relation(Oid relid, Form_pg_class reltuple,
     707             :                                  bits32 options)
     708             : {
     709             :     char       *relname;
     710             : 
     711             :     Assert((options & (VACOPT_VACUUM | VACOPT_ANALYZE)) != 0);
     712             : 
     713             :     /*----------
     714             :      * A role has privileges to vacuum or analyze the relation if any of the
     715             :      * following are true:
     716             :      *   - the role owns the current database and the relation is not shared
     717             :      *   - the role has the MAINTAIN privilege on the relation
     718             :      *----------
     719             :      */
     720       54674 :     if ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId()) &&
     721       62412 :          !reltuple->relisshared) ||
     722        8512 :         pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK)
     723       54334 :         return true;
     724             : 
     725         340 :     relname = NameStr(reltuple->relname);
     726             : 
     727         340 :     if ((options & VACOPT_VACUUM) != 0)
     728             :     {
     729         224 :         ereport(WARNING,
     730             :                 (errmsg("permission denied to vacuum \"%s\", skipping it",
     731             :                         relname)));
     732             : 
     733             :         /*
     734             :          * For VACUUM ANALYZE, both logs could show up, but just generate
     735             :          * information for VACUUM as that would be the first one to be
     736             :          * processed.
     737             :          */
     738         224 :         return false;
     739             :     }
     740             : 
     741         116 :     if ((options & VACOPT_ANALYZE) != 0)
     742         116 :         ereport(WARNING,
     743             :                 (errmsg("permission denied to analyze \"%s\", skipping it",
     744             :                         relname)));
     745             : 
     746         116 :     return false;
     747             : }
     748             : 
     749             : 
     750             : /*
     751             :  * vacuum_open_relation
     752             :  *
     753             :  * This routine is used for attempting to open and lock a relation which
     754             :  * is going to be vacuumed or analyzed.  If the relation cannot be opened
     755             :  * or locked, a log is emitted if possible.
     756             :  */
     757             : Relation
     758       32274 : vacuum_open_relation(Oid relid, RangeVar *relation, bits32 options,
     759             :                      bool verbose, LOCKMODE lmode)
     760             : {
     761             :     Relation    rel;
     762       32274 :     bool        rel_lock = true;
     763             :     int         elevel;
     764             : 
     765             :     Assert((options & (VACOPT_VACUUM | VACOPT_ANALYZE)) != 0);
     766             : 
     767             :     /*
     768             :      * Open the relation and get the appropriate lock on it.
     769             :      *
     770             :      * There's a race condition here: the relation may have gone away since
     771             :      * the last time we saw it.  If so, we don't need to vacuum or analyze it.
     772             :      *
     773             :      * If we've been asked not to wait for the relation lock, acquire it first
     774             :      * in non-blocking mode, before calling try_relation_open().
     775             :      */
     776       32274 :     if (!(options & VACOPT_SKIP_LOCKED))
     777       31724 :         rel = try_relation_open(relid, lmode);
     778         550 :     else if (ConditionalLockRelationOid(relid, lmode))
     779         530 :         rel = try_relation_open(relid, NoLock);
     780             :     else
     781             :     {
     782          20 :         rel = NULL;
     783          20 :         rel_lock = false;
     784             :     }
     785             : 
     786             :     /* if relation is opened, leave */
     787       32274 :     if (rel)
     788       32242 :         return rel;
     789             : 
     790             :     /*
     791             :      * Relation could not be opened, hence generate if possible a log
     792             :      * informing on the situation.
     793             :      *
     794             :      * If the RangeVar is not defined, we do not have enough information to
     795             :      * provide a meaningful log statement.  Chances are that the caller has
     796             :      * intentionally not provided this information so that this logging is
     797             :      * skipped, anyway.
     798             :      */
     799          32 :     if (relation == NULL)
     800          18 :         return NULL;
     801             : 
     802             :     /*
     803             :      * Determine the log level.
     804             :      *
     805             :      * For manual VACUUM or ANALYZE, we emit a WARNING to match the log
     806             :      * statements in the permission checks; otherwise, only log if the caller
     807             :      * so requested.
     808             :      */
     809          14 :     if (!AmAutoVacuumWorkerProcess())
     810          14 :         elevel = WARNING;
     811           0 :     else if (verbose)
     812           0 :         elevel = LOG;
     813             :     else
     814           0 :         return NULL;
     815             : 
     816          14 :     if ((options & VACOPT_VACUUM) != 0)
     817             :     {
     818          10 :         if (!rel_lock)
     819           6 :             ereport(elevel,
     820             :                     (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
     821             :                      errmsg("skipping vacuum of \"%s\" --- lock not available",
     822             :                             relation->relname)));
     823             :         else
     824           4 :             ereport(elevel,
     825             :                     (errcode(ERRCODE_UNDEFINED_TABLE),
     826             :                      errmsg("skipping vacuum of \"%s\" --- relation no longer exists",
     827             :                             relation->relname)));
     828             : 
     829             :         /*
     830             :          * For VACUUM ANALYZE, both logs could show up, but just generate
     831             :          * information for VACUUM as that would be the first one to be
     832             :          * processed.
     833             :          */
     834          10 :         return NULL;
     835             :     }
     836             : 
     837           4 :     if ((options & VACOPT_ANALYZE) != 0)
     838             :     {
     839           4 :         if (!rel_lock)
     840           2 :             ereport(elevel,
     841             :                     (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
     842             :                      errmsg("skipping analyze of \"%s\" --- lock not available",
     843             :                             relation->relname)));
     844             :         else
     845           2 :             ereport(elevel,
     846             :                     (errcode(ERRCODE_UNDEFINED_TABLE),
     847             :                      errmsg("skipping analyze of \"%s\" --- relation no longer exists",
     848             :                             relation->relname)));
     849             :     }
     850             : 
     851           4 :     return NULL;
     852             : }
     853             : 
     854             : 
     855             : /*
     856             :  * Given a VacuumRelation, fill in the table OID if it wasn't specified,
     857             :  * and optionally add VacuumRelations for partitions of the table.
     858             :  *
     859             :  * If a VacuumRelation does not have an OID supplied and is a partitioned
     860             :  * table, an extra entry will be added to the output for each partition.
     861             :  * Presently, only autovacuum supplies OIDs when calling vacuum(), and
     862             :  * it does not want us to expand partitioned tables.
     863             :  *
     864             :  * We take care not to modify the input data structure, but instead build
     865             :  * new VacuumRelation(s) to return.  (But note that they will reference
     866             :  * unmodified parts of the input, eg column lists.)  New data structures
     867             :  * are made in vac_context.
     868             :  */
     869             : static List *
     870       10242 : expand_vacuum_rel(VacuumRelation *vrel, MemoryContext vac_context,
     871             :                   int options)
     872             : {
     873       10242 :     List       *vacrels = NIL;
     874             :     MemoryContext oldcontext;
     875             : 
     876             :     /* If caller supplied OID, there's nothing we need do here. */
     877       10242 :     if (OidIsValid(vrel->oid))
     878             :     {
     879          68 :         oldcontext = MemoryContextSwitchTo(vac_context);
     880          68 :         vacrels = lappend(vacrels, vrel);
     881          68 :         MemoryContextSwitchTo(oldcontext);
     882             :     }
     883             :     else
     884             :     {
     885             :         /* Process a specific relation, and possibly partitions thereof */
     886             :         Oid         relid;
     887             :         HeapTuple   tuple;
     888             :         Form_pg_class classForm;
     889             :         bool        include_parts;
     890             :         int         rvr_opts;
     891             : 
     892             :         /*
     893             :          * Since autovacuum workers supply OIDs when calling vacuum(), no
     894             :          * autovacuum worker should reach this code.
     895             :          */
     896             :         Assert(!AmAutoVacuumWorkerProcess());
     897             : 
     898             :         /*
     899             :          * We transiently take AccessShareLock to protect the syscache lookup
     900             :          * below, as well as find_all_inheritors's expectation that the caller
     901             :          * holds some lock on the starting relation.
     902             :          */
     903       10174 :         rvr_opts = (options & VACOPT_SKIP_LOCKED) ? RVR_SKIP_LOCKED : 0;
     904       10174 :         relid = RangeVarGetRelidExtended(vrel->relation,
     905             :                                          AccessShareLock,
     906             :                                          rvr_opts,
     907             :                                          NULL, NULL);
     908             : 
     909             :         /*
     910             :          * If the lock is unavailable, emit the same log statement that
     911             :          * vacuum_rel() and analyze_rel() would.
     912             :          */
     913       10138 :         if (!OidIsValid(relid))
     914             :         {
     915           8 :             if (options & VACOPT_VACUUM)
     916           6 :                 ereport(WARNING,
     917             :                         (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
     918             :                          errmsg("skipping vacuum of \"%s\" --- lock not available",
     919             :                                 vrel->relation->relname)));
     920             :             else
     921           2 :                 ereport(WARNING,
     922             :                         (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
     923             :                          errmsg("skipping analyze of \"%s\" --- lock not available",
     924             :                                 vrel->relation->relname)));
     925           8 :             return vacrels;
     926             :         }
     927             : 
     928             :         /*
     929             :          * To check whether the relation is a partitioned table and its
     930             :          * ownership, fetch its syscache entry.
     931             :          */
     932       10130 :         tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
     933       10130 :         if (!HeapTupleIsValid(tuple))
     934           0 :             elog(ERROR, "cache lookup failed for relation %u", relid);
     935       10130 :         classForm = (Form_pg_class) GETSTRUCT(tuple);
     936             : 
     937             :         /*
     938             :          * Make a returnable VacuumRelation for this rel if the user has the
     939             :          * required privileges.
     940             :          */
     941       10130 :         if (vacuum_is_permitted_for_relation(relid, classForm, options))
     942             :         {
     943        9898 :             oldcontext = MemoryContextSwitchTo(vac_context);
     944        9898 :             vacrels = lappend(vacrels, makeVacuumRelation(vrel->relation,
     945             :                                                           relid,
     946             :                                                           vrel->va_cols));
     947        9898 :             MemoryContextSwitchTo(oldcontext);
     948             :         }
     949             : 
     950             : 
     951       10130 :         include_parts = (classForm->relkind == RELKIND_PARTITIONED_TABLE);
     952       10130 :         ReleaseSysCache(tuple);
     953             : 
     954             :         /*
     955             :          * If it is, make relation list entries for its partitions.  Note that
     956             :          * the list returned by find_all_inheritors() includes the passed-in
     957             :          * OID, so we have to skip that.  There's no point in taking locks on
     958             :          * the individual partitions yet, and doing so would just add
     959             :          * unnecessary deadlock risk.  For this last reason we do not check
     960             :          * yet the ownership of the partitions, which get added to the list to
     961             :          * process.  Ownership will be checked later on anyway.
     962             :          */
     963       10130 :         if (include_parts)
     964             :         {
     965         684 :             List       *part_oids = find_all_inheritors(relid, NoLock, NULL);
     966             :             ListCell   *part_lc;
     967             : 
     968        3198 :             foreach(part_lc, part_oids)
     969             :             {
     970        2514 :                 Oid         part_oid = lfirst_oid(part_lc);
     971             : 
     972        2514 :                 if (part_oid == relid)
     973         684 :                     continue;   /* ignore original table */
     974             : 
     975             :                 /*
     976             :                  * We omit a RangeVar since it wouldn't be appropriate to
     977             :                  * complain about failure to open one of these relations
     978             :                  * later.
     979             :                  */
     980        1830 :                 oldcontext = MemoryContextSwitchTo(vac_context);
     981        1830 :                 vacrels = lappend(vacrels, makeVacuumRelation(NULL,
     982             :                                                               part_oid,
     983             :                                                               vrel->va_cols));
     984        1830 :                 MemoryContextSwitchTo(oldcontext);
     985             :             }
     986             :         }
     987             : 
     988             :         /*
     989             :          * Release lock again.  This means that by the time we actually try to
     990             :          * process the table, it might be gone or renamed.  In the former case
     991             :          * we'll silently ignore it; in the latter case we'll process it
     992             :          * anyway, but we must beware that the RangeVar doesn't necessarily
     993             :          * identify it anymore.  This isn't ideal, perhaps, but there's little
     994             :          * practical alternative, since we're typically going to commit this
     995             :          * transaction and begin a new one between now and then.  Moreover,
     996             :          * holding locks on multiple relations would create significant risk
     997             :          * of deadlock.
     998             :          */
     999       10130 :         UnlockRelationOid(relid, AccessShareLock);
    1000             :     }
    1001             : 
    1002       10198 :     return vacrels;
    1003             : }
    1004             : 
    1005             : /*
    1006             :  * Construct a list of VacuumRelations for all vacuumable rels in
    1007             :  * the current database.  The list is built in vac_context.
    1008             :  */
    1009             : static List *
    1010         168 : get_all_vacuum_rels(MemoryContext vac_context, int options)
    1011             : {
    1012         168 :     List       *vacrels = NIL;
    1013             :     Relation    pgclass;
    1014             :     TableScanDesc scan;
    1015             :     HeapTuple   tuple;
    1016             : 
    1017         168 :     pgclass = table_open(RelationRelationId, AccessShareLock);
    1018             : 
    1019         168 :     scan = table_beginscan_catalog(pgclass, 0, NULL);
    1020             : 
    1021       71968 :     while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    1022             :     {
    1023       71800 :         Form_pg_class classForm = (Form_pg_class) GETSTRUCT(tuple);
    1024             :         MemoryContext oldcontext;
    1025       71800 :         Oid         relid = classForm->oid;
    1026             : 
    1027             :         /*
    1028             :          * We include partitioned tables here; depending on which operation is
    1029             :          * to be performed, caller will decide whether to process or ignore
    1030             :          * them.
    1031             :          */
    1032       71800 :         if (classForm->relkind != RELKIND_RELATION &&
    1033       59546 :             classForm->relkind != RELKIND_MATVIEW &&
    1034       59540 :             classForm->relkind != RELKIND_PARTITIONED_TABLE)
    1035       59498 :             continue;
    1036             : 
    1037             :         /* check permissions of relation */
    1038       12302 :         if (!vacuum_is_permitted_for_relation(relid, classForm, options))
    1039           0 :             continue;
    1040             : 
    1041             :         /*
    1042             :          * Build VacuumRelation(s) specifying the table OIDs to be processed.
    1043             :          * We omit a RangeVar since it wouldn't be appropriate to complain
    1044             :          * about failure to open one of these relations later.
    1045             :          */
    1046       12302 :         oldcontext = MemoryContextSwitchTo(vac_context);
    1047       12302 :         vacrels = lappend(vacrels, makeVacuumRelation(NULL,
    1048             :                                                       relid,
    1049             :                                                       NIL));
    1050       12302 :         MemoryContextSwitchTo(oldcontext);
    1051             :     }
    1052             : 
    1053         168 :     table_endscan(scan);
    1054         168 :     table_close(pgclass, AccessShareLock);
    1055             : 
    1056         168 :     return vacrels;
    1057             : }
    1058             : 
    1059             : /*
    1060             :  * vacuum_get_cutoffs() -- compute OldestXmin and freeze cutoff points
    1061             :  *
    1062             :  * The target relation and VACUUM parameters are our inputs.
    1063             :  *
    1064             :  * Output parameters are the cutoffs that VACUUM caller should use.
    1065             :  *
    1066             :  * Return value indicates if vacuumlazy.c caller should make its VACUUM
    1067             :  * operation aggressive.  An aggressive VACUUM must advance relfrozenxid up to
    1068             :  * FreezeLimit (at a minimum), and relminmxid up to MultiXactCutoff (at a
    1069             :  * minimum).
    1070             :  */
    1071             : bool
    1072       19604 : vacuum_get_cutoffs(Relation rel, const VacuumParams *params,
    1073             :                    struct VacuumCutoffs *cutoffs)
    1074             : {
    1075             :     int         freeze_min_age,
    1076             :                 multixact_freeze_min_age,
    1077             :                 freeze_table_age,
    1078             :                 multixact_freeze_table_age,
    1079             :                 effective_multixact_freeze_max_age;
    1080             :     TransactionId nextXID,
    1081             :                 safeOldestXmin,
    1082             :                 aggressiveXIDCutoff;
    1083             :     MultiXactId nextMXID,
    1084             :                 safeOldestMxact,
    1085             :                 aggressiveMXIDCutoff;
    1086             : 
    1087             :     /* Use mutable copies of freeze age parameters */
    1088       19604 :     freeze_min_age = params->freeze_min_age;
    1089       19604 :     multixact_freeze_min_age = params->multixact_freeze_min_age;
    1090       19604 :     freeze_table_age = params->freeze_table_age;
    1091       19604 :     multixact_freeze_table_age = params->multixact_freeze_table_age;
    1092             : 
    1093             :     /* Set pg_class fields in cutoffs */
    1094       19604 :     cutoffs->relfrozenxid = rel->rd_rel->relfrozenxid;
    1095       19604 :     cutoffs->relminmxid = rel->rd_rel->relminmxid;
    1096             : 
    1097             :     /*
    1098             :      * Acquire OldestXmin.
    1099             :      *
    1100             :      * We can always ignore processes running lazy vacuum.  This is because we
    1101             :      * use these values only for deciding which tuples we must keep in the
    1102             :      * tables.  Since lazy vacuum doesn't write its XID anywhere (usually no
    1103             :      * XID assigned), it's safe to ignore it.  In theory it could be
    1104             :      * problematic to ignore lazy vacuums in a full vacuum, but keep in mind
    1105             :      * that only one vacuum process can be working on a particular table at
    1106             :      * any time, and that each vacuum is always an independent transaction.
    1107             :      */
    1108       19604 :     cutoffs->OldestXmin = GetOldestNonRemovableTransactionId(rel);
    1109             : 
    1110             :     Assert(TransactionIdIsNormal(cutoffs->OldestXmin));
    1111             : 
    1112             :     /* Acquire OldestMxact */
    1113       19604 :     cutoffs->OldestMxact = GetOldestMultiXactId();
    1114             :     Assert(MultiXactIdIsValid(cutoffs->OldestMxact));
    1115             : 
    1116             :     /* Acquire next XID/next MXID values used to apply age-based settings */
    1117       19604 :     nextXID = ReadNextTransactionId();
    1118       19604 :     nextMXID = ReadNextMultiXactId();
    1119             : 
    1120             :     /*
    1121             :      * Also compute the multixact age for which freezing is urgent.  This is
    1122             :      * normally autovacuum_multixact_freeze_max_age, but may be less if we are
    1123             :      * short of multixact member space.
    1124             :      */
    1125       19604 :     effective_multixact_freeze_max_age = MultiXactMemberFreezeThreshold();
    1126             : 
    1127             :     /*
    1128             :      * Almost ready to set freeze output parameters; check if OldestXmin or
    1129             :      * OldestMxact are held back to an unsafe degree before we start on that
    1130             :      */
    1131       19604 :     safeOldestXmin = nextXID - autovacuum_freeze_max_age;
    1132       19604 :     if (!TransactionIdIsNormal(safeOldestXmin))
    1133           0 :         safeOldestXmin = FirstNormalTransactionId;
    1134       19604 :     safeOldestMxact = nextMXID - effective_multixact_freeze_max_age;
    1135       19604 :     if (safeOldestMxact < FirstMultiXactId)
    1136           0 :         safeOldestMxact = FirstMultiXactId;
    1137       19604 :     if (TransactionIdPrecedes(cutoffs->OldestXmin, safeOldestXmin))
    1138           0 :         ereport(WARNING,
    1139             :                 (errmsg("cutoff for removing and freezing tuples is far in the past"),
    1140             :                  errhint("Close open transactions soon to avoid wraparound problems.\n"
    1141             :                          "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    1142       19604 :     if (MultiXactIdPrecedes(cutoffs->OldestMxact, safeOldestMxact))
    1143           0 :         ereport(WARNING,
    1144             :                 (errmsg("cutoff for freezing multixacts is far in the past"),
    1145             :                  errhint("Close open transactions soon to avoid wraparound problems.\n"
    1146             :                          "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    1147             : 
    1148             :     /*
    1149             :      * Determine the minimum freeze age to use: as specified by the caller, or
    1150             :      * vacuum_freeze_min_age, but in any case not more than half
    1151             :      * autovacuum_freeze_max_age, so that autovacuums to prevent XID
    1152             :      * wraparound won't occur too frequently.
    1153             :      */
    1154       19604 :     if (freeze_min_age < 0)
    1155        8522 :         freeze_min_age = vacuum_freeze_min_age;
    1156       19604 :     freeze_min_age = Min(freeze_min_age, autovacuum_freeze_max_age / 2);
    1157             :     Assert(freeze_min_age >= 0);
    1158             : 
    1159             :     /* Compute FreezeLimit, being careful to generate a normal XID */
    1160       19604 :     cutoffs->FreezeLimit = nextXID - freeze_min_age;
    1161       19604 :     if (!TransactionIdIsNormal(cutoffs->FreezeLimit))
    1162           0 :         cutoffs->FreezeLimit = FirstNormalTransactionId;
    1163             :     /* FreezeLimit must always be <= OldestXmin */
    1164       19604 :     if (TransactionIdPrecedes(cutoffs->OldestXmin, cutoffs->FreezeLimit))
    1165         606 :         cutoffs->FreezeLimit = cutoffs->OldestXmin;
    1166             : 
    1167             :     /*
    1168             :      * Determine the minimum multixact freeze age to use: as specified by
    1169             :      * caller, or vacuum_multixact_freeze_min_age, but in any case not more
    1170             :      * than half effective_multixact_freeze_max_age, so that autovacuums to
    1171             :      * prevent MultiXact wraparound won't occur too frequently.
    1172             :      */
    1173       19604 :     if (multixact_freeze_min_age < 0)
    1174        8522 :         multixact_freeze_min_age = vacuum_multixact_freeze_min_age;
    1175       19604 :     multixact_freeze_min_age = Min(multixact_freeze_min_age,
    1176             :                                    effective_multixact_freeze_max_age / 2);
    1177             :     Assert(multixact_freeze_min_age >= 0);
    1178             : 
    1179             :     /* Compute MultiXactCutoff, being careful to generate a valid value */
    1180       19604 :     cutoffs->MultiXactCutoff = nextMXID - multixact_freeze_min_age;
    1181       19604 :     if (cutoffs->MultiXactCutoff < FirstMultiXactId)
    1182           0 :         cutoffs->MultiXactCutoff = FirstMultiXactId;
    1183             :     /* MultiXactCutoff must always be <= OldestMxact */
    1184       19604 :     if (MultiXactIdPrecedes(cutoffs->OldestMxact, cutoffs->MultiXactCutoff))
    1185           4 :         cutoffs->MultiXactCutoff = cutoffs->OldestMxact;
    1186             : 
    1187             :     /*
    1188             :      * Finally, figure out if caller needs to do an aggressive VACUUM or not.
    1189             :      *
    1190             :      * Determine the table freeze age to use: as specified by the caller, or
    1191             :      * the value of the vacuum_freeze_table_age GUC, but in any case not more
    1192             :      * than autovacuum_freeze_max_age * 0.95, so that if you have e.g nightly
    1193             :      * VACUUM schedule, the nightly VACUUM gets a chance to freeze XIDs before
    1194             :      * anti-wraparound autovacuum is launched.
    1195             :      */
    1196       19604 :     if (freeze_table_age < 0)
    1197        8522 :         freeze_table_age = vacuum_freeze_table_age;
    1198       19604 :     freeze_table_age = Min(freeze_table_age, autovacuum_freeze_max_age * 0.95);
    1199             :     Assert(freeze_table_age >= 0);
    1200       19604 :     aggressiveXIDCutoff = nextXID - freeze_table_age;
    1201       19604 :     if (!TransactionIdIsNormal(aggressiveXIDCutoff))
    1202           0 :         aggressiveXIDCutoff = FirstNormalTransactionId;
    1203       19604 :     if (TransactionIdPrecedesOrEquals(rel->rd_rel->relfrozenxid,
    1204             :                                       aggressiveXIDCutoff))
    1205       11060 :         return true;
    1206             : 
    1207             :     /*
    1208             :      * Similar to the above, determine the table freeze age to use for
    1209             :      * multixacts: as specified by the caller, or the value of the
    1210             :      * vacuum_multixact_freeze_table_age GUC, but in any case not more than
    1211             :      * effective_multixact_freeze_max_age * 0.95, so that if you have e.g.
    1212             :      * nightly VACUUM schedule, the nightly VACUUM gets a chance to freeze
    1213             :      * multixacts before anti-wraparound autovacuum is launched.
    1214             :      */
    1215        8544 :     if (multixact_freeze_table_age < 0)
    1216        8522 :         multixact_freeze_table_age = vacuum_multixact_freeze_table_age;
    1217        8544 :     multixact_freeze_table_age =
    1218        8544 :         Min(multixact_freeze_table_age,
    1219             :             effective_multixact_freeze_max_age * 0.95);
    1220             :     Assert(multixact_freeze_table_age >= 0);
    1221        8544 :     aggressiveMXIDCutoff = nextMXID - multixact_freeze_table_age;
    1222        8544 :     if (aggressiveMXIDCutoff < FirstMultiXactId)
    1223           0 :         aggressiveMXIDCutoff = FirstMultiXactId;
    1224        8544 :     if (MultiXactIdPrecedesOrEquals(rel->rd_rel->relminmxid,
    1225             :                                     aggressiveMXIDCutoff))
    1226           0 :         return true;
    1227             : 
    1228             :     /* Non-aggressive VACUUM */
    1229        8544 :     return false;
    1230             : }
    1231             : 
    1232             : /*
    1233             :  * vacuum_xid_failsafe_check() -- Used by VACUUM's wraparound failsafe
    1234             :  * mechanism to determine if its table's relfrozenxid and relminmxid are now
    1235             :  * dangerously far in the past.
    1236             :  *
    1237             :  * When we return true, VACUUM caller triggers the failsafe.
    1238             :  */
    1239             : bool
    1240       21564 : vacuum_xid_failsafe_check(const struct VacuumCutoffs *cutoffs)
    1241             : {
    1242       21564 :     TransactionId relfrozenxid = cutoffs->relfrozenxid;
    1243       21564 :     MultiXactId relminmxid = cutoffs->relminmxid;
    1244             :     TransactionId xid_skip_limit;
    1245             :     MultiXactId multi_skip_limit;
    1246             :     int         skip_index_vacuum;
    1247             : 
    1248             :     Assert(TransactionIdIsNormal(relfrozenxid));
    1249             :     Assert(MultiXactIdIsValid(relminmxid));
    1250             : 
    1251             :     /*
    1252             :      * Determine the index skipping age to use. In any case no less than
    1253             :      * autovacuum_freeze_max_age * 1.05.
    1254             :      */
    1255       21564 :     skip_index_vacuum = Max(vacuum_failsafe_age, autovacuum_freeze_max_age * 1.05);
    1256             : 
    1257       21564 :     xid_skip_limit = ReadNextTransactionId() - skip_index_vacuum;
    1258       21564 :     if (!TransactionIdIsNormal(xid_skip_limit))
    1259           0 :         xid_skip_limit = FirstNormalTransactionId;
    1260             : 
    1261       21564 :     if (TransactionIdPrecedes(relfrozenxid, xid_skip_limit))
    1262             :     {
    1263             :         /* The table's relfrozenxid is too old */
    1264           0 :         return true;
    1265             :     }
    1266             : 
    1267             :     /*
    1268             :      * Similar to above, determine the index skipping age to use for
    1269             :      * multixact. In any case no less than autovacuum_multixact_freeze_max_age *
    1270             :      * 1.05.
    1271             :      */
    1272       21564 :     skip_index_vacuum = Max(vacuum_multixact_failsafe_age,
    1273             :                             autovacuum_multixact_freeze_max_age * 1.05);
    1274             : 
    1275       21564 :     multi_skip_limit = ReadNextMultiXactId() - skip_index_vacuum;
    1276       21564 :     if (multi_skip_limit < FirstMultiXactId)
    1277           0 :         multi_skip_limit = FirstMultiXactId;
    1278             : 
    1279       21564 :     if (MultiXactIdPrecedes(relminmxid, multi_skip_limit))
    1280             :     {
    1281             :         /* The table's relminmxid is too old */
    1282           0 :         return true;
    1283             :     }
    1284             : 
    1285       21564 :     return false;
    1286             : }
    1287             : 
    1288             : /*
    1289             :  * vac_estimate_reltuples() -- estimate the new value for pg_class.reltuples
    1290             :  *
    1291             :  *      If we scanned the whole relation then we should just use the count of
    1292             :  *      live tuples seen; but if we did not, we should not blindly extrapolate
    1293             :  *      from that number, since VACUUM may have scanned a quite nonrandom
    1294             :  *      subset of the table.  When we have only partial information, we take
    1295             :  *      the old value of pg_class.reltuples/pg_class.relpages as a measurement
    1296             :  *      of the tuple density in the unscanned pages.
    1297             :  *
    1298             :  *      Note: scanned_tuples should count only *live* tuples, since
    1299             :  *      pg_class.reltuples is defined that way.
    1300             :  */
    1301             : double
    1302       19082 : vac_estimate_reltuples(Relation relation,
    1303             :                        BlockNumber total_pages,
    1304             :                        BlockNumber scanned_pages,
    1305             :                        double scanned_tuples)
    1306             : {
    1307       19082 :     BlockNumber old_rel_pages = relation->rd_rel->relpages;
    1308       19082 :     double      old_rel_tuples = relation->rd_rel->reltuples;
    1309             :     double      old_density;
    1310             :     double      unscanned_pages;
    1311             :     double      total_tuples;
    1312             : 
    1313             :     /* If we did scan the whole table, just use the count as-is */
    1314       19082 :     if (scanned_pages >= total_pages)
    1315       18756 :         return scanned_tuples;
    1316             : 
    1317             :     /*
    1318             :      * When successive VACUUM commands scan the same few pages again and
    1319             :      * again, without anything from the table really changing, there is a risk
    1320             :      * that our beliefs about tuple density will gradually become distorted.
    1321             :      * This might be caused by vacuumlazy.c implementation details, such as
    1322             :      * its tendency to always scan the last heap page.  Handle that here.
    1323             :      *
    1324             :      * If the relation is _exactly_ the same size according to the existing
    1325             :      * pg_class entry, and only a few of its pages (less than 2%) were
    1326             :      * scanned, keep the existing value of reltuples.  Also keep the existing
    1327             :      * value when only a subset of rel's pages <= a single page were scanned.
    1328             :      *
    1329             :      * (Note: we might be returning -1 here.)
    1330             :      */
    1331         326 :     if (old_rel_pages == total_pages &&
    1332         306 :         scanned_pages < (double) total_pages * 0.02)
    1333         200 :         return old_rel_tuples;
    1334         126 :     if (scanned_pages <= 1)
    1335          96 :         return old_rel_tuples;
    1336             : 
    1337             :     /*
    1338             :      * If old density is unknown, we can't do much except scale up
    1339             :      * scanned_tuples to match total_pages.
    1340             :      */
    1341          30 :     if (old_rel_tuples < 0 || old_rel_pages == 0)
    1342           2 :         return floor((scanned_tuples / scanned_pages) * total_pages + 0.5);
    1343             : 
    1344             :     /*
    1345             :      * Okay, we've covered the corner cases.  The normal calculation is to
    1346             :      * convert the old measurement to a density (tuples per page), then
    1347             :      * estimate the number of tuples in the unscanned pages using that figure,
    1348             :      * and finally add on the number of tuples in the scanned pages.
    1349             :      */
    1350          28 :     old_density = old_rel_tuples / old_rel_pages;
    1351          28 :     unscanned_pages = (double) total_pages - (double) scanned_pages;
    1352          28 :     total_tuples = old_density * unscanned_pages + scanned_tuples;
    1353          28 :     return floor(total_tuples + 0.5);
    1354             : }
    1355             : 
    1356             : 
    1357             : /*
    1358             :  *  vac_update_relstats() -- update statistics for one relation
    1359             :  *
    1360             :  *      Update the whole-relation statistics that are kept in its pg_class
    1361             :  *      row.  There are additional stats that will be updated if we are
    1362             :  *      doing ANALYZE, but we always update these stats.  This routine works
    1363             :  *      for both index and heap relation entries in pg_class.
    1364             :  *
    1365             :  *      We violate transaction semantics here by overwriting the rel's
    1366             :  *      existing pg_class tuple with the new values.  This is reasonably
    1367             :  *      safe as long as we're sure that the new values are correct whether or
    1368             :  *      not this transaction commits.  The reason for doing this is that if
    1369             :  *      we updated these tuples in the usual way, vacuuming pg_class itself
    1370             :  *      wouldn't work very well --- by the time we got done with a vacuum
    1371             :  *      cycle, most of the tuples in pg_class would've been obsoleted.  Of
    1372             :  *      course, this only works for fixed-size not-null columns, but these are.
    1373             :  *
    1374             :  *      Another reason for doing it this way is that when we are in a lazy
    1375             :  *      VACUUM and have PROC_IN_VACUUM set, we mustn't do any regular updates.
    1376             :  *      Somebody vacuuming pg_class might think they could delete a tuple
    1377             :  *      marked with xmin = our xid.
    1378             :  *
    1379             :  *      In addition to fundamentally nontransactional statistics such as
    1380             :  *      relpages and relallvisible, we try to maintain certain lazily-updated
    1381             :  *      DDL flags such as relhasindex, by clearing them if no longer correct.
    1382             :  *      It's safe to do this in VACUUM, which can't run in parallel with
    1383             :  *      CREATE INDEX/RULE/TRIGGER and can't be part of a transaction block.
    1384             :  *      However, it's *not* safe to do it in an ANALYZE that's within an
    1385             :  *      outer transaction, because for example the current transaction might
    1386             :  *      have dropped the last index; then we'd think relhasindex should be
    1387             :  *      cleared, but if the transaction later rolls back this would be wrong.
    1388             :  *      So we refrain from updating the DDL flags if we're inside an outer
    1389             :  *      transaction.  This is OK since postponing the flag maintenance is
    1390             :  *      always allowable.
    1391             :  *
    1392             :  *      Note: num_tuples should count only *live* tuples, since
    1393             :  *      pg_class.reltuples is defined that way.
    1394             :  *
    1395             :  *      This routine is shared by VACUUM and ANALYZE.
    1396             :  */
    1397             : void
    1398       49952 : vac_update_relstats(Relation relation,
    1399             :                     BlockNumber num_pages, double num_tuples,
    1400             :                     BlockNumber num_all_visible_pages,
    1401             :                     bool hasindex, TransactionId frozenxid,
    1402             :                     MultiXactId minmulti,
    1403             :                     bool *frozenxid_updated, bool *minmulti_updated,
    1404             :                     bool in_outer_xact)
    1405             : {
    1406       49952 :     Oid         relid = RelationGetRelid(relation);
    1407             :     Relation    rd;
    1408             :     HeapTuple   ctup;
    1409             :     Form_pg_class pgcform;
    1410             :     bool        dirty,
    1411             :                 futurexid,
    1412             :                 futuremxid;
    1413             :     TransactionId oldfrozenxid;
    1414             :     MultiXactId oldminmulti;
    1415             : 
    1416       49952 :     rd = table_open(RelationRelationId, RowExclusiveLock);
    1417             : 
    1418             :     /* Fetch a copy of the tuple to scribble on */
    1419       49952 :     ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
    1420       49952 :     if (!HeapTupleIsValid(ctup))
    1421           0 :         elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
    1422             :              relid);
    1423       49952 :     pgcform = (Form_pg_class) GETSTRUCT(ctup);
    1424             : 
    1425             :     /* Apply statistical updates, if any, to copied tuple */
    1426             : 
    1427       49952 :     dirty = false;
    1428       49952 :     if (pgcform->relpages != (int32) num_pages)
    1429             :     {
    1430        7356 :         pgcform->relpages = (int32) num_pages;
    1431        7356 :         dirty = true;
    1432             :     }
    1433       49952 :     if (pgcform->reltuples != (float4) num_tuples)
    1434             :     {
    1435       15760 :         pgcform->reltuples = (float4) num_tuples;
    1436       15760 :         dirty = true;
    1437             :     }
    1438       49952 :     if (pgcform->relallvisible != (int32) num_all_visible_pages)
    1439             :     {
    1440        4484 :         pgcform->relallvisible = (int32) num_all_visible_pages;
    1441        4484 :         dirty = true;
    1442             :     }
    1443             : 
    1444             :     /* Apply DDL updates, but not inside an outer transaction (see above) */
    1445             : 
    1446       49952 :     if (!in_outer_xact)
    1447             :     {
    1448             :         /*
    1449             :          * If we didn't find any indexes, reset relhasindex.
    1450             :          */
    1451       49674 :         if (pgcform->relhasindex && !hasindex)
    1452             :         {
    1453          18 :             pgcform->relhasindex = false;
    1454          18 :             dirty = true;
    1455             :         }
    1456             : 
    1457             :         /* We also clear relhasrules and relhastriggers if needed */
    1458       49674 :         if (pgcform->relhasrules && relation->rd_rules == NULL)
    1459             :         {
    1460           0 :             pgcform->relhasrules = false;
    1461           0 :             dirty = true;
    1462             :         }
    1463       49674 :         if (pgcform->relhastriggers && relation->trigdesc == NULL)
    1464             :         {
    1465           6 :             pgcform->relhastriggers = false;
    1466           6 :             dirty = true;
    1467             :         }
    1468             :     }
    1469             : 
    1470             :     /*
    1471             :      * Update relfrozenxid, unless caller passed InvalidTransactionId
    1472             :      * indicating it has no new data.
    1473             :      *
    1474             :      * Ordinarily, we don't let relfrozenxid go backwards.  However, if the
    1475             :      * stored relfrozenxid is "in the future" then it seems best to assume
    1476             :      * it's corrupt, and overwrite with the oldest remaining XID in the table.
    1477             :      * This should match vac_update_datfrozenxid() concerning what we consider
    1478             :      * to be "in the future".
    1479             :      */
    1480       49952 :     oldfrozenxid = pgcform->relfrozenxid;
    1481       49952 :     futurexid = false;
    1482       49952 :     if (frozenxid_updated)
    1483       19078 :         *frozenxid_updated = false;
    1484       49952 :     if (TransactionIdIsNormal(frozenxid) && oldfrozenxid != frozenxid)
    1485             :     {
    1486       16646 :         bool        update = false;
    1487             : 
    1488       16646 :         if (TransactionIdPrecedes(oldfrozenxid, frozenxid))
    1489       16578 :             update = true;
    1490          68 :         else if (TransactionIdPrecedes(ReadNextTransactionId(), oldfrozenxid))
    1491           0 :             futurexid = update = true;
    1492             : 
    1493       16646 :         if (update)
    1494             :         {
    1495       16578 :             pgcform->relfrozenxid = frozenxid;
    1496       16578 :             dirty = true;
    1497       16578 :             if (frozenxid_updated)
    1498       16578 :                 *frozenxid_updated = true;
    1499             :         }
    1500             :     }
    1501             : 
    1502             :     /* Similarly for relminmxid */
    1503       49952 :     oldminmulti = pgcform->relminmxid;
    1504       49952 :     futuremxid = false;
    1505       49952 :     if (minmulti_updated)
    1506       19078 :         *minmulti_updated = false;
    1507       49952 :     if (MultiXactIdIsValid(minmulti) && oldminmulti != minmulti)
    1508             :     {
    1509          26 :         bool        update = false;
    1510             : 
    1511          26 :         if (MultiXactIdPrecedes(oldminmulti, minmulti))
    1512          26 :             update = true;
    1513           0 :         else if (MultiXactIdPrecedes(ReadNextMultiXactId(), oldminmulti))
    1514           0 :             futuremxid = update = true;
    1515             : 
    1516          26 :         if (update)
    1517             :         {
    1518          26 :             pgcform->relminmxid = minmulti;
    1519          26 :             dirty = true;
    1520          26 :             if (minmulti_updated)
    1521          26 :                 *minmulti_updated = true;
    1522             :         }
    1523             :     }
    1524             : 
    1525             :     /* If anything changed, write out the tuple. */
    1526       49952 :     if (dirty)
    1527       27594 :         heap_inplace_update(rd, ctup);
    1528             : 
    1529       49952 :     table_close(rd, RowExclusiveLock);
    1530             : 
    1531       49952 :     if (futurexid)
    1532           0 :         ereport(WARNING,
    1533             :                 (errcode(ERRCODE_DATA_CORRUPTED),
    1534             :                  errmsg_internal("overwrote invalid relfrozenxid value %u with new value %u for table \"%s\"",
    1535             :                                  oldfrozenxid, frozenxid,
    1536             :                                  RelationGetRelationName(relation))));
    1537       49952 :     if (futuremxid)
    1538           0 :         ereport(WARNING,
    1539             :                 (errcode(ERRCODE_DATA_CORRUPTED),
    1540             :                  errmsg_internal("overwrote invalid relminmxid value %u with new value %u for table \"%s\"",
    1541             :                                  oldminmulti, minmulti,
    1542             :                                  RelationGetRelationName(relation))));
    1543       49952 : }
    1544             : 
    1545             : 
    1546             : /*
    1547             :  *  vac_update_datfrozenxid() -- update pg_database.datfrozenxid for our DB
    1548             :  *
    1549             :  *      Update pg_database's datfrozenxid entry for our database to be the
    1550             :  *      minimum of the pg_class.relfrozenxid values.
    1551             :  *
    1552             :  *      Similarly, update our datminmxid to be the minimum of the
    1553             :  *      pg_class.relminmxid values.
    1554             :  *
    1555             :  *      If we are able to advance either pg_database value, also try to
    1556             :  *      truncate pg_xact and pg_multixact.
    1557             :  *
    1558             :  *      We violate transaction semantics here by overwriting the database's
    1559             :  *      existing pg_database tuple with the new values.  This is reasonably
    1560             :  *      safe since the new values are correct whether or not this transaction
    1561             :  *      commits.  As with vac_update_relstats, this avoids leaving dead tuples
    1562             :  *      behind after a VACUUM.
    1563             :  */
    1564             : void
    1565        1514 : vac_update_datfrozenxid(void)
    1566             : {
    1567             :     HeapTuple   tuple;
    1568             :     Form_pg_database dbform;
    1569             :     Relation    relation;
    1570             :     SysScanDesc scan;
    1571             :     HeapTuple   classTup;
    1572             :     TransactionId newFrozenXid;
    1573             :     MultiXactId newMinMulti;
    1574             :     TransactionId lastSaneFrozenXid;
    1575             :     MultiXactId lastSaneMinMulti;
    1576        1514 :     bool        bogus = false;
    1577        1514 :     bool        dirty = false;
    1578             :     ScanKeyData key[1];
    1579             : 
    1580             :     /*
    1581             :      * Restrict this task to one backend per database.  This avoids race
    1582             :      * conditions that would move datfrozenxid or datminmxid backward.  It
    1583             :      * avoids calling vac_truncate_clog() with a datfrozenxid preceding a
    1584             :      * datfrozenxid passed to an earlier vac_truncate_clog() call.
    1585             :      */
    1586        1514 :     LockDatabaseFrozenIds(ExclusiveLock);
    1587             : 
    1588             :     /*
    1589             :      * Initialize the "min" calculation with
    1590             :      * GetOldestNonRemovableTransactionId(), which is a reasonable
    1591             :      * approximation to the minimum relfrozenxid for not-yet-committed
    1592             :      * pg_class entries for new tables; see AddNewRelationTuple().  So we
    1593             :      * cannot produce a wrong minimum by starting with this.
    1594             :      */
    1595        1514 :     newFrozenXid = GetOldestNonRemovableTransactionId(NULL);
    1596             : 
    1597             :     /*
    1598             :      * Similarly, initialize the MultiXact "min" with the value that would be
    1599             :      * used on pg_class for new tables.  See AddNewRelationTuple().
    1600             :      */
    1601        1514 :     newMinMulti = GetOldestMultiXactId();
    1602             : 
    1603             :     /*
    1604             :      * Identify the latest relfrozenxid and relminmxid values that we could
    1605             :      * validly see during the scan.  These are conservative values, but it's
    1606             :      * not really worth trying to be more exact.
    1607             :      */
    1608        1514 :     lastSaneFrozenXid = ReadNextTransactionId();
    1609        1514 :     lastSaneMinMulti = ReadNextMultiXactId();
    1610             : 
    1611             :     /*
    1612             :      * We must seqscan pg_class to find the minimum Xid, because there is no
    1613             :      * index that can help us here.
    1614             :      */
    1615        1514 :     relation = table_open(RelationRelationId, AccessShareLock);
    1616             : 
    1617        1514 :     scan = systable_beginscan(relation, InvalidOid, false,
    1618             :                               NULL, 0, NULL);
    1619             : 
    1620      993900 :     while ((classTup = systable_getnext(scan)) != NULL)
    1621             :     {
    1622      992386 :         Form_pg_class classForm = (Form_pg_class) GETSTRUCT(classTup);
    1623             : 
    1624             :         /*
    1625             :          * Only consider relations able to hold unfrozen XIDs (anything else
    1626             :          * should have InvalidTransactionId in relfrozenxid anyway).
    1627             :          */
    1628      992386 :         if (classForm->relkind != RELKIND_RELATION &&
    1629      744202 :             classForm->relkind != RELKIND_MATVIEW &&
    1630      742178 :             classForm->relkind != RELKIND_TOASTVALUE)
    1631             :         {
    1632             :             Assert(!TransactionIdIsValid(classForm->relfrozenxid));
    1633             :             Assert(!MultiXactIdIsValid(classForm->relminmxid));
    1634      621468 :             continue;
    1635             :         }
    1636             : 
    1637             :         /*
    1638             :          * Some table AMs might not need per-relation xid / multixid horizons.
    1639             :          * It therefore seems reasonable to allow relfrozenxid and relminmxid
    1640             :          * to not be set (i.e. set to their respective Invalid*Id)
    1641             :          * independently. Thus validate and compute horizon for each only if
    1642             :          * set.
    1643             :          *
    1644             :          * If things are working properly, no relation should have a
    1645             :          * relfrozenxid or relminmxid that is "in the future".  However, such
    1646             :          * cases have been known to arise due to bugs in pg_upgrade.  If we
    1647             :          * see any entries that are "in the future", chicken out and don't do
    1648             :          * anything.  This ensures we won't truncate clog & multixact SLRUs
    1649             :          * before those relations have been scanned and cleaned up.
    1650             :          */
    1651             : 
    1652      370918 :         if (TransactionIdIsValid(classForm->relfrozenxid))
    1653             :         {
    1654             :             Assert(TransactionIdIsNormal(classForm->relfrozenxid));
    1655             : 
    1656             :             /* check for values in the future */
    1657      370918 :             if (TransactionIdPrecedes(lastSaneFrozenXid, classForm->relfrozenxid))
    1658             :             {
    1659           0 :                 bogus = true;
    1660           0 :                 break;
    1661             :             }
    1662             : 
    1663             :             /* determine new horizon */
    1664      370918 :             if (TransactionIdPrecedes(classForm->relfrozenxid, newFrozenXid))
    1665        2844 :                 newFrozenXid = classForm->relfrozenxid;
    1666             :         }
    1667             : 
    1668      370918 :         if (MultiXactIdIsValid(classForm->relminmxid))
    1669             :         {
    1670             :             /* check for values in the future */
    1671      370918 :             if (MultiXactIdPrecedes(lastSaneMinMulti, classForm->relminmxid))
    1672             :             {
    1673           0 :                 bogus = true;
    1674           0 :                 break;
    1675             :             }
    1676             : 
    1677             :             /* determine new horizon */
    1678      370918 :             if (MultiXactIdPrecedes(classForm->relminmxid, newMinMulti))
    1679         192 :                 newMinMulti = classForm->relminmxid;
    1680             :         }
    1681             :     }
    1682             : 
    1683             :     /* we're done with pg_class */
    1684        1514 :     systable_endscan(scan);
    1685        1514 :     table_close(relation, AccessShareLock);
    1686             : 
    1687             :     /* chicken out if bogus data found */
    1688        1514 :     if (bogus)
    1689           0 :         return;
    1690             : 
    1691             :     Assert(TransactionIdIsNormal(newFrozenXid));
    1692             :     Assert(MultiXactIdIsValid(newMinMulti));
    1693             : 
    1694             :     /* Now fetch the pg_database tuple we need to update. */
    1695        1514 :     relation = table_open(DatabaseRelationId, RowExclusiveLock);
    1696             : 
    1697             :     /*
    1698             :      * Get the pg_database tuple to scribble on.  Note that this does not
    1699             :      * directly rely on the syscache to avoid issues with flattened toast
    1700             :      * values for the in-place update.
    1701             :      */
    1702        1514 :     ScanKeyInit(&key[0],
    1703             :                 Anum_pg_database_oid,
    1704             :                 BTEqualStrategyNumber, F_OIDEQ,
    1705             :                 ObjectIdGetDatum(MyDatabaseId));
    1706             : 
    1707        1514 :     scan = systable_beginscan(relation, DatabaseOidIndexId, true,
    1708             :                               NULL, 1, key);
    1709        1514 :     tuple = systable_getnext(scan);
    1710        1514 :     tuple = heap_copytuple(tuple);
    1711        1514 :     systable_endscan(scan);
    1712             : 
    1713        1514 :     if (!HeapTupleIsValid(tuple))
    1714           0 :         elog(ERROR, "could not find tuple for database %u", MyDatabaseId);
    1715             : 
    1716        1514 :     dbform = (Form_pg_database) GETSTRUCT(tuple);
    1717             : 
    1718             :     /*
    1719             :      * As in vac_update_relstats(), we ordinarily don't want to let
    1720             :      * datfrozenxid go backward; but if it's "in the future" then it must be
    1721             :      * corrupt and it seems best to overwrite it.
    1722             :      */
    1723        1646 :     if (dbform->datfrozenxid != newFrozenXid &&
    1724         132 :         (TransactionIdPrecedes(dbform->datfrozenxid, newFrozenXid) ||
    1725           0 :          TransactionIdPrecedes(lastSaneFrozenXid, dbform->datfrozenxid)))
    1726             :     {
    1727         132 :         dbform->datfrozenxid = newFrozenXid;
    1728         132 :         dirty = true;
    1729             :     }
    1730             :     else
    1731        1382 :         newFrozenXid = dbform->datfrozenxid;
    1732             : 
    1733             :     /* Ditto for datminmxid */
    1734        1514 :     if (dbform->datminmxid != newMinMulti &&
    1735           0 :         (MultiXactIdPrecedes(dbform->datminmxid, newMinMulti) ||
    1736           0 :          MultiXactIdPrecedes(lastSaneMinMulti, dbform->datminmxid)))
    1737             :     {
    1738           0 :         dbform->datminmxid = newMinMulti;
    1739           0 :         dirty = true;
    1740             :     }
    1741             :     else
    1742        1514 :         newMinMulti = dbform->datminmxid;
    1743             : 
    1744        1514 :     if (dirty)
    1745         132 :         heap_inplace_update(relation, tuple);
    1746             : 
    1747        1514 :     heap_freetuple(tuple);
    1748        1514 :     table_close(relation, RowExclusiveLock);
    1749             : 
    1750             :     /*
    1751             :      * If we were able to advance datfrozenxid or datminmxid, see if we can
    1752             :      * truncate pg_xact and/or pg_multixact.  Also do it if the shared
    1753             :      * XID-wrap-limit info is stale, since this action will update that too.
    1754             :      */
    1755        1514 :     if (dirty || ForceTransactionIdLimitUpdate())
    1756         132 :         vac_truncate_clog(newFrozenXid, newMinMulti,
    1757             :                           lastSaneFrozenXid, lastSaneMinMulti);
    1758             : }
    1759             : 
    1760             : 
    1761             : /*
    1762             :  *  vac_truncate_clog() -- attempt to truncate the commit log
    1763             :  *
    1764             :  *      Scan pg_database to determine the system-wide oldest datfrozenxid,
    1765             :  *      and use it to truncate the transaction commit log (pg_xact).
    1766             :  *      Also update the XID wrap limit info maintained by varsup.c.
    1767             :  *      Likewise for datminmxid.
    1768             :  *
    1769             :  *      The passed frozenXID and minMulti are the updated values for my own
    1770             :  *      pg_database entry. They're used to initialize the "min" calculations.
    1771             :  *      The caller also passes the "last sane" XID and MXID, since it has
    1772             :  *      those at hand already.
    1773             :  *
    1774             :  *      This routine is only invoked when we've managed to change our
    1775             :  *      DB's datfrozenxid/datminmxid values, or we found that the shared
    1776             :  *      XID-wrap-limit info is stale.
    1777             :  */
    1778             : static void
    1779         132 : vac_truncate_clog(TransactionId frozenXID,
    1780             :                   MultiXactId minMulti,
    1781             :                   TransactionId lastSaneFrozenXid,
    1782             :                   MultiXactId lastSaneMinMulti)
    1783             : {
    1784         132 :     TransactionId nextXID = ReadNextTransactionId();
    1785             :     Relation    relation;
    1786             :     TableScanDesc scan;
    1787             :     HeapTuple   tuple;
    1788             :     Oid         oldestxid_datoid;
    1789             :     Oid         minmulti_datoid;
    1790         132 :     bool        bogus = false;
    1791         132 :     bool        frozenAlreadyWrapped = false;
    1792             : 
    1793             :     /* Restrict task to one backend per cluster; see SimpleLruTruncate(). */
    1794         132 :     LWLockAcquire(WrapLimitsVacuumLock, LW_EXCLUSIVE);
    1795             : 
    1796             :     /* init oldest datoids to sync with my frozenXID/minMulti values */
    1797         132 :     oldestxid_datoid = MyDatabaseId;
    1798         132 :     minmulti_datoid = MyDatabaseId;
    1799             : 
    1800             :     /*
    1801             :      * Scan pg_database to compute the minimum datfrozenxid/datminmxid
    1802             :      *
    1803             :      * Since vac_update_datfrozenxid updates datfrozenxid/datminmxid in-place,
    1804             :      * the values could change while we look at them.  Fetch each one just
    1805             :      * once to ensure sane behavior of the comparison logic.  (Here, as in
    1806             :      * many other places, we assume that fetching or updating an XID in shared
    1807             :      * storage is atomic.)
    1808             :      *
    1809             :      * Note: we need not worry about a race condition with new entries being
    1810             :      * inserted by CREATE DATABASE.  Any such entry will have a copy of some
    1811             :      * existing DB's datfrozenxid, and that source DB cannot be ours because
    1812             :      * of the interlock against copying a DB containing an active backend.
    1813             :      * Hence the new entry will not reduce the minimum.  Also, if two VACUUMs
    1814             :      * concurrently modify the datfrozenxid's of different databases, the
    1815             :      * worst possible outcome is that pg_xact is not truncated as aggressively
    1816             :      * as it could be.
    1817             :      */
    1818         132 :     relation = table_open(DatabaseRelationId, AccessShareLock);
    1819             : 
    1820         132 :     scan = table_beginscan_catalog(relation, 0, NULL);
    1821             : 
    1822         390 :     while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    1823             :     {
    1824         258 :         volatile FormData_pg_database *dbform = (Form_pg_database) GETSTRUCT(tuple);
    1825         258 :         TransactionId datfrozenxid = dbform->datfrozenxid;
    1826         258 :         TransactionId datminmxid = dbform->datminmxid;
    1827             : 
    1828             :         Assert(TransactionIdIsNormal(datfrozenxid));
    1829             :         Assert(MultiXactIdIsValid(datminmxid));
    1830             : 
    1831             :         /*
    1832             :          * If database is in the process of getting dropped, or has been
    1833             :          * interrupted while doing so, no connections to it are possible
    1834             :          * anymore. Therefore we don't need to take it into account here.
    1835             :          * Which is good, because it can't be processed by autovacuum either.
    1836             :          */
    1837         258 :         if (database_is_invalid_form((Form_pg_database) dbform))
    1838             :         {
    1839           2 :             elog(DEBUG2,
    1840             :                  "skipping invalid database \"%s\" while computing relfrozenxid",
    1841             :                  NameStr(dbform->datname));
    1842           2 :             continue;
    1843             :         }
    1844             : 
    1845             :         /*
    1846             :          * If things are working properly, no database should have a
    1847             :          * datfrozenxid or datminmxid that is "in the future".  However, such
    1848             :          * cases have been known to arise due to bugs in pg_upgrade.  If we
    1849             :          * see any entries that are "in the future", chicken out and don't do
    1850             :          * anything.  This ensures we won't truncate clog before those
    1851             :          * databases have been scanned and cleaned up.  (We will issue the
    1852             :          * "already wrapped" warning if appropriate, though.)
    1853             :          */
    1854         512 :         if (TransactionIdPrecedes(lastSaneFrozenXid, datfrozenxid) ||
    1855         256 :             MultiXactIdPrecedes(lastSaneMinMulti, datminmxid))
    1856           0 :             bogus = true;
    1857             : 
    1858         256 :         if (TransactionIdPrecedes(nextXID, datfrozenxid))
    1859           0 :             frozenAlreadyWrapped = true;
    1860         256 :         else if (TransactionIdPrecedes(datfrozenxid, frozenXID))
    1861             :         {
    1862          58 :             frozenXID = datfrozenxid;
    1863          58 :             oldestxid_datoid = dbform->oid;
    1864             :         }
    1865             : 
    1866         256 :         if (MultiXactIdPrecedes(datminmxid, minMulti))
    1867             :         {
    1868           0 :             minMulti = datminmxid;
    1869           0 :             minmulti_datoid = dbform->oid;
    1870             :         }
    1871             :     }
    1872             : 
    1873         132 :     table_endscan(scan);
    1874             : 
    1875         132 :     table_close(relation, AccessShareLock);
    1876             : 
    1877             :     /*
    1878             :      * Do not truncate CLOG if we seem to have suffered wraparound already;
    1879             :      * the computed minimum XID might be bogus.  This case should now be
    1880             :      * impossible due to the defenses in GetNewTransactionId, but we keep the
    1881             :      * test anyway.
    1882             :      */
    1883         132 :     if (frozenAlreadyWrapped)
    1884             :     {
    1885           0 :         ereport(WARNING,
    1886             :                 (errmsg("some databases have not been vacuumed in over 2 billion transactions"),
    1887             :                  errdetail("You might have already suffered transaction-wraparound data loss.")));
    1888           0 :         LWLockRelease(WrapLimitsVacuumLock);
    1889           0 :         return;
    1890             :     }
    1891             : 
    1892             :     /* chicken out if data is bogus in any other way */
    1893         132 :     if (bogus)
    1894             :     {
    1895           0 :         LWLockRelease(WrapLimitsVacuumLock);
    1896           0 :         return;
    1897             :     }
    1898             : 
    1899             :     /*
    1900             :      * Advance the oldest value for commit timestamps before truncating, so
    1901             :      * that if a user requests a timestamp for a transaction we're truncating
    1902             :      * away right after this point, they get NULL instead of an ugly "file not
    1903             :      * found" error from slru.c.  This doesn't matter for xact/multixact
    1904             :      * because they are not subject to arbitrary lookups from users.
    1905             :      */
    1906         132 :     AdvanceOldestCommitTsXid(frozenXID);
    1907             : 
    1908             :     /*
    1909             :      * Truncate CLOG, multixact and CommitTs to the oldest computed value.
    1910             :      */
    1911         132 :     TruncateCLOG(frozenXID, oldestxid_datoid);
    1912         132 :     TruncateCommitTs(frozenXID);
    1913         132 :     TruncateMultiXact(minMulti, minmulti_datoid);
    1914             : 
    1915             :     /*
    1916             :      * Update the wrap limit for GetNewTransactionId and creation of new
    1917             :      * MultiXactIds.  Note: these functions will also signal the postmaster
    1918             :      * for an(other) autovac cycle if needed.   XXX should we avoid possibly
    1919             :      * signaling twice?
    1920             :      */
    1921         132 :     SetTransactionIdLimit(frozenXID, oldestxid_datoid);
    1922         132 :     SetMultiXactIdLimit(minMulti, minmulti_datoid, false);
    1923             : 
    1924         132 :     LWLockRelease(WrapLimitsVacuumLock);
    1925             : }
    1926             : 
    1927             : 
    1928             : /*
    1929             :  *  vacuum_rel() -- vacuum one heap relation
    1930             :  *
    1931             :  *      relid identifies the relation to vacuum.  If relation is supplied,
    1932             :  *      use the name therein for reporting any failure to open/lock the rel;
    1933             :  *      do not use it once we've successfully opened the rel, since it might
    1934             :  *      be stale.
    1935             :  *
    1936             :  *      Returns true if it's okay to proceed with a requested ANALYZE
    1937             :  *      operation on this table.
    1938             :  *
    1939             :  *      Doing one heap at a time incurs extra overhead, since we need to
    1940             :  *      check that the heap exists again just before we vacuum it.  The
    1941             :  *      reason that we do this is so that vacuuming can be spread across
    1942             :  *      many small transactions.  Otherwise, two-phase locking would require
    1943             :  *      us to lock the entire database during one pass of the vacuum cleaner.
    1944             :  *
    1945             :  *      At entry and exit, we are not inside a transaction.
    1946             :  */
    1947             : static bool
    1948       19818 : vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params,
    1949             :            BufferAccessStrategy bstrategy)
    1950             : {
    1951             :     LOCKMODE    lmode;
    1952             :     Relation    rel;
    1953             :     LockRelId   lockrelid;
    1954             :     Oid         priv_relid;
    1955             :     Oid         toast_relid;
    1956             :     Oid         save_userid;
    1957             :     int         save_sec_context;
    1958             :     int         save_nestlevel;
    1959             : 
    1960             :     Assert(params != NULL);
    1961             : 
    1962             :     /* Begin a transaction for vacuuming this relation */
    1963       19818 :     StartTransactionCommand();
    1964             : 
    1965       19818 :     if (!(params->options & VACOPT_FULL))
    1966             :     {
    1967             :         /*
    1968             :          * In lazy vacuum, we can set the PROC_IN_VACUUM flag, which lets
    1969             :          * other concurrent VACUUMs know that they can ignore this one while
    1970             :          * determining their OldestXmin.  (The reason we don't set it during a
    1971             :          * full VACUUM is exactly that we may have to run user-defined
    1972             :          * functions for functional indexes, and we want to make sure that if
    1973             :          * they use the snapshot set above, any tuples it requires can't get
    1974             :          * removed from other tables.  An index function that depends on the
    1975             :          * contents of other tables is arguably broken, but we won't break it
    1976             :          * here by violating transaction semantics.)
    1977             :          *
    1978             :          * We also set the VACUUM_FOR_WRAPAROUND flag, which is passed down by
    1979             :          * autovacuum; it's used to avoid canceling a vacuum that was invoked
    1980             :          * in an emergency.
    1981             :          *
    1982             :          * Note: these flags remain set until CommitTransaction or
    1983             :          * AbortTransaction.  We don't want to clear them until we reset
    1984             :          * MyProc->xid/xmin, otherwise GetOldestNonRemovableTransactionId()
    1985             :          * might appear to go backwards, which is probably Not Good.  (We also
    1986             :          * set PROC_IN_VACUUM *before* taking our own snapshot, so that our
    1987             :          * xmin doesn't become visible ahead of setting the flag.)
    1988             :          */
    1989       19446 :         LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
    1990       19446 :         MyProc->statusFlags |= PROC_IN_VACUUM;
    1991       19446 :         if (params->is_wraparound)
    1992           0 :             MyProc->statusFlags |= PROC_VACUUM_FOR_WRAPAROUND;
    1993       19446 :         ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
    1994       19446 :         LWLockRelease(ProcArrayLock);
    1995             :     }
    1996             : 
    1997             :     /*
    1998             :      * Need to acquire a snapshot to prevent pg_subtrans from being truncated,
    1999             :      * cutoff xids in local memory wrapping around, and to have updated xmin
    2000             :      * horizons.
    2001             :      */
    2002       19818 :     PushActiveSnapshot(GetTransactionSnapshot());
    2003             : 
    2004             :     /*
    2005             :      * Check for user-requested abort.  Note we want this to be inside a
    2006             :      * transaction, so xact.c doesn't issue useless WARNING.
    2007             :      */
    2008       19818 :     CHECK_FOR_INTERRUPTS();
    2009             : 
    2010             :     /*
    2011             :      * Determine the type of lock we want --- hard exclusive lock for a FULL
    2012             :      * vacuum, but just ShareUpdateExclusiveLock for concurrent vacuum. Either
    2013             :      * way, we can be sure that no other backend is vacuuming the same table.
    2014             :      */
    2015       39636 :     lmode = (params->options & VACOPT_FULL) ?
    2016       19818 :         AccessExclusiveLock : ShareUpdateExclusiveLock;
    2017             : 
    2018             :     /* open the relation and get the appropriate lock on it */
    2019       19818 :     rel = vacuum_open_relation(relid, relation, params->options,
    2020       19818 :                                params->log_min_duration >= 0, lmode);
    2021             : 
    2022             :     /* leave if relation could not be opened or locked */
    2023       19818 :     if (!rel)
    2024             :     {
    2025          24 :         PopActiveSnapshot();
    2026          24 :         CommitTransactionCommand();
    2027          24 :         return false;
    2028             :     }
    2029             : 
    2030             :     /*
    2031             :      * When recursing to a TOAST table, check privileges on the parent.  NB:
    2032             :      * This is only safe to do because we hold a session lock on the main
    2033             :      * relation that prevents concurrent deletion.
    2034             :      */
    2035       19794 :     if (OidIsValid(params->toast_parent))
    2036        6818 :         priv_relid = params->toast_parent;
    2037             :     else
    2038       12976 :         priv_relid = RelationGetRelid(rel);
    2039             : 
    2040             :     /*
    2041             :      * Check if relation needs to be skipped based on privileges.  This check
    2042             :      * happens also when building the relation list to vacuum for a manual
    2043             :      * operation, and needs to be done additionally here as VACUUM could
    2044             :      * happen across multiple transactions where privileges could have changed
    2045             :      * in-between.  Make sure to only generate logs for VACUUM in this case.
    2046             :      */
    2047       19794 :     if (!vacuum_is_permitted_for_relation(priv_relid,
    2048             :                                           rel->rd_rel,
    2049       19794 :                                           params->options & ~VACOPT_ANALYZE))
    2050             :     {
    2051          72 :         relation_close(rel, lmode);
    2052          72 :         PopActiveSnapshot();
    2053          72 :         CommitTransactionCommand();
    2054          72 :         return false;
    2055             :     }
    2056             : 
    2057             :     /*
    2058             :      * Check that it's of a vacuumable relkind.
    2059             :      */
    2060       19722 :     if (rel->rd_rel->relkind != RELKIND_RELATION &&
    2061        6978 :         rel->rd_rel->relkind != RELKIND_MATVIEW &&
    2062        6970 :         rel->rd_rel->relkind != RELKIND_TOASTVALUE &&
    2063         152 :         rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
    2064             :     {
    2065           2 :         ereport(WARNING,
    2066             :                 (errmsg("skipping \"%s\" --- cannot vacuum non-tables or special system tables",
    2067             :                         RelationGetRelationName(rel))));
    2068           2 :         relation_close(rel, lmode);
    2069           2 :         PopActiveSnapshot();
    2070           2 :         CommitTransactionCommand();
    2071           2 :         return false;
    2072             :     }
    2073             : 
    2074             :     /*
    2075             :      * Silently ignore tables that are temp tables of other backends ---
    2076             :      * trying to vacuum these will lead to great unhappiness, since their
    2077             :      * contents are probably not up-to-date on disk.  (We don't throw a
    2078             :      * warning here; it would just lead to chatter during a database-wide
    2079             :      * VACUUM.)
    2080             :      */
    2081       19720 :     if (RELATION_IS_OTHER_TEMP(rel))
    2082             :     {
    2083           0 :         relation_close(rel, lmode);
    2084           0 :         PopActiveSnapshot();
    2085           0 :         CommitTransactionCommand();
    2086           0 :         return false;
    2087             :     }
    2088             : 
    2089             :     /*
    2090             :      * Silently ignore partitioned tables as there is no work to be done.  The
    2091             :      * useful work is on their child partitions, which have been queued up for
    2092             :      * us separately.
    2093             :      */
    2094       19720 :     if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    2095             :     {
    2096         150 :         relation_close(rel, lmode);
    2097         150 :         PopActiveSnapshot();
    2098         150 :         CommitTransactionCommand();
    2099             :         /* It's OK to proceed with ANALYZE on this table */
    2100         150 :         return true;
    2101             :     }
    2102             : 
    2103             :     /*
    2104             :      * Get a session-level lock too. This will protect our access to the
    2105             :      * relation across multiple transactions, so that we can vacuum the
    2106             :      * relation's TOAST table (if any) secure in the knowledge that no one is
    2107             :      * deleting the parent relation.
    2108             :      *
    2109             :      * NOTE: this cannot block, even if someone else is waiting for access,
    2110             :      * because the lock manager knows that both lock requests are from the
    2111             :      * same process.
    2112             :      */
    2113       19570 :     lockrelid = rel->rd_lockInfo.lockRelId;
    2114       19570 :     LockRelationIdForSession(&lockrelid, lmode);
    2115             : 
    2116             :     /*
    2117             :      * Set index_cleanup option based on index_cleanup reloption if it wasn't
    2118             :      * specified in VACUUM command, or when running in an autovacuum worker
    2119             :      */
    2120       19570 :     if (params->index_cleanup == VACOPTVALUE_UNSPECIFIED)
    2121             :     {
    2122             :         StdRdOptIndexCleanup vacuum_index_cleanup;
    2123             : 
    2124        5502 :         if (rel->rd_options == NULL)
    2125        5246 :             vacuum_index_cleanup = STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO;
    2126             :         else
    2127         256 :             vacuum_index_cleanup =
    2128         256 :                 ((StdRdOptions *) rel->rd_options)->vacuum_index_cleanup;
    2129             : 
    2130        5502 :         if (vacuum_index_cleanup == STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO)
    2131        5478 :             params->index_cleanup = VACOPTVALUE_AUTO;
    2132          24 :         else if (vacuum_index_cleanup == STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON)
    2133          12 :             params->index_cleanup = VACOPTVALUE_ENABLED;
    2134             :         else
    2135             :         {
    2136             :             Assert(vacuum_index_cleanup ==
    2137             :                    STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF);
    2138          12 :             params->index_cleanup = VACOPTVALUE_DISABLED;
    2139             :         }
    2140             :     }
    2141             : 
    2142             :     /*
    2143             :      * Set truncate option based on truncate reloption if it wasn't specified
    2144             :      * in VACUUM command, or when running in an autovacuum worker
    2145             :      */
    2146       19570 :     if (params->truncate == VACOPTVALUE_UNSPECIFIED)
    2147             :     {
    2148        5528 :         if (rel->rd_options == NULL ||
    2149         256 :             ((StdRdOptions *) rel->rd_options)->vacuum_truncate)
    2150        5522 :             params->truncate = VACOPTVALUE_ENABLED;
    2151             :         else
    2152           6 :             params->truncate = VACOPTVALUE_DISABLED;
    2153             :     }
    2154             : 
    2155             :     /*
    2156             :      * Remember the relation's TOAST relation for later, if the caller asked
    2157             :      * us to process it.  In VACUUM FULL, though, the toast table is
    2158             :      * automatically rebuilt by cluster_rel so we shouldn't recurse to it,
    2159             :      * unless PROCESS_MAIN is disabled.
    2160             :      */
    2161       19570 :     if ((params->options & VACOPT_PROCESS_TOAST) != 0 &&
    2162       19396 :         ((params->options & VACOPT_FULL) == 0 ||
    2163         344 :          (params->options & VACOPT_PROCESS_MAIN) == 0))
    2164       19058 :         toast_relid = rel->rd_rel->reltoastrelid;
    2165             :     else
    2166         512 :         toast_relid = InvalidOid;
    2167             : 
    2168             :     /*
    2169             :      * Switch to the table owner's userid, so that any index functions are run
    2170             :      * as that user.  Also lock down security-restricted operations and
    2171             :      * arrange to make GUC variable changes local to this command. (This is
    2172             :      * unnecessary, but harmless, for lazy VACUUM.)
    2173             :      */
    2174       19570 :     GetUserIdAndSecContext(&save_userid, &save_sec_context);
    2175       19570 :     SetUserIdAndSecContext(rel->rd_rel->relowner,
    2176             :                            save_sec_context | SECURITY_RESTRICTED_OPERATION);
    2177       19570 :     save_nestlevel = NewGUCNestLevel();
    2178       19570 :     RestrictSearchPath();
    2179             : 
    2180             :     /*
    2181             :      * If PROCESS_MAIN is set (the default), it's time to vacuum the main
    2182             :      * relation.  Otherwise, we can skip this part.  If processing the TOAST
    2183             :      * table is required (e.g., PROCESS_TOAST is set), we force PROCESS_MAIN
    2184             :      * to be set when we recurse to the TOAST table.
    2185             :      */
    2186       19570 :     if (params->options & VACOPT_PROCESS_MAIN)
    2187             :     {
    2188             :         /*
    2189             :          * Do the actual work --- either FULL or "lazy" vacuum
    2190             :          */
    2191       19416 :         if (params->options & VACOPT_FULL)
    2192             :         {
    2193         338 :             ClusterParams cluster_params = {0};
    2194             : 
    2195             :             /* close relation before vacuuming, but hold lock until commit */
    2196         338 :             relation_close(rel, NoLock);
    2197         338 :             rel = NULL;
    2198             : 
    2199         338 :             if ((params->options & VACOPT_VERBOSE) != 0)
    2200           2 :                 cluster_params.options |= CLUOPT_VERBOSE;
    2201             : 
    2202             :             /* VACUUM FULL is now a variant of CLUSTER; see cluster.c */
    2203         338 :             cluster_rel(relid, InvalidOid, &cluster_params);
    2204             :         }
    2205             :         else
    2206       19078 :             table_relation_vacuum(rel, params, bstrategy);
    2207             :     }
    2208             : 
    2209             :     /* Roll back any GUC changes executed by index functions */
    2210       19564 :     AtEOXact_GUC(false, save_nestlevel);
    2211             : 
    2212             :     /* Restore userid and security context */
    2213       19564 :     SetUserIdAndSecContext(save_userid, save_sec_context);
    2214             : 
    2215             :     /* all done with this class, but hold lock until commit */
    2216       19564 :     if (rel)
    2217       19232 :         relation_close(rel, NoLock);
    2218             : 
    2219             :     /*
    2220             :      * Complete the transaction and free all temporary memory used.
    2221             :      */
    2222       19564 :     PopActiveSnapshot();
    2223       19564 :     CommitTransactionCommand();
    2224             : 
    2225             :     /*
    2226             :      * If the relation has a secondary toast rel, vacuum that too while we
    2227             :      * still hold the session lock on the main table.  Note however that
    2228             :      * "analyze" will not get done on the toast table.  This is good, because
    2229             :      * the toaster always uses hardcoded index access and statistics are
    2230             :      * totally unimportant for toast relations.
    2231             :      */
    2232       19564 :     if (toast_relid != InvalidOid)
    2233             :     {
    2234             :         VacuumParams toast_vacuum_params;
    2235             : 
    2236             :         /*
    2237             :          * Force VACOPT_PROCESS_MAIN so vacuum_rel() processes it.  Likewise,
    2238             :          * set toast_parent so that the privilege checks are done on the main
    2239             :          * relation.  NB: This is only safe to do because we hold a session
    2240             :          * lock on the main relation that prevents concurrent deletion.
    2241             :          */
    2242        6818 :         memcpy(&toast_vacuum_params, params, sizeof(VacuumParams));
    2243        6818 :         toast_vacuum_params.options |= VACOPT_PROCESS_MAIN;
    2244        6818 :         toast_vacuum_params.toast_parent = relid;
    2245             : 
    2246        6818 :         vacuum_rel(toast_relid, NULL, &toast_vacuum_params, bstrategy);
    2247             :     }
    2248             : 
    2249             :     /*
    2250             :      * Now release the session-level lock on the main table.
    2251             :      */
    2252       19564 :     UnlockRelationIdForSession(&lockrelid, lmode);
    2253             : 
    2254             :     /* Report that we really did it. */
    2255       19564 :     return true;
    2256             : }
    2257             : 
    2258             : 
    2259             : /*
    2260             :  * Open all the vacuumable indexes of the given relation, obtaining the
    2261             :  * specified kind of lock on each.  Return an array of Relation pointers for
    2262             :  * the indexes into *Irel, and the number of indexes into *nindexes.
    2263             :  *
    2264             :  * We consider an index vacuumable if it is marked insertable (indisready).
    2265             :  * If it isn't, probably a CREATE INDEX CONCURRENTLY command failed early in
    2266             :  * execution, and what we have is too corrupt to be processable.  We will
    2267             :  * vacuum even if the index isn't indisvalid; this is important because in a
    2268             :  * unique index, uniqueness checks will be performed anyway and had better not
    2269             :  * hit dangling index pointers.
    2270             :  */
    2271             : void
    2272       30720 : vac_open_indexes(Relation relation, LOCKMODE lockmode,
    2273             :                  int *nindexes, Relation **Irel)
    2274             : {
    2275             :     List       *indexoidlist;
    2276             :     ListCell   *indexoidscan;
    2277             :     int         i;
    2278             : 
    2279             :     Assert(lockmode != NoLock);
    2280             : 
    2281       30720 :     indexoidlist = RelationGetIndexList(relation);
    2282             : 
    2283             :     /* allocate enough memory for all indexes */
    2284       30720 :     i = list_length(indexoidlist);
    2285             : 
    2286       30720 :     if (i > 0)
    2287       26410 :         *Irel = (Relation *) palloc(i * sizeof(Relation));
    2288             :     else
    2289        4310 :         *Irel = NULL;
    2290             : 
    2291             :     /* collect just the ready indexes */
    2292       30720 :     i = 0;
    2293       74674 :     foreach(indexoidscan, indexoidlist)
    2294             :     {
    2295       43954 :         Oid         indexoid = lfirst_oid(indexoidscan);
    2296             :         Relation    indrel;
    2297             : 
    2298       43954 :         indrel = index_open(indexoid, lockmode);
    2299       43954 :         if (indrel->rd_index->indisready)
    2300       43954 :             (*Irel)[i++] = indrel;
    2301             :         else
    2302           0 :             index_close(indrel, lockmode);
    2303             :     }
    2304             : 
    2305       30720 :     *nindexes = i;
    2306             : 
    2307       30720 :     list_free(indexoidlist);
    2308       30720 : }
    2309             : 
    2310             : /*
    2311             :  * Release the resources acquired by vac_open_indexes.  Optionally release
    2312             :  * the locks (say NoLock to keep 'em).
    2313             :  */
    2314             : void
    2315       31394 : vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode)
    2316             : {
    2317       31394 :     if (Irel == NULL)
    2318        4990 :         return;
    2319             : 
    2320       70346 :     while (nindexes--)
    2321             :     {
    2322       43942 :         Relation    ind = Irel[nindexes];
    2323             : 
    2324       43942 :         index_close(ind, lockmode);
    2325             :     }
    2326       26404 :     pfree(Irel);
    2327             : }
    2328             : 
    2329             : /*
    2330             :  * vacuum_delay_point --- check for interrupts and cost-based delay.
    2331             :  *
    2332             :  * This should be called in each major loop of VACUUM processing,
    2333             :  * typically once per page processed.
    2334             :  */
    2335             : void
    2336    60197390 : vacuum_delay_point(void)
    2337             : {
    2338    60197390 :     double      msec = 0;
    2339             : 
    2340             :     /* Always check for interrupts */
    2341    60197390 :     CHECK_FOR_INTERRUPTS();
    2342             : 
    2343    60197390 :     if (InterruptPending ||
    2344    60197390 :         (!VacuumCostActive && !ConfigReloadPending))
    2345    59135434 :         return;
    2346             : 
    2347             :     /*
    2348             :      * Autovacuum workers should reload the configuration file if requested.
    2349             :      * This allows changes to [autovacuum_]vacuum_cost_limit and
    2350             :      * [autovacuum_]vacuum_cost_delay to take effect while a table is being
    2351             :      * vacuumed or analyzed.
    2352             :      */
    2353     1061956 :     if (ConfigReloadPending && AmAutoVacuumWorkerProcess())
    2354             :     {
    2355           0 :         ConfigReloadPending = false;
    2356           0 :         ProcessConfigFile(PGC_SIGHUP);
    2357           0 :         VacuumUpdateCosts();
    2358             :     }
    2359             : 
    2360             :     /*
    2361             :      * If we disabled cost-based delays after reloading the config file,
    2362             :      * return.
    2363             :      */
    2364     1061956 :     if (!VacuumCostActive)
    2365           0 :         return;
    2366             : 
    2367             :     /*
    2368             :      * For parallel vacuum, the delay is computed based on the shared cost
    2369             :      * balance.  See compute_parallel_delay.
    2370             :      */
    2371     1061956 :     if (VacuumSharedCostBalance != NULL)
    2372           0 :         msec = compute_parallel_delay();
    2373     1061956 :     else if (VacuumCostBalance >= vacuum_cost_limit)
    2374          36 :         msec = vacuum_cost_delay * VacuumCostBalance / vacuum_cost_limit;
    2375             : 
    2376             :     /* Nap if appropriate */
    2377     1061956 :     if (msec > 0)
    2378             :     {
    2379          36 :         if (msec > vacuum_cost_delay * 4)
    2380           0 :             msec = vacuum_cost_delay * 4;
    2381             : 
    2382          36 :         pgstat_report_wait_start(WAIT_EVENT_VACUUM_DELAY);
    2383          36 :         pg_usleep(msec * 1000);
    2384          36 :         pgstat_report_wait_end();
    2385             : 
    2386             :         /*
    2387             :          * We don't want to ignore postmaster death during very long vacuums
    2388             :          * with vacuum_cost_delay configured.  We can't use the usual
    2389             :          * WaitLatch() approach here because we want microsecond-based sleep
    2390             :          * durations above.
    2391             :          */
    2392          36 :         if (IsUnderPostmaster && !PostmasterIsAlive())
    2393           0 :             exit(1);
    2394             : 
    2395          36 :         VacuumCostBalance = 0;
    2396             : 
    2397             :         /*
    2398             :          * Balance and update limit values for autovacuum workers. We must do
    2399             :          * this periodically, as the number of workers across which we are
    2400             :          * balancing the limit may have changed.
    2401             :          *
    2402             :          * TODO: There may be better criteria for determining when to do this
    2403             :          * besides "check after napping".
    2404             :          */
    2405          36 :         AutoVacuumUpdateCostLimit();
    2406             : 
    2407             :         /* Might have gotten an interrupt while sleeping */
    2408          36 :         CHECK_FOR_INTERRUPTS();
    2409             :     }
    2410             : }
    2411             : 
    2412             : /*
    2413             :  * Computes the vacuum delay for parallel workers.
    2414             :  *
    2415             :  * The basic idea of a cost-based delay for parallel vacuum is to allow each
    2416             :  * worker to sleep in proportion to the share of work it's done.  We achieve this
    2417             :  * by allowing all parallel vacuum workers including the leader process to
    2418             :  * have a shared view of cost related parameters (mainly VacuumCostBalance).
    2419             :  * We allow each worker to update it as and when it has incurred any cost and
    2420             :  * then based on that decide whether it needs to sleep.  We compute the time
    2421             :  * to sleep for a worker based on the cost it has incurred
    2422             :  * (VacuumCostBalanceLocal) and then reduce the VacuumSharedCostBalance by
    2423             :  * that amount.  This avoids putting to sleep those workers which have done less
    2424             :  * I/O than other workers and therefore ensure that workers
    2425             :  * which are doing more I/O got throttled more.
    2426             :  *
    2427             :  * We allow a worker to sleep only if it has performed I/O above a certain
    2428             :  * threshold, which is calculated based on the number of active workers
    2429             :  * (VacuumActiveNWorkers), and the overall cost balance is more than
    2430             :  * VacuumCostLimit set by the system.  Testing reveals that we achieve
    2431             :  * the required throttling if we force a worker that has done more than 50%
    2432             :  * of its share of work to sleep.
    2433             :  */
    2434             : static double
    2435           0 : compute_parallel_delay(void)
    2436             : {
    2437           0 :     double      msec = 0;
    2438             :     uint32      shared_balance;
    2439             :     int         nworkers;
    2440             : 
    2441             :     /* Parallel vacuum must be active */
    2442             :     Assert(VacuumSharedCostBalance);
    2443             : 
    2444           0 :     nworkers = pg_atomic_read_u32(VacuumActiveNWorkers);
    2445             : 
    2446             :     /* At least count itself */
    2447             :     Assert(nworkers >= 1);
    2448             : 
    2449             :     /* Update the shared cost balance value atomically */
    2450           0 :     shared_balance = pg_atomic_add_fetch_u32(VacuumSharedCostBalance, VacuumCostBalance);
    2451             : 
    2452             :     /* Compute the total local balance for the current worker */
    2453           0 :     VacuumCostBalanceLocal += VacuumCostBalance;
    2454             : 
    2455           0 :     if ((shared_balance >= vacuum_cost_limit) &&
    2456           0 :         (VacuumCostBalanceLocal > 0.5 * ((double) vacuum_cost_limit / nworkers)))
    2457             :     {
    2458             :         /* Compute sleep time based on the local cost balance */
    2459           0 :         msec = vacuum_cost_delay * VacuumCostBalanceLocal / vacuum_cost_limit;
    2460           0 :         pg_atomic_sub_fetch_u32(VacuumSharedCostBalance, VacuumCostBalanceLocal);
    2461           0 :         VacuumCostBalanceLocal = 0;
    2462             :     }
    2463             : 
    2464             :     /*
    2465             :      * Reset the local balance as we accumulated it into the shared value.
    2466             :      */
    2467           0 :     VacuumCostBalance = 0;
    2468             : 
    2469           0 :     return msec;
    2470             : }
    2471             : 
    2472             : /*
    2473             :  * A wrapper function of defGetBoolean().
    2474             :  *
    2475             :  * This function returns VACOPTVALUE_ENABLED and VACOPTVALUE_DISABLED instead
    2476             :  * of true and false.
    2477             :  */
    2478             : static VacOptValue
    2479         316 : get_vacoptval_from_boolean(DefElem *def)
    2480             : {
    2481         316 :     return defGetBoolean(def) ? VACOPTVALUE_ENABLED : VACOPTVALUE_DISABLED;
    2482             : }
    2483             : 
    2484             : /*
    2485             :  *  vac_bulkdel_one_index() -- bulk-deletion for index relation.
    2486             :  *
    2487             :  * Returns bulk delete stats derived from input stats
    2488             :  */
    2489             : IndexBulkDeleteResult *
    2490        1664 : vac_bulkdel_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat,
    2491             :                       TidStore *dead_items, VacDeadItemsInfo *dead_items_info)
    2492             : {
    2493             :     /* Do bulk deletion */
    2494        1664 :     istat = index_bulk_delete(ivinfo, istat, vac_tid_reaped,
    2495             :                               (void *) dead_items);
    2496             : 
    2497        1664 :     ereport(ivinfo->message_level,
    2498             :             (errmsg("scanned index \"%s\" to remove %lld row versions",
    2499             :                     RelationGetRelationName(ivinfo->index),
    2500             :                     (long long) dead_items_info->num_items)));
    2501             : 
    2502        1664 :     return istat;
    2503             : }
    2504             : 
    2505             : /*
    2506             :  *  vac_cleanup_one_index() -- do post-vacuum cleanup for index relation.
    2507             :  *
    2508             :  * Returns bulk delete stats derived from input stats
    2509             :  */
    2510             : IndexBulkDeleteResult *
    2511       26582 : vac_cleanup_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat)
    2512             : {
    2513       26582 :     istat = index_vacuum_cleanup(ivinfo, istat);
    2514             : 
    2515       26582 :     if (istat)
    2516        1900 :         ereport(ivinfo->message_level,
    2517             :                 (errmsg("index \"%s\" now contains %.0f row versions in %u pages",
    2518             :                         RelationGetRelationName(ivinfo->index),
    2519             :                         istat->num_index_tuples,
    2520             :                         istat->num_pages),
    2521             :                  errdetail("%.0f index row versions were removed.\n"
    2522             :                            "%u index pages were newly deleted.\n"
    2523             :                            "%u index pages are currently deleted, of which %u are currently reusable.",
    2524             :                            istat->tuples_removed,
    2525             :                            istat->pages_newly_deleted,
    2526             :                            istat->pages_deleted, istat->pages_free)));
    2527             : 
    2528       26582 :     return istat;
    2529             : }
    2530             : 
    2531             : /*
    2532             :  *  vac_tid_reaped() -- is a particular tid deletable?
    2533             :  *
    2534             :  *      This has the right signature to be an IndexBulkDeleteCallback.
    2535             :  */
    2536             : static bool
    2537     4449640 : vac_tid_reaped(ItemPointer itemptr, void *state)
    2538             : {
    2539     4449640 :     TidStore   *dead_items = (TidStore *) state;
    2540             : 
    2541     4449640 :     return TidStoreIsMember(dead_items, itemptr);
    2542             : }

Generated by: LCOV version 1.14