PostgreSQL Source Code  git master
vacuum.c
Go to the documentation of this file.
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"
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  */
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;
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  */
105 
106 /* non-export function prototypes */
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);
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
127 {
128  /* Value upper and lower hard limits are inclusive */
129  if (*newval == 0 || (*newval >= MIN_BAS_VAC_RING_SIZE_KB &&
131  return true;
132 
133  /* Value does not fall within any allowable range */
134  GUC_check_errdetail("\"vacuum_buffer_usage_limit\" must be 0 or between %d kB and %d kB",
136 
137  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 ExecVacuum(ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel)
148 {
149  VacuumParams params;
150  BufferAccessStrategy bstrategy = NULL;
151  bool verbose = false;
152  bool skip_locked = false;
153  bool analyze = false;
154  bool freeze = false;
155  bool full = false;
156  bool disable_page_skipping = false;
157  bool process_main = true;
158  bool process_toast = true;
159  int ring_size;
160  bool skip_database_stats = false;
161  bool only_database_stats = false;
162  MemoryContext vac_context;
163  ListCell *lc;
164 
165  /* index_cleanup and truncate values unspecified for now */
168 
169  /* By default parallel vacuum is enabled */
170  params.nworkers = 0;
171 
172  /* Will be set later if we recurse to a TOAST table. */
173  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  ring_size = -1;
180 
181  /* Parse options list */
182  foreach(lc, vacstmt->options)
183  {
184  DefElem *opt = (DefElem *) lfirst(lc);
185 
186  /* Parse common options for VACUUM and ANALYZE */
187  if (strcmp(opt->defname, "verbose") == 0)
188  verbose = defGetBoolean(opt);
189  else if (strcmp(opt->defname, "skip_locked") == 0)
190  skip_locked = defGetBoolean(opt);
191  else if (strcmp(opt->defname, "buffer_usage_limit") == 0)
192  {
193  const char *hintmsg;
194  int result;
195  char *vac_buffer_size;
196 
197  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  if (!parse_int(vac_buffer_size, &result, GUC_UNIT_KB, &hintmsg) ||
204  (result != 0 &&
205  (result < MIN_BAS_VAC_RING_SIZE_KB || result > MAX_BAS_VAC_RING_SIZE_KB)))
206  {
207  ereport(ERROR,
208  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
209  errmsg("BUFFER_USAGE_LIMIT option must be 0 or between %d kB and %d kB",
211  hintmsg ? errhint("%s", _(hintmsg)) : 0));
212  }
213 
214  ring_size = result;
215  }
216  else if (!vacstmt->is_vacuumcmd)
217  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  else if (strcmp(opt->defname, "analyze") == 0)
224  analyze = defGetBoolean(opt);
225  else if (strcmp(opt->defname, "freeze") == 0)
226  freeze = defGetBoolean(opt);
227  else if (strcmp(opt->defname, "full") == 0)
228  full = defGetBoolean(opt);
229  else if (strcmp(opt->defname, "disable_page_skipping") == 0)
230  disable_page_skipping = defGetBoolean(opt);
231  else if (strcmp(opt->defname, "index_cleanup") == 0)
232  {
233  /* Interpret no string as the default, which is 'auto' */
234  if (!opt->arg)
236  else
237  {
238  char *sval = defGetString(opt);
239 
240  /* Try matching on 'auto' string, or fall back on boolean */
241  if (pg_strcasecmp(sval, "auto") == 0)
243  else
245  }
246  }
247  else if (strcmp(opt->defname, "process_main") == 0)
248  process_main = defGetBoolean(opt);
249  else if (strcmp(opt->defname, "process_toast") == 0)
250  process_toast = defGetBoolean(opt);
251  else if (strcmp(opt->defname, "truncate") == 0)
252  params.truncate = get_vacoptval_from_boolean(opt);
253  else if (strcmp(opt->defname, "parallel") == 0)
254  {
255  if (opt->arg == NULL)
256  {
257  ereport(ERROR,
258  (errcode(ERRCODE_SYNTAX_ERROR),
259  errmsg("parallel option requires a value between 0 and %d",
261  parser_errposition(pstate, opt->location)));
262  }
263  else
264  {
265  int nworkers;
266 
267  nworkers = defGetInt32(opt);
268  if (nworkers < 0 || nworkers > MAX_PARALLEL_WORKER_LIMIT)
269  ereport(ERROR,
270  (errcode(ERRCODE_SYNTAX_ERROR),
271  errmsg("parallel workers for vacuum must be between 0 and %d",
273  parser_errposition(pstate, opt->location)));
274 
275  /*
276  * Disable parallel vacuum, if user has specified parallel
277  * degree as zero.
278  */
279  if (nworkers == 0)
280  params.nworkers = -1;
281  else
282  params.nworkers = nworkers;
283  }
284  }
285  else if (strcmp(opt->defname, "skip_database_stats") == 0)
286  skip_database_stats = defGetBoolean(opt);
287  else if (strcmp(opt->defname, "only_database_stats") == 0)
288  only_database_stats = defGetBoolean(opt);
289  else
290  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  params.options =
298  (vacstmt->is_vacuumcmd ? VACOPT_VACUUM : VACOPT_ANALYZE) |
299  (verbose ? VACOPT_VERBOSE : 0) |
300  (skip_locked ? VACOPT_SKIP_LOCKED : 0) |
301  (analyze ? VACOPT_ANALYZE : 0) |
302  (freeze ? VACOPT_FREEZE : 0) |
303  (full ? VACOPT_FULL : 0) |
304  (disable_page_skipping ? VACOPT_DISABLE_PAGE_SKIPPING : 0) |
305  (process_main ? VACOPT_PROCESS_MAIN : 0) |
306  (process_toast ? VACOPT_PROCESS_TOAST : 0) |
307  (skip_database_stats ? VACOPT_SKIP_DATABASE_STATS : 0) |
308  (only_database_stats ? VACOPT_ONLY_DATABASE_STATS : 0);
309 
310  /* sanity checks on options */
312  Assert((params.options & VACOPT_VACUUM) ||
313  !(params.options & (VACOPT_FULL | VACOPT_FREEZE)));
314 
315  if ((params.options & VACOPT_FULL) && params.nworkers > 0)
316  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  if (ring_size != -1 && (params.options & VACOPT_FULL) &&
326  !(params.options & VACOPT_ANALYZE))
327  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  if (!(params.options & VACOPT_ANALYZE))
335  {
336  foreach(lc, vacstmt->rels)
337  {
339 
340  if (vrel->va_cols != NIL)
341  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  if ((params.options & VACOPT_FULL) != 0 &&
352  (params.options & VACOPT_DISABLE_PAGE_SKIPPING) != 0)
353  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  if ((params.options & VACOPT_FULL) != 0 &&
359  (params.options & VACOPT_PROCESS_TOAST) == 0)
360  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  if (params.options & VACOPT_ONLY_DATABASE_STATS)
366  {
367  Assert(params.options & VACOPT_VACUUM);
368  if (vacstmt->rels != NIL)
369  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  if (params.options & ~(VACOPT_VACUUM |
378  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  if (params.options & VACOPT_FREEZE)
388  {
389  params.freeze_min_age = 0;
390  params.freeze_table_age = 0;
391  params.multixact_freeze_min_age = 0;
392  params.multixact_freeze_table_age = 0;
393  }
394  else
395  {
396  params.freeze_min_age = -1;
397  params.freeze_table_age = -1;
398  params.multixact_freeze_min_age = -1;
399  params.multixact_freeze_table_age = -1;
400  }
401 
402  /* user-invoked vacuum is never "for wraparound" */
403  params.is_wraparound = false;
404 
405  /* user-invoked vacuum uses VACOPT_VERBOSE instead of log_min_duration */
406  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  vac_context = AllocSetContextCreate(PortalContext,
415  "Vacuum",
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  if ((params.options & (VACOPT_ONLY_DATABASE_STATS |
426  VACOPT_FULL)) == 0 ||
427  (params.options & VACOPT_ANALYZE) != 0)
428  {
429 
430  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  if (ring_size == -1)
441  ring_size = VacuumBufferUsageLimit;
442 
443  bstrategy = GetAccessStrategyWithSize(BAS_VACUUM, ring_size);
444 
445  MemoryContextSwitchTo(old_context);
446  }
447 
448  /* Now go through the common routine */
449  vacuum(vacstmt->rels, &params, bstrategy, vac_context, isTopLevel);
450 
451  /* Finally, clean up the vacuum memory context */
452  MemoryContextDelete(vac_context);
453 }
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 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  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  if (params->options & VACOPT_VACUUM)
500  {
501  PreventInTransactionBlock(isTopLevel, stmttype);
502  in_outer_xact = false;
503  }
504  else
505  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  if (in_vacuum)
513  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  if (params->options & VACOPT_ONLY_DATABASE_STATS)
523  {
524  /* We don't process any tables in this case */
525  Assert(relations == NIL);
526  }
527  else if (relations != NIL)
528  {
529  List *newrels = NIL;
530  ListCell *lc;
531 
532  foreach(lc, relations)
533  {
535  List *sublist;
536  MemoryContext old_context;
537 
538  sublist = expand_vacuum_rel(vrel, vac_context, params->options);
539  old_context = MemoryContextSwitchTo(vac_context);
540  newrels = list_concat(newrels, sublist);
541  MemoryContextSwitchTo(old_context);
542  }
543  relations = newrels;
544  }
545  else
546  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  if (params->options & VACOPT_VACUUM)
563  use_own_xacts = true;
564  else
565  {
566  Assert(params->options & VACOPT_ANALYZE);
568  use_own_xacts = true;
569  else if (in_outer_xact)
570  use_own_xacts = false;
571  else if (list_length(relations) > 1)
572  use_own_xacts = true;
573  else
574  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  if (use_own_xacts)
586  {
587  Assert(!in_outer_xact);
588 
589  /* ActiveSnapshot is not set by autovacuum */
590  if (ActiveSnapshotSet())
592 
593  /* matches the StartTransaction in PostgresMain() */
595  }
596 
597  /* Turn vacuum cost accounting on or off, and set/clear in_vacuum */
598  PG_TRY();
599  {
600  ListCell *cur;
601 
602  in_vacuum = true;
603  VacuumFailsafeActive = false;
605  VacuumCostBalance = 0;
606  VacuumPageHit = 0;
607  VacuumPageMiss = 0;
608  VacuumPageDirty = 0;
611  VacuumActiveNWorkers = NULL;
612 
613  /*
614  * Loop to process each selected relation.
615  */
616  foreach(cur, relations)
617  {
619 
620  if (params->options & VACOPT_VACUUM)
621  {
622  if (!vacuum_rel(vrel->oid, vrel->relation, params, bstrategy))
623  continue;
624  }
625 
626  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  if (use_own_xacts)
633  {
635  /* functions in indexes may want a snapshot set */
637  }
638 
639  analyze_rel(vrel->oid, vrel->relation, params,
640  vrel->va_cols, in_outer_xact, bstrategy);
641 
642  if (use_own_xacts)
643  {
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  */
655  }
656  }
657 
658  /*
659  * Ensure VacuumFailsafeActive has been reset before vacuuming the
660  * next relation.
661  */
662  VacuumFailsafeActive = false;
663  }
664  }
665  PG_FINALLY();
666  {
667  in_vacuum = false;
668  VacuumCostActive = false;
669  VacuumFailsafeActive = false;
670  VacuumCostBalance = 0;
671  }
672  PG_END_TRY();
673 
674  /*
675  * Finish up processing.
676  */
677  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  */
686  }
687 
688  if ((params->options & VACOPT_VACUUM) &&
689  !(params->options & VACOPT_SKIP_DATABASE_STATS))
690  {
691  /*
692  * Update pg_database.datfrozenxid, and truncate pg_xact if possible.
693  */
695  }
696 
697 }
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
707  bits32 options)
708 {
709  char *relname;
710 
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  if ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId()) &&
721  !reltuple->relisshared) ||
723  return true;
724 
725  relname = NameStr(reltuple->relname);
726 
727  if ((options & VACOPT_VACUUM) != 0)
728  {
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  return false;
739  }
740 
741  if ((options & VACOPT_ANALYZE) != 0)
743  (errmsg("permission denied to analyze \"%s\", skipping it",
744  relname)));
745 
746  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
759  bool verbose, LOCKMODE lmode)
760 {
761  Relation rel;
762  bool rel_lock = true;
763  int elevel;
764 
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  if (!(options & VACOPT_SKIP_LOCKED))
777  rel = try_relation_open(relid, lmode);
778  else if (ConditionalLockRelationOid(relid, lmode))
779  rel = try_relation_open(relid, NoLock);
780  else
781  {
782  rel = NULL;
783  rel_lock = false;
784  }
785 
786  /* if relation is opened, leave */
787  if (rel)
788  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  if (relation == NULL)
800  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  */
810  elevel = WARNING;
811  else if (verbose)
812  elevel = LOG;
813  else
814  return NULL;
815 
816  if ((options & VACOPT_VACUUM) != 0)
817  {
818  if (!rel_lock)
819  ereport(elevel,
820  (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
821  errmsg("skipping vacuum of \"%s\" --- lock not available",
822  relation->relname)));
823  else
824  ereport(elevel,
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  return NULL;
835  }
836 
837  if ((options & VACOPT_ANALYZE) != 0)
838  {
839  if (!rel_lock)
840  ereport(elevel,
841  (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
842  errmsg("skipping analyze of \"%s\" --- lock not available",
843  relation->relname)));
844  else
845  ereport(elevel,
847  errmsg("skipping analyze of \"%s\" --- relation no longer exists",
848  relation->relname)));
849  }
850 
851  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 *
871  int options)
872 {
873  List *vacrels = NIL;
874  MemoryContext oldcontext;
875 
876  /* If caller supplied OID, there's nothing we need do here. */
877  if (OidIsValid(vrel->oid))
878  {
879  oldcontext = MemoryContextSwitchTo(vac_context);
880  vacrels = lappend(vacrels, vrel);
881  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  */
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  rvr_opts = (options & VACOPT_SKIP_LOCKED) ? RVR_SKIP_LOCKED : 0;
904  relid = RangeVarGetRelidExtended(vrel->relation,
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  if (!OidIsValid(relid))
914  {
915  if (options & VACOPT_VACUUM)
917  (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
918  errmsg("skipping vacuum of \"%s\" --- lock not available",
919  vrel->relation->relname)));
920  else
922  (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
923  errmsg("skipping analyze of \"%s\" --- lock not available",
924  vrel->relation->relname)));
925  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  tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
933  if (!HeapTupleIsValid(tuple))
934  elog(ERROR, "cache lookup failed for relation %u", relid);
935  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  if (vacuum_is_permitted_for_relation(relid, classForm, options))
942  {
943  oldcontext = MemoryContextSwitchTo(vac_context);
944  vacrels = lappend(vacrels, makeVacuumRelation(vrel->relation,
945  relid,
946  vrel->va_cols));
947  MemoryContextSwitchTo(oldcontext);
948  }
949 
950 
951  include_parts = (classForm->relkind == RELKIND_PARTITIONED_TABLE);
952  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  if (include_parts)
964  {
965  List *part_oids = find_all_inheritors(relid, NoLock, NULL);
966  ListCell *part_lc;
967 
968  foreach(part_lc, part_oids)
969  {
970  Oid part_oid = lfirst_oid(part_lc);
971 
972  if (part_oid == relid)
973  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  oldcontext = MemoryContextSwitchTo(vac_context);
981  vacrels = lappend(vacrels, makeVacuumRelation(NULL,
982  part_oid,
983  vrel->va_cols));
984  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  */
1000  }
1001 
1002  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 *
1011 {
1012  List *vacrels = NIL;
1013  Relation pgclass;
1014  TableScanDesc scan;
1015  HeapTuple tuple;
1016 
1017  pgclass = table_open(RelationRelationId, AccessShareLock);
1018 
1019  scan = table_beginscan_catalog(pgclass, 0, NULL);
1020 
1021  while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
1022  {
1023  Form_pg_class classForm = (Form_pg_class) GETSTRUCT(tuple);
1024  MemoryContext oldcontext;
1025  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  if (classForm->relkind != RELKIND_RELATION &&
1033  classForm->relkind != RELKIND_MATVIEW &&
1034  classForm->relkind != RELKIND_PARTITIONED_TABLE)
1035  continue;
1036 
1037  /* check permissions of relation */
1038  if (!vacuum_is_permitted_for_relation(relid, classForm, options))
1039  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  oldcontext = MemoryContextSwitchTo(vac_context);
1047  vacrels = lappend(vacrels, makeVacuumRelation(NULL,
1048  relid,
1049  NIL));
1050  MemoryContextSwitchTo(oldcontext);
1051  }
1052 
1053  table_endscan(scan);
1054  table_close(pgclass, AccessShareLock);
1055 
1056  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
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  freeze_min_age = params->freeze_min_age;
1089  multixact_freeze_min_age = params->multixact_freeze_min_age;
1090  freeze_table_age = params->freeze_table_age;
1091  multixact_freeze_table_age = params->multixact_freeze_table_age;
1092 
1093  /* Set pg_class fields in cutoffs */
1094  cutoffs->relfrozenxid = rel->rd_rel->relfrozenxid;
1095  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  */
1109 
1111 
1112  /* Acquire OldestMxact */
1113  cutoffs->OldestMxact = GetOldestMultiXactId();
1115 
1116  /* Acquire next XID/next MXID values used to apply age-based settings */
1117  nextXID = ReadNextTransactionId();
1118  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  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  safeOldestXmin = nextXID - autovacuum_freeze_max_age;
1132  if (!TransactionIdIsNormal(safeOldestXmin))
1133  safeOldestXmin = FirstNormalTransactionId;
1134  safeOldestMxact = nextMXID - effective_multixact_freeze_max_age;
1135  if (safeOldestMxact < FirstMultiXactId)
1136  safeOldestMxact = FirstMultiXactId;
1137  if (TransactionIdPrecedes(cutoffs->OldestXmin, safeOldestXmin))
1138  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  if (MultiXactIdPrecedes(cutoffs->OldestMxact, safeOldestMxact))
1143  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  if (freeze_min_age < 0)
1155  freeze_min_age = vacuum_freeze_min_age;
1156  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  cutoffs->FreezeLimit = nextXID - freeze_min_age;
1161  if (!TransactionIdIsNormal(cutoffs->FreezeLimit))
1163  /* FreezeLimit must always be <= OldestXmin */
1164  if (TransactionIdPrecedes(cutoffs->OldestXmin, cutoffs->FreezeLimit))
1165  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  if (multixact_freeze_min_age < 0)
1174  multixact_freeze_min_age = vacuum_multixact_freeze_min_age;
1175  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  cutoffs->MultiXactCutoff = nextMXID - multixact_freeze_min_age;
1181  if (cutoffs->MultiXactCutoff < FirstMultiXactId)
1182  cutoffs->MultiXactCutoff = FirstMultiXactId;
1183  /* MultiXactCutoff must always be <= OldestMxact */
1184  if (MultiXactIdPrecedes(cutoffs->OldestMxact, cutoffs->MultiXactCutoff))
1185  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  if (freeze_table_age < 0)
1197  freeze_table_age = vacuum_freeze_table_age;
1198  freeze_table_age = Min(freeze_table_age, autovacuum_freeze_max_age * 0.95);
1199  Assert(freeze_table_age >= 0);
1200  aggressiveXIDCutoff = nextXID - freeze_table_age;
1201  if (!TransactionIdIsNormal(aggressiveXIDCutoff))
1202  aggressiveXIDCutoff = FirstNormalTransactionId;
1204  aggressiveXIDCutoff))
1205  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  if (multixact_freeze_table_age < 0)
1216  multixact_freeze_table_age = vacuum_multixact_freeze_table_age;
1217  multixact_freeze_table_age =
1218  Min(multixact_freeze_table_age,
1219  effective_multixact_freeze_max_age * 0.95);
1220  Assert(multixact_freeze_table_age >= 0);
1221  aggressiveMXIDCutoff = nextMXID - multixact_freeze_table_age;
1222  if (aggressiveMXIDCutoff < FirstMultiXactId)
1223  aggressiveMXIDCutoff = FirstMultiXactId;
1225  aggressiveMXIDCutoff))
1226  return true;
1227 
1228  /* Non-aggressive VACUUM */
1229  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
1241 {
1242  TransactionId relfrozenxid = cutoffs->relfrozenxid;
1243  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  skip_index_vacuum = Max(vacuum_failsafe_age, autovacuum_freeze_max_age * 1.05);
1256 
1257  xid_skip_limit = ReadNextTransactionId() - skip_index_vacuum;
1258  if (!TransactionIdIsNormal(xid_skip_limit))
1259  xid_skip_limit = FirstNormalTransactionId;
1260 
1261  if (TransactionIdPrecedes(relfrozenxid, xid_skip_limit))
1262  {
1263  /* The table's relfrozenxid is too old */
1264  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  skip_index_vacuum = Max(vacuum_multixact_failsafe_age,
1274 
1275  multi_skip_limit = ReadNextMultiXactId() - skip_index_vacuum;
1276  if (multi_skip_limit < FirstMultiXactId)
1277  multi_skip_limit = FirstMultiXactId;
1278 
1279  if (MultiXactIdPrecedes(relminmxid, multi_skip_limit))
1280  {
1281  /* The table's relminmxid is too old */
1282  return true;
1283  }
1284 
1285  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
1303  BlockNumber total_pages,
1304  BlockNumber scanned_pages,
1305  double scanned_tuples)
1306 {
1307  BlockNumber old_rel_pages = relation->rd_rel->relpages;
1308  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  if (scanned_pages >= total_pages)
1315  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  if (old_rel_pages == total_pages &&
1332  scanned_pages < (double) total_pages * 0.02)
1333  return old_rel_tuples;
1334  if (scanned_pages <= 1)
1335  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  if (old_rel_tuples < 0 || old_rel_pages == 0)
1342  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  old_density = old_rel_tuples / old_rel_pages;
1351  unscanned_pages = (double) total_pages - (double) scanned_pages;
1352  total_tuples = old_density * unscanned_pages + scanned_tuples;
1353  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
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  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  rd = table_open(RelationRelationId, RowExclusiveLock);
1417 
1418  /* Fetch a copy of the tuple to scribble on */
1419  ctup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
1420  if (!HeapTupleIsValid(ctup))
1421  elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
1422  relid);
1423  pgcform = (Form_pg_class) GETSTRUCT(ctup);
1424 
1425  /* Apply statistical updates, if any, to copied tuple */
1426 
1427  dirty = false;
1428  if (pgcform->relpages != (int32) num_pages)
1429  {
1430  pgcform->relpages = (int32) num_pages;
1431  dirty = true;
1432  }
1433  if (pgcform->reltuples != (float4) num_tuples)
1434  {
1435  pgcform->reltuples = (float4) num_tuples;
1436  dirty = true;
1437  }
1438  if (pgcform->relallvisible != (int32) num_all_visible_pages)
1439  {
1440  pgcform->relallvisible = (int32) num_all_visible_pages;
1441  dirty = true;
1442  }
1443 
1444  /* Apply DDL updates, but not inside an outer transaction (see above) */
1445 
1446  if (!in_outer_xact)
1447  {
1448  /*
1449  * If we didn't find any indexes, reset relhasindex.
1450  */
1451  if (pgcform->relhasindex && !hasindex)
1452  {
1453  pgcform->relhasindex = false;
1454  dirty = true;
1455  }
1456 
1457  /* We also clear relhasrules and relhastriggers if needed */
1458  if (pgcform->relhasrules && relation->rd_rules == NULL)
1459  {
1460  pgcform->relhasrules = false;
1461  dirty = true;
1462  }
1463  if (pgcform->relhastriggers && relation->trigdesc == NULL)
1464  {
1465  pgcform->relhastriggers = false;
1466  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  oldfrozenxid = pgcform->relfrozenxid;
1481  futurexid = false;
1482  if (frozenxid_updated)
1483  *frozenxid_updated = false;
1484  if (TransactionIdIsNormal(frozenxid) && oldfrozenxid != frozenxid)
1485  {
1486  bool update = false;
1487 
1488  if (TransactionIdPrecedes(oldfrozenxid, frozenxid))
1489  update = true;
1490  else if (TransactionIdPrecedes(ReadNextTransactionId(), oldfrozenxid))
1491  futurexid = update = true;
1492 
1493  if (update)
1494  {
1495  pgcform->relfrozenxid = frozenxid;
1496  dirty = true;
1497  if (frozenxid_updated)
1498  *frozenxid_updated = true;
1499  }
1500  }
1501 
1502  /* Similarly for relminmxid */
1503  oldminmulti = pgcform->relminmxid;
1504  futuremxid = false;
1505  if (minmulti_updated)
1506  *minmulti_updated = false;
1507  if (MultiXactIdIsValid(minmulti) && oldminmulti != minmulti)
1508  {
1509  bool update = false;
1510 
1511  if (MultiXactIdPrecedes(oldminmulti, minmulti))
1512  update = true;
1513  else if (MultiXactIdPrecedes(ReadNextMultiXactId(), oldminmulti))
1514  futuremxid = update = true;
1515 
1516  if (update)
1517  {
1518  pgcform->relminmxid = minmulti;
1519  dirty = true;
1520  if (minmulti_updated)
1521  *minmulti_updated = true;
1522  }
1523  }
1524 
1525  /* If anything changed, write out the tuple. */
1526  if (dirty)
1527  heap_inplace_update(rd, ctup);
1528 
1530 
1531  if (futurexid)
1532  ereport(WARNING,
1534  errmsg_internal("overwrote invalid relfrozenxid value %u with new value %u for table \"%s\"",
1535  oldfrozenxid, frozenxid,
1536  RelationGetRelationName(relation))));
1537  if (futuremxid)
1538  ereport(WARNING,
1540  errmsg_internal("overwrote invalid relminmxid value %u with new value %u for table \"%s\"",
1541  oldminmulti, minmulti,
1542  RelationGetRelationName(relation))));
1543 }
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
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  bool bogus = false;
1577  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  */
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  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  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  lastSaneFrozenXid = ReadNextTransactionId();
1609  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  * See vac_truncate_clog() for the race condition to prevent.
1616  */
1617  relation = table_open(RelationRelationId, AccessShareLock);
1618 
1619  scan = systable_beginscan(relation, InvalidOid, false,
1620  NULL, 0, NULL);
1621 
1622  while ((classTup = systable_getnext(scan)) != NULL)
1623  {
1624  volatile FormData_pg_class *classForm = (Form_pg_class) GETSTRUCT(classTup);
1625  TransactionId relfrozenxid = classForm->relfrozenxid;
1626  TransactionId relminmxid = classForm->relminmxid;
1627 
1628  /*
1629  * Only consider relations able to hold unfrozen XIDs (anything else
1630  * should have InvalidTransactionId in relfrozenxid anyway).
1631  */
1632  if (classForm->relkind != RELKIND_RELATION &&
1633  classForm->relkind != RELKIND_MATVIEW &&
1634  classForm->relkind != RELKIND_TOASTVALUE)
1635  {
1636  Assert(!TransactionIdIsValid(relfrozenxid));
1637  Assert(!MultiXactIdIsValid(relminmxid));
1638  continue;
1639  }
1640 
1641  /*
1642  * Some table AMs might not need per-relation xid / multixid horizons.
1643  * It therefore seems reasonable to allow relfrozenxid and relminmxid
1644  * to not be set (i.e. set to their respective Invalid*Id)
1645  * independently. Thus validate and compute horizon for each only if
1646  * set.
1647  *
1648  * If things are working properly, no relation should have a
1649  * relfrozenxid or relminmxid that is "in the future". However, such
1650  * cases have been known to arise due to bugs in pg_upgrade. If we
1651  * see any entries that are "in the future", chicken out and don't do
1652  * anything. This ensures we won't truncate clog & multixact SLRUs
1653  * before those relations have been scanned and cleaned up.
1654  */
1655 
1656  if (TransactionIdIsValid(relfrozenxid))
1657  {
1658  Assert(TransactionIdIsNormal(relfrozenxid));
1659 
1660  /* check for values in the future */
1661  if (TransactionIdPrecedes(lastSaneFrozenXid, relfrozenxid))
1662  {
1663  bogus = true;
1664  break;
1665  }
1666 
1667  /* determine new horizon */
1668  if (TransactionIdPrecedes(relfrozenxid, newFrozenXid))
1669  newFrozenXid = relfrozenxid;
1670  }
1671 
1672  if (MultiXactIdIsValid(relminmxid))
1673  {
1674  /* check for values in the future */
1675  if (MultiXactIdPrecedes(lastSaneMinMulti, relminmxid))
1676  {
1677  bogus = true;
1678  break;
1679  }
1680 
1681  /* determine new horizon */
1682  if (MultiXactIdPrecedes(relminmxid, newMinMulti))
1683  newMinMulti = relminmxid;
1684  }
1685  }
1686 
1687  /* we're done with pg_class */
1688  systable_endscan(scan);
1689  table_close(relation, AccessShareLock);
1690 
1691  /* chicken out if bogus data found */
1692  if (bogus)
1693  return;
1694 
1695  Assert(TransactionIdIsNormal(newFrozenXid));
1696  Assert(MultiXactIdIsValid(newMinMulti));
1697 
1698  /* Now fetch the pg_database tuple we need to update. */
1699  relation = table_open(DatabaseRelationId, RowExclusiveLock);
1700 
1701  /*
1702  * Get the pg_database tuple to scribble on. Note that this does not
1703  * directly rely on the syscache to avoid issues with flattened toast
1704  * values for the in-place update.
1705  */
1706  ScanKeyInit(&key[0],
1707  Anum_pg_database_oid,
1708  BTEqualStrategyNumber, F_OIDEQ,
1710 
1711  scan = systable_beginscan(relation, DatabaseOidIndexId, true,
1712  NULL, 1, key);
1713  tuple = systable_getnext(scan);
1714  tuple = heap_copytuple(tuple);
1715  systable_endscan(scan);
1716 
1717  if (!HeapTupleIsValid(tuple))
1718  elog(ERROR, "could not find tuple for database %u", MyDatabaseId);
1719 
1720  dbform = (Form_pg_database) GETSTRUCT(tuple);
1721 
1722  /*
1723  * As in vac_update_relstats(), we ordinarily don't want to let
1724  * datfrozenxid go backward; but if it's "in the future" then it must be
1725  * corrupt and it seems best to overwrite it.
1726  */
1727  if (dbform->datfrozenxid != newFrozenXid &&
1728  (TransactionIdPrecedes(dbform->datfrozenxid, newFrozenXid) ||
1729  TransactionIdPrecedes(lastSaneFrozenXid, dbform->datfrozenxid)))
1730  {
1731  dbform->datfrozenxid = newFrozenXid;
1732  dirty = true;
1733  }
1734  else
1735  newFrozenXid = dbform->datfrozenxid;
1736 
1737  /* Ditto for datminmxid */
1738  if (dbform->datminmxid != newMinMulti &&
1739  (MultiXactIdPrecedes(dbform->datminmxid, newMinMulti) ||
1740  MultiXactIdPrecedes(lastSaneMinMulti, dbform->datminmxid)))
1741  {
1742  dbform->datminmxid = newMinMulti;
1743  dirty = true;
1744  }
1745  else
1746  newMinMulti = dbform->datminmxid;
1747 
1748  if (dirty)
1749  heap_inplace_update(relation, tuple);
1750 
1751  heap_freetuple(tuple);
1752  table_close(relation, RowExclusiveLock);
1753 
1754  /*
1755  * If we were able to advance datfrozenxid or datminmxid, see if we can
1756  * truncate pg_xact and/or pg_multixact. Also do it if the shared
1757  * XID-wrap-limit info is stale, since this action will update that too.
1758  */
1759  if (dirty || ForceTransactionIdLimitUpdate())
1760  vac_truncate_clog(newFrozenXid, newMinMulti,
1761  lastSaneFrozenXid, lastSaneMinMulti);
1762 }
1763 
1764 
1765 /*
1766  * vac_truncate_clog() -- attempt to truncate the commit log
1767  *
1768  * Scan pg_database to determine the system-wide oldest datfrozenxid,
1769  * and use it to truncate the transaction commit log (pg_xact).
1770  * Also update the XID wrap limit info maintained by varsup.c.
1771  * Likewise for datminmxid.
1772  *
1773  * The passed frozenXID and minMulti are the updated values for my own
1774  * pg_database entry. They're used to initialize the "min" calculations.
1775  * The caller also passes the "last sane" XID and MXID, since it has
1776  * those at hand already.
1777  *
1778  * This routine is only invoked when we've managed to change our
1779  * DB's datfrozenxid/datminmxid values, or we found that the shared
1780  * XID-wrap-limit info is stale.
1781  */
1782 static void
1784  MultiXactId minMulti,
1785  TransactionId lastSaneFrozenXid,
1786  MultiXactId lastSaneMinMulti)
1787 {
1789  Relation relation;
1790  TableScanDesc scan;
1791  HeapTuple tuple;
1792  Oid oldestxid_datoid;
1793  Oid minmulti_datoid;
1794  bool bogus = false;
1795  bool frozenAlreadyWrapped = false;
1796 
1797  /* Restrict task to one backend per cluster; see SimpleLruTruncate(). */
1798  LWLockAcquire(WrapLimitsVacuumLock, LW_EXCLUSIVE);
1799 
1800  /* init oldest datoids to sync with my frozenXID/minMulti values */
1801  oldestxid_datoid = MyDatabaseId;
1802  minmulti_datoid = MyDatabaseId;
1803 
1804  /*
1805  * Scan pg_database to compute the minimum datfrozenxid/datminmxid
1806  *
1807  * Since vac_update_datfrozenxid updates datfrozenxid/datminmxid in-place,
1808  * the values could change while we look at them. Fetch each one just
1809  * once to ensure sane behavior of the comparison logic. (Here, as in
1810  * many other places, we assume that fetching or updating an XID in shared
1811  * storage is atomic.)
1812  *
1813  * Note: we need not worry about a race condition with new entries being
1814  * inserted by CREATE DATABASE. Any such entry will have a copy of some
1815  * existing DB's datfrozenxid, and that source DB cannot be ours because
1816  * of the interlock against copying a DB containing an active backend.
1817  * Hence the new entry will not reduce the minimum. Also, if two VACUUMs
1818  * concurrently modify the datfrozenxid's of different databases, the
1819  * worst possible outcome is that pg_xact is not truncated as aggressively
1820  * as it could be.
1821  */
1822  relation = table_open(DatabaseRelationId, AccessShareLock);
1823 
1824  scan = table_beginscan_catalog(relation, 0, NULL);
1825 
1826  while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
1827  {
1828  volatile FormData_pg_database *dbform = (Form_pg_database) GETSTRUCT(tuple);
1829  TransactionId datfrozenxid = dbform->datfrozenxid;
1830  TransactionId datminmxid = dbform->datminmxid;
1831 
1834 
1835  /*
1836  * If database is in the process of getting dropped, or has been
1837  * interrupted while doing so, no connections to it are possible
1838  * anymore. Therefore we don't need to take it into account here.
1839  * Which is good, because it can't be processed by autovacuum either.
1840  */
1842  {
1843  elog(DEBUG2,
1844  "skipping invalid database \"%s\" while computing relfrozenxid",
1845  NameStr(dbform->datname));
1846  continue;
1847  }
1848 
1849  /*
1850  * If things are working properly, no database should have a
1851  * datfrozenxid or datminmxid that is "in the future". However, such
1852  * cases have been known to arise due to bugs in pg_upgrade. If we
1853  * see any entries that are "in the future", chicken out and don't do
1854  * anything. This ensures we won't truncate clog before those
1855  * databases have been scanned and cleaned up. (We will issue the
1856  * "already wrapped" warning if appropriate, though.)
1857  */
1858  if (TransactionIdPrecedes(lastSaneFrozenXid, datfrozenxid) ||
1859  MultiXactIdPrecedes(lastSaneMinMulti, datminmxid))
1860  bogus = true;
1861 
1862  if (TransactionIdPrecedes(nextXID, datfrozenxid))
1863  frozenAlreadyWrapped = true;
1864  else if (TransactionIdPrecedes(datfrozenxid, frozenXID))
1865  {
1866  frozenXID = datfrozenxid;
1867  oldestxid_datoid = dbform->oid;
1868  }
1869 
1870  if (MultiXactIdPrecedes(datminmxid, minMulti))
1871  {
1872  minMulti = datminmxid;
1873  minmulti_datoid = dbform->oid;
1874  }
1875  }
1876 
1877  table_endscan(scan);
1878 
1879  table_close(relation, AccessShareLock);
1880 
1881  /*
1882  * Do not truncate CLOG if we seem to have suffered wraparound already;
1883  * the computed minimum XID might be bogus. This case should now be
1884  * impossible due to the defenses in GetNewTransactionId, but we keep the
1885  * test anyway.
1886  */
1887  if (frozenAlreadyWrapped)
1888  {
1889  ereport(WARNING,
1890  (errmsg("some databases have not been vacuumed in over 2 billion transactions"),
1891  errdetail("You might have already suffered transaction-wraparound data loss.")));
1892  LWLockRelease(WrapLimitsVacuumLock);
1893  return;
1894  }
1895 
1896  /* chicken out if data is bogus in any other way */
1897  if (bogus)
1898  {
1899  LWLockRelease(WrapLimitsVacuumLock);
1900  return;
1901  }
1902 
1903  /*
1904  * Advance the oldest value for commit timestamps before truncating, so
1905  * that if a user requests a timestamp for a transaction we're truncating
1906  * away right after this point, they get NULL instead of an ugly "file not
1907  * found" error from slru.c. This doesn't matter for xact/multixact
1908  * because they are not subject to arbitrary lookups from users.
1909  */
1910  AdvanceOldestCommitTsXid(frozenXID);
1911 
1912  /*
1913  * Truncate CLOG, multixact and CommitTs to the oldest computed value.
1914  */
1915  TruncateCLOG(frozenXID, oldestxid_datoid);
1916  TruncateCommitTs(frozenXID);
1917  TruncateMultiXact(minMulti, minmulti_datoid);
1918 
1919  /*
1920  * Update the wrap limit for GetNewTransactionId and creation of new
1921  * MultiXactIds. Note: these functions will also signal the postmaster
1922  * for an(other) autovac cycle if needed. XXX should we avoid possibly
1923  * signaling twice?
1924  */
1925  SetTransactionIdLimit(frozenXID, oldestxid_datoid);
1926  SetMultiXactIdLimit(minMulti, minmulti_datoid, false);
1927 
1928  LWLockRelease(WrapLimitsVacuumLock);
1929 }
1930 
1931 
1932 /*
1933  * vacuum_rel() -- vacuum one heap relation
1934  *
1935  * relid identifies the relation to vacuum. If relation is supplied,
1936  * use the name therein for reporting any failure to open/lock the rel;
1937  * do not use it once we've successfully opened the rel, since it might
1938  * be stale.
1939  *
1940  * Returns true if it's okay to proceed with a requested ANALYZE
1941  * operation on this table.
1942  *
1943  * Doing one heap at a time incurs extra overhead, since we need to
1944  * check that the heap exists again just before we vacuum it. The
1945  * reason that we do this is so that vacuuming can be spread across
1946  * many small transactions. Otherwise, two-phase locking would require
1947  * us to lock the entire database during one pass of the vacuum cleaner.
1948  *
1949  * At entry and exit, we are not inside a transaction.
1950  */
1951 static bool
1952 vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params,
1953  BufferAccessStrategy bstrategy)
1954 {
1955  LOCKMODE lmode;
1956  Relation rel;
1957  LockRelId lockrelid;
1958  Oid priv_relid;
1959  Oid toast_relid;
1960  Oid save_userid;
1961  int save_sec_context;
1962  int save_nestlevel;
1963 
1964  Assert(params != NULL);
1965 
1966  /* Begin a transaction for vacuuming this relation */
1968 
1969  if (!(params->options & VACOPT_FULL))
1970  {
1971  /*
1972  * In lazy vacuum, we can set the PROC_IN_VACUUM flag, which lets
1973  * other concurrent VACUUMs know that they can ignore this one while
1974  * determining their OldestXmin. (The reason we don't set it during a
1975  * full VACUUM is exactly that we may have to run user-defined
1976  * functions for functional indexes, and we want to make sure that if
1977  * they use the snapshot set above, any tuples it requires can't get
1978  * removed from other tables. An index function that depends on the
1979  * contents of other tables is arguably broken, but we won't break it
1980  * here by violating transaction semantics.)
1981  *
1982  * We also set the VACUUM_FOR_WRAPAROUND flag, which is passed down by
1983  * autovacuum; it's used to avoid canceling a vacuum that was invoked
1984  * in an emergency.
1985  *
1986  * Note: these flags remain set until CommitTransaction or
1987  * AbortTransaction. We don't want to clear them until we reset
1988  * MyProc->xid/xmin, otherwise GetOldestNonRemovableTransactionId()
1989  * might appear to go backwards, which is probably Not Good. (We also
1990  * set PROC_IN_VACUUM *before* taking our own snapshot, so that our
1991  * xmin doesn't become visible ahead of setting the flag.)
1992  */
1993  LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
1995  if (params->is_wraparound)
1998  LWLockRelease(ProcArrayLock);
1999  }
2000 
2001  /*
2002  * Need to acquire a snapshot to prevent pg_subtrans from being truncated,
2003  * cutoff xids in local memory wrapping around, and to have updated xmin
2004  * horizons.
2005  */
2007 
2008  /*
2009  * Check for user-requested abort. Note we want this to be inside a
2010  * transaction, so xact.c doesn't issue useless WARNING.
2011  */
2013 
2014  /*
2015  * Determine the type of lock we want --- hard exclusive lock for a FULL
2016  * vacuum, but just ShareUpdateExclusiveLock for concurrent vacuum. Either
2017  * way, we can be sure that no other backend is vacuuming the same table.
2018  */
2019  lmode = (params->options & VACOPT_FULL) ?
2021 
2022  /* open the relation and get the appropriate lock on it */
2023  rel = vacuum_open_relation(relid, relation, params->options,
2024  params->log_min_duration >= 0, lmode);
2025 
2026  /* leave if relation could not be opened or locked */
2027  if (!rel)
2028  {
2031  return false;
2032  }
2033 
2034  /*
2035  * When recursing to a TOAST table, check privileges on the parent. NB:
2036  * This is only safe to do because we hold a session lock on the main
2037  * relation that prevents concurrent deletion.
2038  */
2039  if (OidIsValid(params->toast_parent))
2040  priv_relid = params->toast_parent;
2041  else
2042  priv_relid = RelationGetRelid(rel);
2043 
2044  /*
2045  * Check if relation needs to be skipped based on privileges. This check
2046  * happens also when building the relation list to vacuum for a manual
2047  * operation, and needs to be done additionally here as VACUUM could
2048  * happen across multiple transactions where privileges could have changed
2049  * in-between. Make sure to only generate logs for VACUUM in this case.
2050  */
2051  if (!vacuum_is_permitted_for_relation(priv_relid,
2052  rel->rd_rel,
2053  params->options & ~VACOPT_ANALYZE))
2054  {
2055  relation_close(rel, lmode);
2058  return false;
2059  }
2060 
2061  /*
2062  * Check that it's of a vacuumable relkind.
2063  */
2064  if (rel->rd_rel->relkind != RELKIND_RELATION &&
2065  rel->rd_rel->relkind != RELKIND_MATVIEW &&
2066  rel->rd_rel->relkind != RELKIND_TOASTVALUE &&
2067  rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
2068  {
2069  ereport(WARNING,
2070  (errmsg("skipping \"%s\" --- cannot vacuum non-tables or special system tables",
2071  RelationGetRelationName(rel))));
2072  relation_close(rel, lmode);
2075  return false;
2076  }
2077 
2078  /*
2079  * Silently ignore tables that are temp tables of other backends ---
2080  * trying to vacuum these will lead to great unhappiness, since their
2081  * contents are probably not up-to-date on disk. (We don't throw a
2082  * warning here; it would just lead to chatter during a database-wide
2083  * VACUUM.)
2084  */
2085  if (RELATION_IS_OTHER_TEMP(rel))
2086  {
2087  relation_close(rel, lmode);
2090  return false;
2091  }
2092 
2093  /*
2094  * Silently ignore partitioned tables as there is no work to be done. The
2095  * useful work is on their child partitions, which have been queued up for
2096  * us separately.
2097  */
2098  if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
2099  {
2100  relation_close(rel, lmode);
2103  /* It's OK to proceed with ANALYZE on this table */
2104  return true;
2105  }
2106 
2107  /*
2108  * Get a session-level lock too. This will protect our access to the
2109  * relation across multiple transactions, so that we can vacuum the
2110  * relation's TOAST table (if any) secure in the knowledge that no one is
2111  * deleting the parent relation.
2112  *
2113  * NOTE: this cannot block, even if someone else is waiting for access,
2114  * because the lock manager knows that both lock requests are from the
2115  * same process.
2116  */
2117  lockrelid = rel->rd_lockInfo.lockRelId;
2118  LockRelationIdForSession(&lockrelid, lmode);
2119 
2120  /*
2121  * Set index_cleanup option based on index_cleanup reloption if it wasn't
2122  * specified in VACUUM command, or when running in an autovacuum worker
2123  */
2124  if (params->index_cleanup == VACOPTVALUE_UNSPECIFIED)
2125  {
2126  StdRdOptIndexCleanup vacuum_index_cleanup;
2127 
2128  if (rel->rd_options == NULL)
2129  vacuum_index_cleanup = STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO;
2130  else
2131  vacuum_index_cleanup =
2132  ((StdRdOptions *) rel->rd_options)->vacuum_index_cleanup;
2133 
2134  if (vacuum_index_cleanup == STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO)
2135  params->index_cleanup = VACOPTVALUE_AUTO;
2136  else if (vacuum_index_cleanup == STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON)
2138  else
2139  {
2140  Assert(vacuum_index_cleanup ==
2143  }
2144  }
2145 
2146  /*
2147  * Set truncate option based on truncate reloption if it wasn't specified
2148  * in VACUUM command, or when running in an autovacuum worker
2149  */
2150  if (params->truncate == VACOPTVALUE_UNSPECIFIED)
2151  {
2152  if (rel->rd_options == NULL ||
2153  ((StdRdOptions *) rel->rd_options)->vacuum_truncate)
2154  params->truncate = VACOPTVALUE_ENABLED;
2155  else
2156  params->truncate = VACOPTVALUE_DISABLED;
2157  }
2158 
2159  /*
2160  * Remember the relation's TOAST relation for later, if the caller asked
2161  * us to process it. In VACUUM FULL, though, the toast table is
2162  * automatically rebuilt by cluster_rel so we shouldn't recurse to it,
2163  * unless PROCESS_MAIN is disabled.
2164  */
2165  if ((params->options & VACOPT_PROCESS_TOAST) != 0 &&
2166  ((params->options & VACOPT_FULL) == 0 ||
2167  (params->options & VACOPT_PROCESS_MAIN) == 0))
2168  toast_relid = rel->rd_rel->reltoastrelid;
2169  else
2170  toast_relid = InvalidOid;
2171 
2172  /*
2173  * Switch to the table owner's userid, so that any index functions are run
2174  * as that user. Also lock down security-restricted operations and
2175  * arrange to make GUC variable changes local to this command. (This is
2176  * unnecessary, but harmless, for lazy VACUUM.)
2177  */
2178  GetUserIdAndSecContext(&save_userid, &save_sec_context);
2179  SetUserIdAndSecContext(rel->rd_rel->relowner,
2180  save_sec_context | SECURITY_RESTRICTED_OPERATION);
2181  save_nestlevel = NewGUCNestLevel();
2183 
2184  /*
2185  * If PROCESS_MAIN is set (the default), it's time to vacuum the main
2186  * relation. Otherwise, we can skip this part. If processing the TOAST
2187  * table is required (e.g., PROCESS_TOAST is set), we force PROCESS_MAIN
2188  * to be set when we recurse to the TOAST table.
2189  */
2190  if (params->options & VACOPT_PROCESS_MAIN)
2191  {
2192  /*
2193  * Do the actual work --- either FULL or "lazy" vacuum
2194  */
2195  if (params->options & VACOPT_FULL)
2196  {
2197  ClusterParams cluster_params = {0};
2198 
2199  /* close relation before vacuuming, but hold lock until commit */
2200  relation_close(rel, NoLock);
2201  rel = NULL;
2202 
2203  if ((params->options & VACOPT_VERBOSE) != 0)
2204  cluster_params.options |= CLUOPT_VERBOSE;
2205 
2206  /* VACUUM FULL is now a variant of CLUSTER; see cluster.c */
2207  cluster_rel(relid, InvalidOid, &cluster_params);
2208  }
2209  else
2210  table_relation_vacuum(rel, params, bstrategy);
2211  }
2212 
2213  /* Roll back any GUC changes executed by index functions */
2214  AtEOXact_GUC(false, save_nestlevel);
2215 
2216  /* Restore userid and security context */
2217  SetUserIdAndSecContext(save_userid, save_sec_context);
2218 
2219  /* all done with this class, but hold lock until commit */
2220  if (rel)
2221  relation_close(rel, NoLock);
2222 
2223  /*
2224  * Complete the transaction and free all temporary memory used.
2225  */
2228 
2229  /*
2230  * If the relation has a secondary toast rel, vacuum that too while we
2231  * still hold the session lock on the main table. Note however that
2232  * "analyze" will not get done on the toast table. This is good, because
2233  * the toaster always uses hardcoded index access and statistics are
2234  * totally unimportant for toast relations.
2235  */
2236  if (toast_relid != InvalidOid)
2237  {
2238  VacuumParams toast_vacuum_params;
2239 
2240  /*
2241  * Force VACOPT_PROCESS_MAIN so vacuum_rel() processes it. Likewise,
2242  * set toast_parent so that the privilege checks are done on the main
2243  * relation. NB: This is only safe to do because we hold a session
2244  * lock on the main relation that prevents concurrent deletion.
2245  */
2246  memcpy(&toast_vacuum_params, params, sizeof(VacuumParams));
2247  toast_vacuum_params.options |= VACOPT_PROCESS_MAIN;
2248  toast_vacuum_params.toast_parent = relid;
2249 
2250  vacuum_rel(toast_relid, NULL, &toast_vacuum_params, bstrategy);
2251  }
2252 
2253  /*
2254  * Now release the session-level lock on the main table.
2255  */
2256  UnlockRelationIdForSession(&lockrelid, lmode);
2257 
2258  /* Report that we really did it. */
2259  return true;
2260 }
2261 
2262 
2263 /*
2264  * Open all the vacuumable indexes of the given relation, obtaining the
2265  * specified kind of lock on each. Return an array of Relation pointers for
2266  * the indexes into *Irel, and the number of indexes into *nindexes.
2267  *
2268  * We consider an index vacuumable if it is marked insertable (indisready).
2269  * If it isn't, probably a CREATE INDEX CONCURRENTLY command failed early in
2270  * execution, and what we have is too corrupt to be processable. We will
2271  * vacuum even if the index isn't indisvalid; this is important because in a
2272  * unique index, uniqueness checks will be performed anyway and had better not
2273  * hit dangling index pointers.
2274  */
2275 void
2277  int *nindexes, Relation **Irel)
2278 {
2279  List *indexoidlist;
2280  ListCell *indexoidscan;
2281  int i;
2282 
2283  Assert(lockmode != NoLock);
2284 
2285  indexoidlist = RelationGetIndexList(relation);
2286 
2287  /* allocate enough memory for all indexes */
2288  i = list_length(indexoidlist);
2289 
2290  if (i > 0)
2291  *Irel = (Relation *) palloc(i * sizeof(Relation));
2292  else
2293  *Irel = NULL;
2294 
2295  /* collect just the ready indexes */
2296  i = 0;
2297  foreach(indexoidscan, indexoidlist)
2298  {
2299  Oid indexoid = lfirst_oid(indexoidscan);
2300  Relation indrel;
2301 
2302  indrel = index_open(indexoid, lockmode);
2303  if (indrel->rd_index->indisready)
2304  (*Irel)[i++] = indrel;
2305  else
2306  index_close(indrel, lockmode);
2307  }
2308 
2309  *nindexes = i;
2310 
2311  list_free(indexoidlist);
2312 }
2313 
2314 /*
2315  * Release the resources acquired by vac_open_indexes. Optionally release
2316  * the locks (say NoLock to keep 'em).
2317  */
2318 void
2319 vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode)
2320 {
2321  if (Irel == NULL)
2322  return;
2323 
2324  while (nindexes--)
2325  {
2326  Relation ind = Irel[nindexes];
2327 
2328  index_close(ind, lockmode);
2329  }
2330  pfree(Irel);
2331 }
2332 
2333 /*
2334  * vacuum_delay_point --- check for interrupts and cost-based delay.
2335  *
2336  * This should be called in each major loop of VACUUM processing,
2337  * typically once per page processed.
2338  */
2339 void
2341 {
2342  double msec = 0;
2343 
2344  /* Always check for interrupts */
2346 
2347  if (InterruptPending ||
2349  return;
2350 
2351  /*
2352  * Autovacuum workers should reload the configuration file if requested.
2353  * This allows changes to [autovacuum_]vacuum_cost_limit and
2354  * [autovacuum_]vacuum_cost_delay to take effect while a table is being
2355  * vacuumed or analyzed.
2356  */
2358  {
2359  ConfigReloadPending = false;
2362  }
2363 
2364  /*
2365  * If we disabled cost-based delays after reloading the config file,
2366  * return.
2367  */
2368  if (!VacuumCostActive)
2369  return;
2370 
2371  /*
2372  * For parallel vacuum, the delay is computed based on the shared cost
2373  * balance. See compute_parallel_delay.
2374  */
2375  if (VacuumSharedCostBalance != NULL)
2376  msec = compute_parallel_delay();
2379 
2380  /* Nap if appropriate */
2381  if (msec > 0)
2382  {
2383  if (msec > vacuum_cost_delay * 4)
2384  msec = vacuum_cost_delay * 4;
2385 
2386  pgstat_report_wait_start(WAIT_EVENT_VACUUM_DELAY);
2387  pg_usleep(msec * 1000);
2389 
2390  /*
2391  * We don't want to ignore postmaster death during very long vacuums
2392  * with vacuum_cost_delay configured. We can't use the usual
2393  * WaitLatch() approach here because we want microsecond-based sleep
2394  * durations above.
2395  */
2397  exit(1);
2398 
2399  VacuumCostBalance = 0;
2400 
2401  /*
2402  * Balance and update limit values for autovacuum workers. We must do
2403  * this periodically, as the number of workers across which we are
2404  * balancing the limit may have changed.
2405  *
2406  * TODO: There may be better criteria for determining when to do this
2407  * besides "check after napping".
2408  */
2410 
2411  /* Might have gotten an interrupt while sleeping */
2413  }
2414 }
2415 
2416 /*
2417  * Computes the vacuum delay for parallel workers.
2418  *
2419  * The basic idea of a cost-based delay for parallel vacuum is to allow each
2420  * worker to sleep in proportion to the share of work it's done. We achieve this
2421  * by allowing all parallel vacuum workers including the leader process to
2422  * have a shared view of cost related parameters (mainly VacuumCostBalance).
2423  * We allow each worker to update it as and when it has incurred any cost and
2424  * then based on that decide whether it needs to sleep. We compute the time
2425  * to sleep for a worker based on the cost it has incurred
2426  * (VacuumCostBalanceLocal) and then reduce the VacuumSharedCostBalance by
2427  * that amount. This avoids putting to sleep those workers which have done less
2428  * I/O than other workers and therefore ensure that workers
2429  * which are doing more I/O got throttled more.
2430  *
2431  * We allow a worker to sleep only if it has performed I/O above a certain
2432  * threshold, which is calculated based on the number of active workers
2433  * (VacuumActiveNWorkers), and the overall cost balance is more than
2434  * VacuumCostLimit set by the system. Testing reveals that we achieve
2435  * the required throttling if we force a worker that has done more than 50%
2436  * of its share of work to sleep.
2437  */
2438 static double
2440 {
2441  double msec = 0;
2442  uint32 shared_balance;
2443  int nworkers;
2444 
2445  /* Parallel vacuum must be active */
2447 
2449 
2450  /* At least count itself */
2451  Assert(nworkers >= 1);
2452 
2453  /* Update the shared cost balance value atomically */
2455 
2456  /* Compute the total local balance for the current worker */
2458 
2459  if ((shared_balance >= vacuum_cost_limit) &&
2460  (VacuumCostBalanceLocal > 0.5 * ((double) vacuum_cost_limit / nworkers)))
2461  {
2462  /* Compute sleep time based on the local cost balance */
2466  }
2467 
2468  /*
2469  * Reset the local balance as we accumulated it into the shared value.
2470  */
2471  VacuumCostBalance = 0;
2472 
2473  return msec;
2474 }
2475 
2476 /*
2477  * A wrapper function of defGetBoolean().
2478  *
2479  * This function returns VACOPTVALUE_ENABLED and VACOPTVALUE_DISABLED instead
2480  * of true and false.
2481  */
2482 static VacOptValue
2484 {
2486 }
2487 
2488 /*
2489  * vac_bulkdel_one_index() -- bulk-deletion for index relation.
2490  *
2491  * Returns bulk delete stats derived from input stats
2492  */
2495  TidStore *dead_items, VacDeadItemsInfo *dead_items_info)
2496 {
2497  /* Do bulk deletion */
2498  istat = index_bulk_delete(ivinfo, istat, vac_tid_reaped,
2499  (void *) dead_items);
2500 
2501  ereport(ivinfo->message_level,
2502  (errmsg("scanned index \"%s\" to remove %lld row versions",
2503  RelationGetRelationName(ivinfo->index),
2504  (long long) dead_items_info->num_items)));
2505 
2506  return istat;
2507 }
2508 
2509 /*
2510  * vac_cleanup_one_index() -- do post-vacuum cleanup for index relation.
2511  *
2512  * Returns bulk delete stats derived from input stats
2513  */
2516 {
2517  istat = index_vacuum_cleanup(ivinfo, istat);
2518 
2519  if (istat)
2520  ereport(ivinfo->message_level,
2521  (errmsg("index \"%s\" now contains %.0f row versions in %u pages",
2522  RelationGetRelationName(ivinfo->index),
2523  istat->num_index_tuples,
2524  istat->num_pages),
2525  errdetail("%.0f index row versions were removed.\n"
2526  "%u index pages were newly deleted.\n"
2527  "%u index pages are currently deleted, of which %u are currently reusable.",
2528  istat->tuples_removed,
2529  istat->pages_newly_deleted,
2530  istat->pages_deleted, istat->pages_free)));
2531 
2532  return istat;
2533 }
2534 
2535 /*
2536  * vac_tid_reaped() -- is a particular tid deletable?
2537  *
2538  * This has the right signature to be an IndexBulkDeleteCallback.
2539  */
2540 static bool
2542 {
2543  TidStore *dead_items = (TidStore *) state;
2544 
2545  return TidStoreIsMember(dead_items, itemptr);
2546 }
@ ACLCHECK_OK
Definition: acl.h:183
bool object_ownercheck(Oid classid, Oid objectid, Oid roleid)
Definition: aclchk.c:4142
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4091
static uint32 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:432
static uint32 pg_atomic_add_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:417
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:232
void VacuumUpdateCosts(void)
Definition: autovacuum.c:1634
int autovacuum_multixact_freeze_max_age
Definition: autovacuum.c:128
int autovacuum_freeze_max_age
Definition: autovacuum.c:127
void AutoVacuumUpdateCostLimit(void)
Definition: autovacuum.c:1703
#define MAX_PARALLEL_WORKER_LIMIT
uint32 BlockNumber
Definition: block.h:31
@ BAS_VACUUM
Definition: bufmgr.h:39
#define NameStr(name)
Definition: c.h:746
unsigned int uint32
Definition: c.h:506
#define Min(x, y)
Definition: c.h:1004
signed int int32
Definition: c.h:494
#define Max(x, y)
Definition: c.h:998
#define Assert(condition)
Definition: c.h:858
TransactionId MultiXactId
Definition: c.h:662
uint32 bits32
Definition: c.h:515
float float4
Definition: c.h:629
uint32 TransactionId
Definition: c.h:652
#define OidIsValid(objectId)
Definition: c.h:775
void TruncateCLOG(TransactionId oldestXact, Oid oldestxid_datoid)
Definition: clog.c:1000
void cluster_rel(Oid tableOid, Oid indexOid, ClusterParams *params)
Definition: cluster.c:311
#define CLUOPT_VERBOSE
Definition: cluster.h:23
void analyze_rel(Oid relid, RangeVar *relation, VacuumParams *params, List *va_cols, bool in_outer_xact, BufferAccessStrategy bstrategy)
Definition: analyze.c:111
void AdvanceOldestCommitTsXid(TransactionId oldestXact)
Definition: commit_ts.c:936
void TruncateCommitTs(TransactionId oldestXact)
Definition: commit_ts.c:883
bool database_is_invalid_form(Form_pg_database datform)
Definition: dbcommands.c:3190
int32 defGetInt32(DefElem *def)
Definition: define.c:162
bool defGetBoolean(DefElem *def)
Definition: define.c:107
char * defGetString(DefElem *def)
Definition: define.c:48
struct cursor * cur
Definition: ecpg.c:28
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1155
int errdetail(const char *fmt,...)
Definition: elog.c:1201
int errhint(const char *fmt,...)
Definition: elog.c:1315
int errcode(int sqlerrcode)
Definition: elog.c:855
int errmsg(const char *fmt,...)
Definition: elog.c:1068
#define _(x)
Definition: elog.c:90
#define LOG
Definition: elog.h:31
#define PG_TRY(...)
Definition: elog.h:370
#define WARNING
Definition: elog.h:36
#define DEBUG2
Definition: elog.h:29
#define PG_END_TRY(...)
Definition: elog.h:395
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define PG_FINALLY(...)
Definition: elog.h:387
#define ereport(elevel,...)
Definition: elog.h:149
BufferAccessStrategy GetAccessStrategyWithSize(BufferAccessStrategyType btype, int ring_size_kb)
Definition: freelist.c:584
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:596
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:503
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:384
volatile sig_atomic_t InterruptPending
Definition: globals.c:31
int64 VacuumPageHit
Definition: globals.c:155
int64 VacuumPageMiss
Definition: globals.c:156
bool VacuumCostActive
Definition: globals.c:160
bool IsUnderPostmaster
Definition: globals.c:118
int64 VacuumPageDirty
Definition: globals.c:157
int VacuumCostBalance
Definition: globals.c:159
int VacuumBufferUsageLimit
Definition: globals.c:147
Oid MyDatabaseId
Definition: globals.c:92
bool parse_int(const char *value, int *result, int flags, const char **hintmsg)
Definition: guc.c:2873
int NewGUCNestLevel(void)
Definition: guc.c:2237
#define newval
void RestrictSearchPath(void)
Definition: guc.c:2248
void AtEOXact_GUC(bool isCommit, int nestLevel)
Definition: guc.c:2264
#define GUC_check_errdetail
Definition: guc.h:447
GucSource
Definition: guc.h:108
@ PGC_SIGHUP
Definition: guc.h:71
#define GUC_UNIT_KB
Definition: guc.h:227
void ProcessConfigFile(GucContext context)
void heap_inplace_update(Relation relation, HeapTuple tuple)
Definition: heapam.c:6063
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1252
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:776
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1434
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
int verbose
IndexBulkDeleteResult * index_vacuum_cleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *istat)
Definition: indexam.c:769
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
IndexBulkDeleteResult * index_bulk_delete(IndexVacuumInfo *info, IndexBulkDeleteResult *istat, IndexBulkDeleteCallback callback, void *callback_state)
Definition: indexam.c:748
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:133
volatile sig_atomic_t ConfigReloadPending
Definition: interrupt.c:27
int i
Definition: isn.c:73
exit(1)
List * lappend(List *list, void *datum)
Definition: list.c:339
void list_free(List *list)
Definition: list.c:1546
List * list_concat(List *list1, const List *list2)
Definition: list.c:561
bool ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode)
Definition: lmgr.c:151
void UnlockRelationOid(Oid relid, LOCKMODE lockmode)
Definition: lmgr.c:227
void LockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:387
void UnlockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:400
void LockDatabaseFrozenIds(LOCKMODE lockmode)
Definition: lmgr.c:487
int LOCKMODE
Definition: lockdefs.h:26
#define NoLock
Definition: lockdefs.h:34
#define AccessExclusiveLock
Definition: lockdefs.h:43
#define AccessShareLock
Definition: lockdefs.h:36
#define ShareUpdateExclusiveLock
Definition: lockdefs.h:39
#define ExclusiveLock
Definition: lockdefs.h:42
#define RowExclusiveLock
Definition: lockdefs.h:38
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1168
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1781
@ LW_EXCLUSIVE
Definition: lwlock.h:114
VacuumRelation * makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols)
Definition: makefuncs.c:832
void pfree(void *pointer)
Definition: mcxt.c:1521
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
void * palloc(Size size)
Definition: mcxt.c:1317
MemoryContext PortalContext
Definition: mcxt.c:158
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
#define AmAutoVacuumWorkerProcess()
Definition: miscadmin.h:375
#define MIN_BAS_VAC_RING_SIZE_KB
Definition: miscadmin.h:276
#define MAX_BAS_VAC_RING_SIZE_KB
Definition: miscadmin.h:277
#define SECURITY_RESTRICTED_OPERATION
Definition: miscadmin.h:315
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
Definition: miscinit.c:635
Oid GetUserId(void)
Definition: miscinit.c:514
void SetUserIdAndSecContext(Oid userid, int sec_context)
Definition: miscinit.c:642
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:3308
bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:3322
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
Definition: multixact.c:2354
MultiXactId GetOldestMultiXactId(void)
Definition: multixact.c:2652
int MultiXactMemberFreezeThreshold(void)
Definition: multixact.c:2970
MultiXactId ReadNextMultiXactId(void)
Definition: multixact.c:770
void TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
Definition: multixact.c:3093
#define MultiXactIdIsValid(multi)
Definition: multixact.h:28
#define FirstMultiXactId
Definition: multixact.h:25
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition: namespace.c:426
@ RVR_SKIP_LOCKED
Definition: namespace.h:74
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
#define ACL_MAINTAIN
Definition: parsenodes.h:90
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:41
NameData relname
Definition: pg_class.h:38
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
FormData_pg_class
Definition: pg_class.h:142
TransactionId datfrozenxid
Definition: pg_database.h:62
TransactionId datminmxid
Definition: pg_database.h:65
FormData_pg_database * Form_pg_database
Definition: pg_database.h:96
FormData_pg_database
Definition: pg_database.h:89
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
Definition: pg_inherits.c:255
#define lfirst(lc)
Definition: pg_list.h:172
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define lfirst_oid(lc)
Definition: pg_list.h:174
static rewind_source * source
Definition: pg_rewind.c:89
#define ERRCODE_UNDEFINED_TABLE
Definition: pgbench.c:78
#define PostmasterIsAlive()
Definition: pmsignal.h:102
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
#define PROC_IN_VACUUM
Definition: proc.h:58
#define PROC_VACUUM_FOR_WRAPAROUND
Definition: proc.h:60
TransactionId GetOldestNonRemovableTransactionId(Relation rel)
Definition: procarray.c:2005
MemoryContextSwitchTo(old_ctx)
static long analyze(struct nfa *nfa)
Definition: regc_nfa.c:3016
#define RelationGetRelid(relation)
Definition: rel.h:505
#define RelationGetRelationName(relation)
Definition: rel.h:539
#define RELATION_IS_OTHER_TEMP(relation)
Definition: rel.h:658
StdRdOptIndexCleanup
Definition: rel.h:330
@ STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO
Definition: rel.h:331
@ STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF
Definition: rel.h:332
@ STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON
Definition: rel.h:333
List * RelationGetIndexList(Relation relation)
Definition: relcache.c:4801
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
@ ForwardScanDirection
Definition: sdir.h:28
void pg_usleep(long microsec)
Definition: signal.c:53
Snapshot GetTransactionSnapshot(void)
Definition: snapmgr.c:216
void PushActiveSnapshot(Snapshot snapshot)
Definition: snapmgr.c:648
bool ActiveSnapshotSet(void)
Definition: snapmgr.c:782
void PopActiveSnapshot(void)
Definition: snapmgr.c:743
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation try_relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:88
PGPROC * MyProc
Definition: proc.c:66
PROC_HDR * ProcGlobal
Definition: proc.c:78
#define BTEqualStrategyNumber
Definition: stratnum.h:31
bits32 options
Definition: cluster.h:30
char * defname
Definition: parsenodes.h:815
ParseLoc location
Definition: parsenodes.h:819
Node * arg
Definition: parsenodes.h:816
BlockNumber pages_deleted
Definition: genam.h:82
BlockNumber pages_newly_deleted
Definition: genam.h:81
BlockNumber pages_free
Definition: genam.h:83
BlockNumber num_pages
Definition: genam.h:77
double tuples_removed
Definition: genam.h:80
double num_index_tuples
Definition: genam.h:79
Relation index
Definition: genam.h:46
int message_level
Definition: genam.h:51
Definition: pg_list.h:54
LockRelId lockRelId
Definition: rel.h:46
Definition: rel.h:39
uint8 statusFlags
Definition: proc.h:237
int pgxactoff
Definition: proc.h:179
uint8 * statusFlags
Definition: proc.h:394
char * relname
Definition: primnodes.h:82
LockInfoData rd_lockInfo
Definition: rel.h:114
TriggerDesc * trigdesc
Definition: rel.h:117
Form_pg_index rd_index
Definition: rel.h:192
RuleLock * rd_rules
Definition: rel.h:115
bytea * rd_options
Definition: rel.h:175
Form_pg_class rd_rel
Definition: rel.h:111
int64 num_items
Definition: vacuum.h:288
TransactionId FreezeLimit
Definition: vacuum.h:277
TransactionId OldestXmin
Definition: vacuum.h:267
TransactionId relfrozenxid
Definition: vacuum.h:251
MultiXactId relminmxid
Definition: vacuum.h:252
MultiXactId MultiXactCutoff
Definition: vacuum.h:278
MultiXactId OldestMxact
Definition: vacuum.h:268
int nworkers
Definition: vacuum.h:239
int freeze_table_age
Definition: vacuum.h:221
VacOptValue truncate
Definition: vacuum.h:231
bits32 options
Definition: vacuum.h:219
int freeze_min_age
Definition: vacuum.h:220
bool is_wraparound
Definition: vacuum.h:226
int multixact_freeze_min_age
Definition: vacuum.h:222
int multixact_freeze_table_age
Definition: vacuum.h:224
int log_min_duration
Definition: vacuum.h:227
Oid toast_parent
Definition: vacuum.h:232
VacOptValue index_cleanup
Definition: vacuum.h:230
RangeVar * relation
Definition: parsenodes.h:3860
List * options
Definition: parsenodes.h:3845
bool is_vacuumcmd
Definition: parsenodes.h:3847
List * rels
Definition: parsenodes.h:3846
Definition: regguts.h:323
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:86
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, struct ScanKeyData *key)
Definition: tableam.c:112
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:1019
static void table_relation_vacuum(Relation rel, struct VacuumParams *params, BufferAccessStrategy bstrategy)
Definition: tableam.h:1707
bool TidStoreIsMember(TidStore *ts, ItemPointer tid)
Definition: tidstore.c:432
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
Definition: transam.c:299
static TransactionId ReadNextTransactionId(void)
Definition: transam.h:315
#define FirstNormalTransactionId
Definition: transam.h:34
#define TransactionIdIsValid(xid)
Definition: transam.h:41
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
static bool vac_tid_reaped(ItemPointer itemptr, void *state)
Definition: vacuum.c:2541
void ExecVacuum(ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel)
Definition: vacuum.c:147
IndexBulkDeleteResult * vac_bulkdel_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat, TidStore *dead_items, VacDeadItemsInfo *dead_items_info)
Definition: vacuum.c:2494
pg_atomic_uint32 * VacuumActiveNWorkers
Definition: vacuum.c:103
static void vac_truncate_clog(TransactionId frozenXID, MultiXactId minMulti, TransactionId lastSaneFrozenXid, MultiXactId lastSaneMinMulti)
Definition: vacuum.c:1783
int vacuum_freeze_min_age
Definition: vacuum.c:67
static List * expand_vacuum_rel(VacuumRelation *vrel, MemoryContext vac_context, int options)
Definition: vacuum.c:870
double vacuum_cost_delay
Definition: vacuum.c:80
static double compute_parallel_delay(void)
Definition: vacuum.c:2439
static VacOptValue get_vacoptval_from_boolean(DefElem *def)
Definition: vacuum.c:2483
void vac_open_indexes(Relation relation, LOCKMODE lockmode, int *nindexes, Relation **Irel)
Definition: vacuum.c:2276
void vacuum(List *relations, VacuumParams *params, BufferAccessStrategy bstrategy, MemoryContext vac_context, bool isTopLevel)
Definition: vacuum.c:478
bool check_vacuum_buffer_usage_limit(int *newval, void **extra, GucSource source)
Definition: vacuum.c:125
int VacuumCostBalanceLocal
Definition: vacuum.c:104
static List * get_all_vacuum_rels(MemoryContext vac_context, int options)
Definition: vacuum.c:1010
void vac_update_relstats(Relation relation, BlockNumber num_pages, double num_tuples, BlockNumber num_all_visible_pages, bool hasindex, TransactionId frozenxid, MultiXactId minmulti, bool *frozenxid_updated, bool *minmulti_updated, bool in_outer_xact)
Definition: vacuum.c:1398
int vacuum_multixact_freeze_table_age
Definition: vacuum.c:70
int vacuum_freeze_table_age
Definition: vacuum.c:68
int vacuum_multixact_failsafe_age
Definition: vacuum.c:72
int vacuum_multixact_freeze_min_age
Definition: vacuum.c:69
Relation vacuum_open_relation(Oid relid, RangeVar *relation, bits32 options, bool verbose, LOCKMODE lmode)
Definition: vacuum.c:758
static bool vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params, BufferAccessStrategy bstrategy)
Definition: vacuum.c:1952
void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode)
Definition: vacuum.c:2319
void vacuum_delay_point(void)
Definition: vacuum.c:2340
void vac_update_datfrozenxid(void)
Definition: vacuum.c:1565
bool vacuum_get_cutoffs(Relation rel, const VacuumParams *params, struct VacuumCutoffs *cutoffs)
Definition: vacuum.c:1072
bool vacuum_xid_failsafe_check(const struct VacuumCutoffs *cutoffs)
Definition: vacuum.c:1240
pg_atomic_uint32 * VacuumSharedCostBalance
Definition: vacuum.c:102
bool VacuumFailsafeActive
Definition: vacuum.c:96
int vacuum_cost_limit
Definition: vacuum.c:81
int vacuum_failsafe_age
Definition: vacuum.c:71
double vac_estimate_reltuples(Relation relation, BlockNumber total_pages, BlockNumber scanned_pages, double scanned_tuples)
Definition: vacuum.c:1302
IndexBulkDeleteResult * vac_cleanup_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat)
Definition: vacuum.c:2515
bool vacuum_is_permitted_for_relation(Oid relid, Form_pg_class reltuple, bits32 options)
Definition: vacuum.c:706
#define VACOPT_FREEZE
Definition: vacuum.h:183
#define VACOPT_SKIP_LOCKED
Definition: vacuum.h:185
#define VACOPT_VACUUM
Definition: vacuum.h:180
#define VACOPT_VERBOSE
Definition: vacuum.h:182
#define VACOPT_FULL
Definition: vacuum.h:184
#define VACOPT_SKIP_DATABASE_STATS
Definition: vacuum.h:189
VacOptValue
Definition: vacuum.h:201
@ VACOPTVALUE_AUTO
Definition: vacuum.h:203
@ VACOPTVALUE_ENABLED
Definition: vacuum.h:205
@ VACOPTVALUE_UNSPECIFIED
Definition: vacuum.h:202
@ VACOPTVALUE_DISABLED
Definition: vacuum.h:204
#define VACOPT_PROCESS_TOAST
Definition: vacuum.h:187
#define VACOPT_DISABLE_PAGE_SKIPPING
Definition: vacuum.h:188
#define VACOPT_ONLY_DATABASE_STATS
Definition: vacuum.h:190
#define VACOPT_PROCESS_MAIN
Definition: vacuum.h:186
#define VACOPT_ANALYZE
Definition: vacuum.h:181
void SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
Definition: varsup.c:372
bool ForceTransactionIdLimitUpdate(void)
Definition: varsup.c:517
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:85
static void pgstat_report_wait_end(void)
Definition: wait_event.h:101
bool IsInTransactionBlock(bool isTopLevel)
Definition: xact.c:3753
void CommandCounterIncrement(void)
Definition: xact.c:1098
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3622
void StartTransactionCommand(void)
Definition: xact.c:3033
void CommitTransactionCommand(void)
Definition: xact.c:3131