PostgreSQL Source Code  git master
vacuum.c File Reference
#include "postgres.h"
#include <math.h>
#include "access/clog.h"
#include "access/commit_ts.h"
#include "access/genam.h"
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/multixact.h"
#include "access/tableam.h"
#include "access/transam.h"
#include "access/xact.h"
#include "catalog/index.h"
#include "catalog/namespace.h"
#include "catalog/pg_database.h"
#include "catalog/pg_inherits.h"
#include "commands/cluster.h"
#include "commands/defrem.h"
#include "commands/vacuum.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/bgworker_internals.h"
#include "postmaster/interrupt.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
#include "storage/pmsignal.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/acl.h"
#include "utils/fmgroids.h"
#include "utils/guc.h"
#include "utils/guc_hooks.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
Include dependency graph for vacuum.c:

Go to the source code of this file.

Functions

static Listexpand_vacuum_rel (VacuumRelation *vrel, MemoryContext vac_context, int options)
 
static Listget_all_vacuum_rels (MemoryContext vac_context, int options)
 
static void vac_truncate_clog (TransactionId frozenXID, MultiXactId minMulti, TransactionId lastSaneFrozenXid, MultiXactId lastSaneMinMulti)
 
static bool vacuum_rel (Oid relid, RangeVar *relation, VacuumParams *params, BufferAccessStrategy bstrategy)
 
static double compute_parallel_delay (void)
 
static VacOptValue get_vacoptval_from_boolean (DefElem *def)
 
static bool vac_tid_reaped (ItemPointer itemptr, void *state)
 
bool check_vacuum_buffer_usage_limit (int *newval, void **extra, GucSource source)
 
void ExecVacuum (ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel)
 
void vacuum (List *relations, VacuumParams *params, BufferAccessStrategy bstrategy, MemoryContext vac_context, bool isTopLevel)
 
bool vacuum_is_permitted_for_relation (Oid relid, Form_pg_class reltuple, bits32 options)
 
Relation vacuum_open_relation (Oid relid, RangeVar *relation, bits32 options, bool verbose, LOCKMODE lmode)
 
bool vacuum_get_cutoffs (Relation rel, const VacuumParams *params, struct VacuumCutoffs *cutoffs)
 
bool vacuum_xid_failsafe_check (const struct VacuumCutoffs *cutoffs)
 
double vac_estimate_reltuples (Relation relation, BlockNumber total_pages, BlockNumber scanned_pages, double scanned_tuples)
 
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)
 
void vac_update_datfrozenxid (void)
 
void vac_open_indexes (Relation relation, LOCKMODE lockmode, int *nindexes, Relation **Irel)
 
void vac_close_indexes (int nindexes, Relation *Irel, LOCKMODE lockmode)
 
void vacuum_delay_point (void)
 
IndexBulkDeleteResultvac_bulkdel_one_index (IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat, TidStore *dead_items, VacDeadItemsInfo *dead_items_info)
 
IndexBulkDeleteResultvac_cleanup_one_index (IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat)
 

Variables

int vacuum_freeze_min_age
 
int vacuum_freeze_table_age
 
int vacuum_multixact_freeze_min_age
 
int vacuum_multixact_freeze_table_age
 
int vacuum_failsafe_age
 
int vacuum_multixact_failsafe_age
 
double vacuum_cost_delay = 0
 
int vacuum_cost_limit = 200
 
bool VacuumFailsafeActive = false
 
pg_atomic_uint32VacuumSharedCostBalance = NULL
 
pg_atomic_uint32VacuumActiveNWorkers = NULL
 
int VacuumCostBalanceLocal = 0
 

Function Documentation

◆ check_vacuum_buffer_usage_limit()

bool check_vacuum_buffer_usage_limit ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 125 of file vacuum.c.

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 }
#define newval
#define GUC_check_errdetail
Definition: guc.h:447
#define MIN_BAS_VAC_RING_SIZE_KB
Definition: miscadmin.h:276
#define MAX_BAS_VAC_RING_SIZE_KB
Definition: miscadmin.h:277

References GUC_check_errdetail, MAX_BAS_VAC_RING_SIZE_KB, MIN_BAS_VAC_RING_SIZE_KB, and newval.

◆ compute_parallel_delay()

static double compute_parallel_delay ( void  )
static

Definition at line 2439 of file vacuum.c.

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 }
static uint32 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:434
static uint32 pg_atomic_add_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:419
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:234
unsigned int uint32
Definition: c.h:506
#define Assert(condition)
Definition: c.h:858
int VacuumCostBalance
Definition: globals.c:158
pg_atomic_uint32 * VacuumActiveNWorkers
Definition: vacuum.c:103
double vacuum_cost_delay
Definition: vacuum.c:80
int VacuumCostBalanceLocal
Definition: vacuum.c:104
pg_atomic_uint32 * VacuumSharedCostBalance
Definition: vacuum.c:102
int vacuum_cost_limit
Definition: vacuum.c:81

References Assert, pg_atomic_add_fetch_u32(), pg_atomic_read_u32(), pg_atomic_sub_fetch_u32(), vacuum_cost_delay, vacuum_cost_limit, VacuumActiveNWorkers, VacuumCostBalance, VacuumCostBalanceLocal, and VacuumSharedCostBalance.

Referenced by vacuum_delay_point().

◆ ExecVacuum()

void ExecVacuum ( ParseState pstate,
VacuumStmt vacstmt,
bool  isTopLevel 
)

Definition at line 147 of file vacuum.c.

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 }
#define MAX_PARALLEL_WORKER_LIMIT
@ BAS_VACUUM
Definition: bufmgr.h:39
int32 defGetInt32(DefElem *def)
Definition: define.c:162
bool defGetBoolean(DefElem *def)
Definition: define.c:107
char * defGetString(DefElem *def)
Definition: define.c:48
int errhint(const char *fmt,...)
Definition: elog.c:1317
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define _(x)
Definition: elog.c:90
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
BufferAccessStrategy GetAccessStrategyWithSize(BufferAccessStrategyType btype, int ring_size_kb)
Definition: freelist.c:584
int VacuumBufferUsageLimit
Definition: globals.c:146
bool parse_int(const char *value, int *result, int flags, const char **hintmsg)
Definition: guc.c:2873
#define GUC_UNIT_KB
Definition: guc.h:227
int verbose
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
MemoryContext PortalContext
Definition: mcxt.c:158
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
#define lfirst(lc)
Definition: pg_list.h:172
#define lfirst_node(type, lc)
Definition: pg_list.h:176
#define NIL
Definition: pg_list.h:68
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
#define InvalidOid
Definition: postgres_ext.h:36
MemoryContextSwitchTo(old_ctx)
static long analyze(struct nfa *nfa)
Definition: regc_nfa.c:3016
char * defname
Definition: parsenodes.h:815
ParseLoc location
Definition: parsenodes.h:819
Node * arg
Definition: parsenodes.h:816
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
List * options
Definition: parsenodes.h:3845
bool is_vacuumcmd
Definition: parsenodes.h:3847
List * rels
Definition: parsenodes.h:3846
static VacOptValue get_vacoptval_from_boolean(DefElem *def)
Definition: vacuum.c:2483
void vacuum(List *relations, VacuumParams *params, BufferAccessStrategy bstrategy, MemoryContext vac_context, bool isTopLevel)
Definition: vacuum.c:478
#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_AUTO
Definition: vacuum.h:203
@ VACOPTVALUE_UNSPECIFIED
Definition: vacuum.h:202
#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

References _, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, analyze(), DefElem::arg, Assert, BAS_VACUUM, defGetBoolean(), defGetInt32(), defGetString(), DefElem::defname, ereport, errcode(), errhint(), errmsg(), ERROR, VacuumParams::freeze_min_age, VacuumParams::freeze_table_age, get_vacoptval_from_boolean(), GetAccessStrategyWithSize(), GUC_UNIT_KB, VacuumParams::index_cleanup, InvalidOid, VacuumStmt::is_vacuumcmd, VacuumParams::is_wraparound, lfirst, lfirst_node, DefElem::location, VacuumParams::log_min_duration, MAX_BAS_VAC_RING_SIZE_KB, MAX_PARALLEL_WORKER_LIMIT, MemoryContextDelete(), MemoryContextSwitchTo(), MIN_BAS_VAC_RING_SIZE_KB, VacuumParams::multixact_freeze_min_age, VacuumParams::multixact_freeze_table_age, NIL, VacuumParams::nworkers, VacuumParams::options, VacuumStmt::options, parse_int(), parser_errposition(), pg_strcasecmp(), PortalContext, VacuumStmt::rels, VacuumParams::toast_parent, VacuumParams::truncate, VacuumRelation::va_cols, VACOPT_ANALYZE, VACOPT_DISABLE_PAGE_SKIPPING, VACOPT_FREEZE, VACOPT_FULL, VACOPT_ONLY_DATABASE_STATS, VACOPT_PROCESS_MAIN, VACOPT_PROCESS_TOAST, VACOPT_SKIP_DATABASE_STATS, VACOPT_SKIP_LOCKED, VACOPT_VACUUM, VACOPT_VERBOSE, VACOPTVALUE_AUTO, VACOPTVALUE_UNSPECIFIED, vacuum(), VacuumBufferUsageLimit, and verbose.

Referenced by standard_ProcessUtility().

◆ expand_vacuum_rel()

static List * expand_vacuum_rel ( VacuumRelation vrel,
MemoryContext  vac_context,
int  options 
)
static

Definition at line 870 of file vacuum.c.

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 }
#define OidIsValid(objectId)
Definition: c.h:775
#define WARNING
Definition: elog.h:36
#define elog(elevel,...)
Definition: elog.h:224
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
List * lappend(List *list, void *datum)
Definition: list.c:339
void UnlockRelationOid(Oid relid, LOCKMODE lockmode)
Definition: lmgr.c:227
#define NoLock
Definition: lockdefs.h:34
#define AccessShareLock
Definition: lockdefs.h:36
VacuumRelation * makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols)
Definition: makefuncs.c:832
#define AmAutoVacuumWorkerProcess()
Definition: miscadmin.h:375
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
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
Definition: pg_inherits.c:255
#define lfirst_oid(lc)
Definition: pg_list.h:174
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
unsigned int Oid
Definition: postgres_ext.h:31
Definition: pg_list.h:54
char * relname
Definition: primnodes.h:82
RangeVar * relation
Definition: parsenodes.h:3860
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218
bool vacuum_is_permitted_for_relation(Oid relid, Form_pg_class reltuple, bits32 options)
Definition: vacuum.c:706

References AccessShareLock, AmAutoVacuumWorkerProcess, Assert, elog, ereport, errcode(), errmsg(), ERROR, find_all_inheritors(), GETSTRUCT, HeapTupleIsValid, lappend(), lfirst_oid, makeVacuumRelation(), MemoryContextSwitchTo(), NIL, NoLock, ObjectIdGetDatum(), VacuumRelation::oid, OidIsValid, RangeVarGetRelidExtended(), VacuumRelation::relation, ReleaseSysCache(), RangeVar::relname, RVR_SKIP_LOCKED, SearchSysCache1(), UnlockRelationOid(), VacuumRelation::va_cols, VACOPT_SKIP_LOCKED, VACOPT_VACUUM, vacuum_is_permitted_for_relation(), and WARNING.

Referenced by vacuum().

◆ get_all_vacuum_rels()

static List * get_all_vacuum_rels ( MemoryContext  vac_context,
int  options 
)
static

Definition at line 1010 of file vacuum.c.

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 }
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1251
@ ForwardScanDirection
Definition: sdir.h:28
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:1029

References AccessShareLock, ForwardScanDirection, GETSTRUCT, heap_getnext(), lappend(), makeVacuumRelation(), MemoryContextSwitchTo(), NIL, table_beginscan_catalog(), table_close(), table_endscan(), table_open(), and vacuum_is_permitted_for_relation().

Referenced by vacuum().

◆ get_vacoptval_from_boolean()

static VacOptValue get_vacoptval_from_boolean ( DefElem def)
static

Definition at line 2483 of file vacuum.c.

2484 {
2486 }
@ VACOPTVALUE_ENABLED
Definition: vacuum.h:205
@ VACOPTVALUE_DISABLED
Definition: vacuum.h:204

References defGetBoolean(), VACOPTVALUE_DISABLED, and VACOPTVALUE_ENABLED.

Referenced by ExecVacuum().

◆ vac_bulkdel_one_index()

IndexBulkDeleteResult* vac_bulkdel_one_index ( IndexVacuumInfo ivinfo,
IndexBulkDeleteResult istat,
TidStore dead_items,
VacDeadItemsInfo dead_items_info 
)

Definition at line 2494 of file vacuum.c.

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 }
IndexBulkDeleteResult * index_bulk_delete(IndexVacuumInfo *info, IndexBulkDeleteResult *istat, IndexBulkDeleteCallback callback, void *callback_state)
Definition: indexam.c:748
#define RelationGetRelationName(relation)
Definition: rel.h:539
Relation index
Definition: genam.h:46
int message_level
Definition: genam.h:51
int64 num_items
Definition: vacuum.h:288
static bool vac_tid_reaped(ItemPointer itemptr, void *state)
Definition: vacuum.c:2541

References ereport, errmsg(), IndexVacuumInfo::index, index_bulk_delete(), IndexVacuumInfo::message_level, VacDeadItemsInfo::num_items, RelationGetRelationName, and vac_tid_reaped().

Referenced by lazy_vacuum_one_index(), and parallel_vacuum_process_one_index().

◆ vac_cleanup_one_index()

IndexBulkDeleteResult* vac_cleanup_one_index ( IndexVacuumInfo ivinfo,
IndexBulkDeleteResult istat 
)

Definition at line 2515 of file vacuum.c.

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 }
int errdetail(const char *fmt,...)
Definition: elog.c:1203
IndexBulkDeleteResult * index_vacuum_cleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *istat)
Definition: indexam.c:769
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

References ereport, errdetail(), errmsg(), IndexVacuumInfo::index, index_vacuum_cleanup(), IndexVacuumInfo::message_level, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, IndexBulkDeleteResult::pages_deleted, IndexBulkDeleteResult::pages_free, IndexBulkDeleteResult::pages_newly_deleted, RelationGetRelationName, and IndexBulkDeleteResult::tuples_removed.

Referenced by lazy_cleanup_one_index(), and parallel_vacuum_process_one_index().

◆ vac_close_indexes()

void vac_close_indexes ( int  nindexes,
Relation Irel,
LOCKMODE  lockmode 
)

Definition at line 2319 of file vacuum.c.

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 }
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
void pfree(void *pointer)
Definition: mcxt.c:1520

References index_close(), and pfree().

Referenced by do_analyze_rel(), heap_vacuum_rel(), and parallel_vacuum_main().

◆ vac_estimate_reltuples()

double vac_estimate_reltuples ( Relation  relation,
BlockNumber  total_pages,
BlockNumber  scanned_pages,
double  scanned_tuples 
)

Definition at line 1302 of file vacuum.c.

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 }
uint32 BlockNumber
Definition: block.h:31
Form_pg_class rd_rel
Definition: rel.h:111

References RelationData::rd_rel.

Referenced by lazy_scan_heap(), and statapprox_heap().

◆ vac_open_indexes()

void vac_open_indexes ( Relation  relation,
LOCKMODE  lockmode,
int *  nindexes,
Relation **  Irel 
)

Definition at line 2276 of file vacuum.c.

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 }
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:133
int i
Definition: isn.c:73
void list_free(List *list)
Definition: list.c:1546
void * palloc(Size size)
Definition: mcxt.c:1316
static int list_length(const List *l)
Definition: pg_list.h:152
List * RelationGetIndexList(Relation relation)
Definition: relcache.c:4800
Form_pg_index rd_index
Definition: rel.h:192

References Assert, i, index_close(), index_open(), lfirst_oid, list_free(), list_length(), NoLock, palloc(), RelationData::rd_index, and RelationGetIndexList().

Referenced by do_analyze_rel(), heap_vacuum_rel(), and parallel_vacuum_main().

◆ vac_tid_reaped()

static bool vac_tid_reaped ( ItemPointer  itemptr,
void *  state 
)
static

Definition at line 2541 of file vacuum.c.

2542 {
2543  TidStore *dead_items = (TidStore *) state;
2544 
2545  return TidStoreIsMember(dead_items, itemptr);
2546 }
Definition: regguts.h:323
bool TidStoreIsMember(TidStore *ts, ItemPointer tid)
Definition: tidstore.c:432

References TidStoreIsMember().

Referenced by vac_bulkdel_one_index().

◆ vac_truncate_clog()

static void vac_truncate_clog ( TransactionId  frozenXID,
MultiXactId  minMulti,
TransactionId  lastSaneFrozenXid,
MultiXactId  lastSaneMinMulti 
)
static

Definition at line 1783 of file vacuum.c.

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 }
#define NameStr(name)
Definition: c.h:746
uint32 TransactionId
Definition: c.h:652
void TruncateCLOG(TransactionId oldestXact, Oid oldestxid_datoid)
Definition: clog.c:1000
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:3178
#define DEBUG2
Definition: elog.h:29
Oid MyDatabaseId
Definition: globals.c:91
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1170
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1783
@ LW_EXCLUSIVE
Definition: lwlock.h:114
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:3267
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid, bool is_startup)
Definition: multixact.c:2313
void TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
Definition: multixact.c:3052
#define MultiXactIdIsValid(multi)
Definition: multixact.h:28
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
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
static TransactionId ReadNextTransactionId(void)
Definition: transam.h:315
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
void SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
Definition: varsup.c:372

References AccessShareLock, AdvanceOldestCommitTsXid(), Assert, database_is_invalid_form(), datfrozenxid, datminmxid, DEBUG2, elog, ereport, errdetail(), errmsg(), FormData_pg_database, ForwardScanDirection, GETSTRUCT, heap_getnext(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MultiXactIdPrecedes(), MyDatabaseId, NameStr, ReadNextTransactionId(), SetMultiXactIdLimit(), SetTransactionIdLimit(), table_beginscan_catalog(), table_close(), table_endscan(), table_open(), TransactionIdIsNormal, TransactionIdPrecedes(), TruncateCLOG(), TruncateCommitTs(), TruncateMultiXact(), and WARNING.

Referenced by vac_update_datfrozenxid().

◆ vac_update_datfrozenxid()

void vac_update_datfrozenxid ( void  )

Definition at line 1565 of file vacuum.c.

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 }
TransactionId MultiXactId
Definition: c.h:662
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
void heap_inplace_update(Relation relation, HeapTuple tuple)
Definition: heapam.c:6062
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:776
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1434
void LockDatabaseFrozenIds(LOCKMODE lockmode)
Definition: lmgr.c:497
#define ExclusiveLock
Definition: lockdefs.h:42
#define RowExclusiveLock
Definition: lockdefs.h:38
MultiXactId GetOldestMultiXactId(void)
Definition: multixact.c:2611
MultiXactId ReadNextMultiXactId(void)
Definition: multixact.c:729
FormData_pg_class
Definition: pg_class.h:142
TransactionId GetOldestNonRemovableTransactionId(Relation rel)
Definition: procarray.c:1993
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
#define BTEqualStrategyNumber
Definition: stratnum.h:31
#define TransactionIdIsValid(xid)
Definition: transam.h:41
static void vac_truncate_clog(TransactionId frozenXID, MultiXactId minMulti, TransactionId lastSaneFrozenXid, MultiXactId lastSaneMinMulti)
Definition: vacuum.c:1783
bool ForceTransactionIdLimitUpdate(void)
Definition: varsup.c:517

References AccessShareLock, Assert, BTEqualStrategyNumber, elog, ERROR, ExclusiveLock, ForceTransactionIdLimitUpdate(), FormData_pg_class, GetOldestMultiXactId(), GetOldestNonRemovableTransactionId(), GETSTRUCT, heap_copytuple(), heap_freetuple(), heap_inplace_update(), HeapTupleIsValid, InvalidOid, sort-test::key, LockDatabaseFrozenIds(), MultiXactIdIsValid, MultiXactIdPrecedes(), MyDatabaseId, ObjectIdGetDatum(), ReadNextMultiXactId(), ReadNextTransactionId(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), and vac_truncate_clog().

Referenced by do_autovacuum(), and vacuum().

◆ vac_update_relstats()

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 at line 1398 of file vacuum.c.

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 }
signed int int32
Definition: c.h:494
float float4
Definition: c.h:629
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:41
#define RelationGetRelid(relation)
Definition: rel.h:505
TriggerDesc * trigdesc
Definition: rel.h:117
RuleLock * rd_rules
Definition: rel.h:115
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:86

References elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, GETSTRUCT, heap_inplace_update(), HeapTupleIsValid, MultiXactIdIsValid, MultiXactIdPrecedes(), ObjectIdGetDatum(), RelationData::rd_rules, ReadNextMultiXactId(), ReadNextTransactionId(), RelationGetRelationName, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, table_close(), table_open(), TransactionIdIsNormal, TransactionIdPrecedes(), RelationData::trigdesc, and WARNING.

Referenced by do_analyze_rel(), heap_vacuum_rel(), and update_relstats_all_indexes().

◆ vacuum()

void vacuum ( List relations,
VacuumParams params,
BufferAccessStrategy  bstrategy,
MemoryContext  vac_context,
bool  isTopLevel 
)

Definition at line 478 of file vacuum.c.

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 }
void VacuumUpdateCosts(void)
Definition: autovacuum.c:1633
void analyze_rel(Oid relid, RangeVar *relation, VacuumParams *params, List *va_cols, bool in_outer_xact, BufferAccessStrategy bstrategy)
Definition: analyze.c:111
struct cursor * cur
Definition: ecpg.c:28
#define PG_TRY(...)
Definition: elog.h:370
#define PG_END_TRY(...)
Definition: elog.h:395
#define PG_FINALLY(...)
Definition: elog.h:387
int64 VacuumPageHit
Definition: globals.c:154
int64 VacuumPageMiss
Definition: globals.c:155
bool VacuumCostActive
Definition: globals.c:159
int64 VacuumPageDirty
Definition: globals.c:156
List * list_concat(List *list1, const List *list2)
Definition: list.c:561
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
static List * expand_vacuum_rel(VacuumRelation *vrel, MemoryContext vac_context, int options)
Definition: vacuum.c:870
static List * get_all_vacuum_rels(MemoryContext vac_context, int options)
Definition: vacuum.c:1010
static bool vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params, BufferAccessStrategy bstrategy)
Definition: vacuum.c:1952
void vac_update_datfrozenxid(void)
Definition: vacuum.c:1565
bool VacuumFailsafeActive
Definition: vacuum.c:96
bool IsInTransactionBlock(bool isTopLevel)
Definition: xact.c:3715
void CommandCounterIncrement(void)
Definition: xact.c:1097
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3584
void StartTransactionCommand(void)
Definition: xact.c:2995
void CommitTransactionCommand(void)
Definition: xact.c:3093

References ActiveSnapshotSet(), AmAutoVacuumWorkerProcess, analyze_rel(), Assert, CommandCounterIncrement(), CommitTransactionCommand(), cur, ereport, errcode(), errmsg(), ERROR, expand_vacuum_rel(), get_all_vacuum_rels(), GetTransactionSnapshot(), IsInTransactionBlock(), lfirst_node, list_concat(), list_length(), MemoryContextSwitchTo(), NIL, VacuumRelation::oid, VacuumParams::options, PG_END_TRY, PG_FINALLY, PG_TRY, PopActiveSnapshot(), PreventInTransactionBlock(), PushActiveSnapshot(), VacuumRelation::relation, StartTransactionCommand(), VacuumRelation::va_cols, vac_update_datfrozenxid(), VACOPT_ANALYZE, VACOPT_ONLY_DATABASE_STATS, VACOPT_SKIP_DATABASE_STATS, VACOPT_VACUUM, vacuum_rel(), VacuumActiveNWorkers, VacuumCostActive, VacuumCostBalance, VacuumCostBalanceLocal, VacuumFailsafeActive, VacuumPageDirty, VacuumPageHit, VacuumPageMiss, VacuumSharedCostBalance, and VacuumUpdateCosts().

Referenced by autovacuum_do_vac_analyze(), ExecVacuum(), parallel_vacuum_index_is_parallel_safe(), and parallel_vacuum_process_all_indexes().

◆ vacuum_delay_point()

void vacuum_delay_point ( void  )

Definition at line 2340 of file vacuum.c.

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 }
void AutoVacuumUpdateCostLimit(void)
Definition: autovacuum.c:1702
volatile sig_atomic_t InterruptPending
Definition: globals.c:30
bool IsUnderPostmaster
Definition: globals.c:117
@ PGC_SIGHUP
Definition: guc.h:71
void ProcessConfigFile(GucContext context)
volatile sig_atomic_t ConfigReloadPending
Definition: interrupt.c:27
exit(1)
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
#define PostmasterIsAlive()
Definition: pmsignal.h:102
void pg_usleep(long microsec)
Definition: signal.c:53
static double compute_parallel_delay(void)
Definition: vacuum.c:2439
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:82
static void pgstat_report_wait_end(void)
Definition: wait_event.h:98

References AmAutoVacuumWorkerProcess, AutoVacuumUpdateCostLimit(), CHECK_FOR_INTERRUPTS, compute_parallel_delay(), ConfigReloadPending, exit(), InterruptPending, IsUnderPostmaster, pg_usleep(), PGC_SIGHUP, pgstat_report_wait_end(), pgstat_report_wait_start(), PostmasterIsAlive, ProcessConfigFile(), vacuum_cost_delay, vacuum_cost_limit, VacuumCostActive, VacuumCostBalance, VacuumSharedCostBalance, and VacuumUpdateCosts().

Referenced by acquire_sample_rows(), blbulkdelete(), blvacuumcleanup(), btvacuumpage(), compute_array_stats(), compute_distinct_stats(), compute_index_stats(), compute_range_stats(), compute_scalar_stats(), compute_trivial_stats(), compute_tsvector_stats(), file_acquire_sample_rows(), ginbulkdelete(), ginInsertCleanup(), ginvacuumcleanup(), gistvacuumpage(), hashbucketcleanup(), lazy_scan_heap(), lazy_vacuum_heap_rel(), spgprocesspending(), and spgvacuumpage().

◆ vacuum_get_cutoffs()

bool vacuum_get_cutoffs ( Relation  rel,
const VacuumParams params,
struct VacuumCutoffs cutoffs 
)

Definition at line 1072 of file vacuum.c.

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 }
int autovacuum_freeze_max_age
Definition: autovacuum.c:126
#define Min(x, y)
Definition: c.h:1004
bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:3281
int MultiXactMemberFreezeThreshold(void)
Definition: multixact.c:2929
#define FirstMultiXactId
Definition: multixact.h:25
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
bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
Definition: transam.c:299
#define FirstNormalTransactionId
Definition: transam.h:34
int vacuum_freeze_min_age
Definition: vacuum.c:67
int vacuum_multixact_freeze_table_age
Definition: vacuum.c:70
int vacuum_freeze_table_age
Definition: vacuum.c:68
int vacuum_multixact_freeze_min_age
Definition: vacuum.c:69

References Assert, autovacuum_freeze_max_age, ereport, errhint(), errmsg(), FirstMultiXactId, FirstNormalTransactionId, VacuumParams::freeze_min_age, VacuumParams::freeze_table_age, VacuumCutoffs::FreezeLimit, GetOldestMultiXactId(), GetOldestNonRemovableTransactionId(), Min, VacuumParams::multixact_freeze_min_age, VacuumParams::multixact_freeze_table_age, VacuumCutoffs::MultiXactCutoff, MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactIdPrecedesOrEquals(), MultiXactMemberFreezeThreshold(), VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, RelationData::rd_rel, ReadNextMultiXactId(), ReadNextTransactionId(), VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, TransactionIdIsNormal, TransactionIdPrecedes(), TransactionIdPrecedesOrEquals(), vacuum_freeze_min_age, vacuum_freeze_table_age, vacuum_multixact_freeze_min_age, vacuum_multixact_freeze_table_age, and WARNING.

Referenced by copy_table_data(), and heap_vacuum_rel().

◆ vacuum_is_permitted_for_relation()

bool vacuum_is_permitted_for_relation ( Oid  relid,
Form_pg_class  reltuple,
bits32  options 
)

Definition at line 706 of file vacuum.c.

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 }
@ ACLCHECK_OK
Definition: acl.h:183
bool object_ownercheck(Oid classid, Oid objectid, Oid roleid)
Definition: aclchk.c:4144
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4093
Oid GetUserId(void)
Definition: miscinit.c:514
#define ACL_MAINTAIN
Definition: parsenodes.h:90
NameData relname
Definition: pg_class.h:38

References ACL_MAINTAIN, ACLCHECK_OK, Assert, ereport, errmsg(), GetUserId(), MyDatabaseId, NameStr, object_ownercheck(), pg_class_aclcheck(), relname, VACOPT_ANALYZE, VACOPT_VACUUM, and WARNING.

Referenced by analyze_rel(), expand_vacuum_rel(), get_all_vacuum_rels(), and vacuum_rel().

◆ vacuum_open_relation()

Relation vacuum_open_relation ( Oid  relid,
RangeVar relation,
bits32  options,
bool  verbose,
LOCKMODE  lmode 
)

Definition at line 758 of file vacuum.c.

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 }
#define LOG
Definition: elog.h:31
bool ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode)
Definition: lmgr.c:151
#define ERRCODE_UNDEFINED_TABLE
Definition: pgbench.c:78
Relation try_relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:88

References AmAutoVacuumWorkerProcess, Assert, ConditionalLockRelationOid(), ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), LOG, NoLock, RangeVar::relname, try_relation_open(), VACOPT_ANALYZE, VACOPT_SKIP_LOCKED, VACOPT_VACUUM, verbose, and WARNING.

Referenced by analyze_rel(), and vacuum_rel().

◆ vacuum_rel()

static bool vacuum_rel ( Oid  relid,
RangeVar relation,
VacuumParams params,
BufferAccessStrategy  bstrategy 
)
static

Definition at line 1952 of file vacuum.c.

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 }
void cluster_rel(Oid tableOid, Oid indexOid, ClusterParams *params)
Definition: cluster.c:311
#define CLUOPT_VERBOSE
Definition: cluster.h:23
int NewGUCNestLevel(void)
Definition: guc.c:2237
void RestrictSearchPath(void)
Definition: guc.c:2248
void AtEOXact_GUC(bool isCommit, int nestLevel)
Definition: guc.c:2264
void LockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:397
void UnlockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:410
int LOCKMODE
Definition: lockdefs.h:26
#define AccessExclusiveLock
Definition: lockdefs.h:43
#define ShareUpdateExclusiveLock
Definition: lockdefs.h:39
#define SECURITY_RESTRICTED_OPERATION
Definition: miscadmin.h:315
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
Definition: miscinit.c:635
void SetUserIdAndSecContext(Oid userid, int sec_context)
Definition: miscinit.c:642
#define PROC_IN_VACUUM
Definition: proc.h:58
#define PROC_VACUUM_FOR_WRAPAROUND
Definition: proc.h:60
#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
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
PGPROC * MyProc
Definition: proc.c:66
PROC_HDR * ProcGlobal
Definition: proc.c:78
bits32 options
Definition: cluster.h:30
LockRelId lockRelId
Definition: rel.h:46
Definition: rel.h:39
uint8 statusFlags
Definition: proc.h:238
int pgxactoff
Definition: proc.h:180
uint8 * statusFlags
Definition: proc.h:395
LockInfoData rd_lockInfo
Definition: rel.h:114
bytea * rd_options
Definition: rel.h:175
static void table_relation_vacuum(Relation rel, struct VacuumParams *params, BufferAccessStrategy bstrategy)
Definition: tableam.h:1717
Relation vacuum_open_relation(Oid relid, RangeVar *relation, bits32 options, bool verbose, LOCKMODE lmode)
Definition: vacuum.c:758

References AccessExclusiveLock, Assert, AtEOXact_GUC(), CHECK_FOR_INTERRUPTS, CLUOPT_VERBOSE, cluster_rel(), CommitTransactionCommand(), ereport, errmsg(), GetTransactionSnapshot(), GetUserIdAndSecContext(), VacuumParams::index_cleanup, InvalidOid, VacuumParams::is_wraparound, LockRelationIdForSession(), LockInfoData::lockRelId, VacuumParams::log_min_duration, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, NewGUCNestLevel(), NoLock, OidIsValid, ClusterParams::options, VacuumParams::options, PGPROC::pgxactoff, PopActiveSnapshot(), PROC_IN_VACUUM, PROC_VACUUM_FOR_WRAPAROUND, ProcGlobal, PushActiveSnapshot(), RelationData::rd_lockInfo, RelationData::rd_options, RelationData::rd_rel, relation_close(), RELATION_IS_OTHER_TEMP, RelationGetRelationName, RelationGetRelid, RestrictSearchPath(), SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), ShareUpdateExclusiveLock, StartTransactionCommand(), PGPROC::statusFlags, PROC_HDR::statusFlags, STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO, STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF, STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON, table_relation_vacuum(), VacuumParams::toast_parent, VacuumParams::truncate, UnlockRelationIdForSession(), VACOPT_ANALYZE, VACOPT_FULL, VACOPT_PROCESS_MAIN, VACOPT_PROCESS_TOAST, VACOPT_VERBOSE, VACOPTVALUE_AUTO, VACOPTVALUE_DISABLED, VACOPTVALUE_ENABLED, VACOPTVALUE_UNSPECIFIED, vacuum_is_permitted_for_relation(), vacuum_open_relation(), and WARNING.

Referenced by vacuum().

◆ vacuum_xid_failsafe_check()

bool vacuum_xid_failsafe_check ( const struct VacuumCutoffs cutoffs)

Definition at line 1240 of file vacuum.c.

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 }
int autovacuum_multixact_freeze_max_age
Definition: autovacuum.c:127
#define Max(x, y)
Definition: c.h:998
int vacuum_multixact_failsafe_age
Definition: vacuum.c:72
int vacuum_failsafe_age
Definition: vacuum.c:71

References Assert, autovacuum_freeze_max_age, autovacuum_multixact_freeze_max_age, FirstMultiXactId, FirstNormalTransactionId, Max, MultiXactIdIsValid, MultiXactIdPrecedes(), ReadNextMultiXactId(), ReadNextTransactionId(), VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, TransactionIdIsNormal, TransactionIdPrecedes(), vacuum_failsafe_age, and vacuum_multixact_failsafe_age.

Referenced by lazy_check_wraparound_failsafe().

Variable Documentation

◆ vacuum_cost_delay

double vacuum_cost_delay = 0

◆ vacuum_cost_limit

int vacuum_cost_limit = 200

◆ vacuum_failsafe_age

int vacuum_failsafe_age

Definition at line 71 of file vacuum.c.

Referenced by vacuum_xid_failsafe_check().

◆ vacuum_freeze_min_age

int vacuum_freeze_min_age

Definition at line 67 of file vacuum.c.

Referenced by do_autovacuum(), and vacuum_get_cutoffs().

◆ vacuum_freeze_table_age

int vacuum_freeze_table_age

Definition at line 68 of file vacuum.c.

Referenced by do_autovacuum(), and vacuum_get_cutoffs().

◆ vacuum_multixact_failsafe_age

int vacuum_multixact_failsafe_age

Definition at line 72 of file vacuum.c.

Referenced by vacuum_xid_failsafe_check().

◆ vacuum_multixact_freeze_min_age

int vacuum_multixact_freeze_min_age

Definition at line 69 of file vacuum.c.

Referenced by do_autovacuum(), and vacuum_get_cutoffs().

◆ vacuum_multixact_freeze_table_age

int vacuum_multixact_freeze_table_age

Definition at line 70 of file vacuum.c.

Referenced by do_autovacuum(), and vacuum_get_cutoffs().

◆ VacuumActiveNWorkers

◆ VacuumCostBalanceLocal

int VacuumCostBalanceLocal = 0

◆ VacuumFailsafeActive

◆ VacuumSharedCostBalance

pg_atomic_uint32* VacuumSharedCostBalance = NULL