#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/namespace.h"#include "catalog/pg_database.h"#include "catalog/pg_inherits.h"#include "commands/async.h"#include "commands/cluster.h"#include "commands/defrem.h"#include "commands/progress.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/injection_point.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.
Macros | |
| #define | PARALLEL_VACUUM_DELAY_REPORT_INTERVAL_NS (NS_PER_S) |
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_max_eager_freeze_failure_rate |
| bool | track_cost_delay_timing |
| bool | vacuum_truncate |
| double | vacuum_cost_delay = 0 |
| int | vacuum_cost_limit = 200 |
| int64 | parallel_vacuum_worker_delay_ns = 0 |
| bool | VacuumFailsafeActive = false |
| pg_atomic_uint32 * | VacuumSharedCostBalance = NULL |
| pg_atomic_uint32 * | VacuumActiveNWorkers = NULL |
| int | VacuumCostBalanceLocal = 0 |
Macro Definition Documentation
◆ PARALLEL_VACUUM_DELAY_REPORT_INTERVAL_NS
Function Documentation
◆ check_vacuum_buffer_usage_limit()
| bool check_vacuum_buffer_usage_limit | ( | int * | newval, |
| void ** | extra, | ||
| GucSource | source | ||
| ) |
Definition at line 139 of file vacuum.c.
141{
142 /* Value upper and lower hard limits are inclusive */
145 return true;
146
147 /* Value does not fall within any allowable range */
149 "vacuum_buffer_usage_limit",
151
152 return false;
153}
#define newval
References GUC_check_errdetail, MAX_BAS_VAC_RING_SIZE_KB, MIN_BAS_VAC_RING_SIZE_KB, and newval.
◆ compute_parallel_delay()
|
static |
Definition at line 2578 of file vacuum.c.
2579{
2580 double msec = 0;
2581 uint32 shared_balance;
2582 int nworkers;
2583
2584 /* Parallel vacuum must be active */
2586
2588
2589 /* At least count itself */
2590 Assert(nworkers >= 1);
2591
2592 /* Update the shared cost balance value atomically */
2594
2595 /* Compute the total local balance for the current worker */
2597
2600 {
2601 /* Compute sleep time based on the local cost balance */
2604 VacuumCostBalanceLocal = 0;
2605 }
2606
2607 /*
2608 * Reset the local balance as we accumulated it into the shared value.
2609 */
2610 VacuumCostBalance = 0;
2611
2612 return msec;
2613}
static uint32 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:439
static uint32 pg_atomic_add_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:424
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:237
Assert(PointerIsAligned(start, uint64))
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 162 of file vacuum.c.
163{
164 VacuumParams params;
165 BufferAccessStrategy bstrategy = NULL;
167 bool skip_locked = false;
169 bool freeze = false;
170 bool full = false;
171 bool disable_page_skipping = false;
172 bool process_main = true;
173 bool process_toast = true;
174 int ring_size;
175 bool skip_database_stats = false;
176 bool only_database_stats = false;
177 MemoryContext vac_context;
178 ListCell *lc;
179
180 /* index_cleanup and truncate values unspecified for now */
183
184 /* By default parallel vacuum is enabled */
185 params.nworkers = 0;
186
187 /* Will be set later if we recurse to a TOAST table. */
189
190 /*
191 * Set this to an invalid value so it is clear whether or not a
192 * BUFFER_USAGE_LIMIT was specified when making the access strategy.
193 */
194 ring_size = -1;
195
196 /* Parse options list */
198 {
200
201 /* Parse common options for VACUUM and ANALYZE */
205 skip_locked = defGetBoolean(opt);
207 {
208 const char *hintmsg;
209 int result;
210 char *vac_buffer_size;
211
212 vac_buffer_size = defGetString(opt);
213
214 /*
215 * Check that the specified value is valid and the size falls
216 * within the hard upper and lower limits if it is not 0.
217 */
219 (result != 0 &&
220 (result < MIN_BAS_VAC_RING_SIZE_KB || result > MAX_BAS_VAC_RING_SIZE_KB)))
221 {
223 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
225 "BUFFER_USAGE_LIMIT",
228 }
229
230 ring_size = result;
231 }
234 (errcode(ERRCODE_SYNTAX_ERROR),
238
239 /* Parse options available on VACUUM */
243 freeze = defGetBoolean(opt);
245 full = defGetBoolean(opt);
247 disable_page_skipping = defGetBoolean(opt);
249 {
250 /* Interpret no string as the default, which is 'auto' */
253 else
254 {
256
257 /* Try matching on 'auto' string, or fall back on boolean */
260 else
262 }
263 }
265 process_main = defGetBoolean(opt);
267 process_toast = defGetBoolean(opt);
271 {
273
276 (errcode(ERRCODE_SYNTAX_ERROR),
278 "PARALLEL",
281
282 /*
283 * Disable parallel vacuum, if user has specified parallel degree
284 * as zero.
285 */
286 if (nworkers == 0)
287 params.nworkers = -1;
288 else
289 params.nworkers = nworkers;
290 }
292 skip_database_stats = defGetBoolean(opt);
294 only_database_stats = defGetBoolean(opt);
295 else
297 (errcode(ERRCODE_SYNTAX_ERROR),
301 }
302
303 /* Set vacuum options */
304 params.options =
307 (skip_locked ? VACOPT_SKIP_LOCKED : 0) |
309 (freeze ? VACOPT_FREEZE : 0) |
310 (full ? VACOPT_FULL : 0) |
311 (disable_page_skipping ? VACOPT_DISABLE_PAGE_SKIPPING : 0) |
312 (process_main ? VACOPT_PROCESS_MAIN : 0) |
313 (process_toast ? VACOPT_PROCESS_TOAST : 0) |
314 (skip_database_stats ? VACOPT_SKIP_DATABASE_STATS : 0) |
315 (only_database_stats ? VACOPT_ONLY_DATABASE_STATS : 0);
316
317 /* sanity checks on options */
321
324 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
326
327 /*
328 * BUFFER_USAGE_LIMIT does nothing for VACUUM (FULL) so just raise an
329 * ERROR for that case. VACUUM (FULL, ANALYZE) does make use of it, so
330 * we'll permit that.
331 */
335 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
337
338 /*
339 * Make sure VACOPT_ANALYZE is specified if any column lists are present.
340 */
342 {
344 {
346
349 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
351 }
352 }
353
354
355 /*
356 * Sanity check DISABLE_PAGE_SKIPPING option.
357 */
361 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
363
364 /* sanity check for PROCESS_TOAST */
368 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
370
371 /* sanity check for ONLY_DATABASE_STATS */
373 {
377 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
379 /* don't require people to turn off PROCESS_TOAST/MAIN explicitly */
381 VACOPT_VERBOSE |
382 VACOPT_PROCESS_MAIN |
383 VACOPT_PROCESS_TOAST |
386 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
388 }
389
390 /*
391 * All freeze ages are zero if the FREEZE option is given; otherwise pass
392 * them as -1 which means to use the default values.
393 */
395 {
396 params.freeze_min_age = 0;
397 params.freeze_table_age = 0;
398 params.multixact_freeze_min_age = 0;
399 params.multixact_freeze_table_age = 0;
400 }
401 else
402 {
403 params.freeze_min_age = -1;
404 params.freeze_table_age = -1;
405 params.multixact_freeze_min_age = -1;
406 params.multixact_freeze_table_age = -1;
407 }
408
409 /* user-invoked vacuum is never "for wraparound" */
411
412 /*
413 * user-invoked vacuum uses VACOPT_VERBOSE instead of
414 * log_vacuum_min_duration and log_analyze_min_duration
415 */
416 params.log_vacuum_min_duration = -1;
417 params.log_analyze_min_duration = -1;
418
419 /*
420 * Later, in vacuum_rel(), we check if a reloption override was specified.
421 */
423
424 /*
425 * Create special memory context for cross-transaction storage.
426 *
427 * Since it is a child of PortalContext, it will go away eventually even
428 * if we suffer an error; there's no need for special abort cleanup logic.
429 */
431 "Vacuum",
432 ALLOCSET_DEFAULT_SIZES);
433
434 /*
435 * Make a buffer strategy object in the cross-transaction memory context.
436 * We needn't bother making this for VACUUM (FULL) or VACUUM
437 * (ONLY_DATABASE_STATS) as they'll not make use of it. VACUUM (FULL,
438 * ANALYZE) is possible, so we'd better ensure that we make a strategy
439 * when we see ANALYZE.
440 */
442 VACOPT_FULL)) == 0 ||
444 {
445
447
448 Assert(ring_size >= -1);
449
450 /*
451 * If BUFFER_USAGE_LIMIT was specified by the VACUUM or ANALYZE
452 * command, it overrides the value of VacuumBufferUsageLimit. Either
453 * value may be 0, in which case GetAccessStrategyWithSize() will
454 * return NULL, effectively allowing full use of shared buffers.
455 */
456 if (ring_size == -1)
457 ring_size = VacuumBufferUsageLimit;
458
460
461 MemoryContextSwitchTo(old_context);
462 }
463
464 /* Now go through the common routine */
466
467 /* Finally, clean up the vacuum memory context */
468 MemoryContextDelete(vac_context);
469}
BufferAccessStrategy GetAccessStrategyWithSize(BufferAccessStrategyType btype, int ring_size_kb)
Definition: freelist.c:546
bool parse_int(const char *value, int *result, int flags, const char **hintmsg)
Definition: guc.c:2743
int verbose
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
Definition: freelist.c:65
Definition: parsenodes.h:840
Definition: memnodes.h:118
Definition: vacuum.h:218
double max_eager_freeze_failure_rate
Definition: vacuum.h:244
Definition: parsenodes.h:3989
Definition: pg_list.h:46
void vacuum(List *relations, const VacuumParams params, BufferAccessStrategy bstrategy, MemoryContext vac_context, bool isTopLevel)
Definition: vacuum.c:494
double vacuum_max_eager_freeze_failure_rate
Definition: vacuum.c:81
static VacOptValue get_vacoptval_from_boolean(DefElem *def)
Definition: vacuum.c:2622
References _, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, analyze(), DefElem::arg, Assert(), BAS_VACUUM, defGetBoolean(), defGetInt32(), defGetString(), DefElem::defname, ereport, errcode(), errhint_internal(), 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_analyze_min_duration, VacuumParams::log_vacuum_min_duration, MAX_BAS_VAC_RING_SIZE_KB, VacuumParams::max_eager_freeze_failure_rate, 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(), vacuum_max_eager_freeze_failure_rate, VacuumBufferUsageLimit, and verbose.
Referenced by standard_ProcessUtility().
◆ expand_vacuum_rel()
|
static |
Definition at line 883 of file vacuum.c.
885{
887 MemoryContext oldcontext;
888
889 /* If caller supplied OID, there's nothing we need do here. */
891 {
892 oldcontext = MemoryContextSwitchTo(vac_context);
893 vacrels = lappend(vacrels, vrel);
894 MemoryContextSwitchTo(oldcontext);
895 }
896 else
897 {
898 /*
899 * Process a specific relation, and possibly partitions or child
900 * tables thereof.
901 */
902 Oid relid;
903 HeapTuple tuple;
904 Form_pg_class classForm;
905 bool include_children;
906 bool is_partitioned_table;
907 int rvr_opts;
908
909 /*
910 * Since autovacuum workers supply OIDs when calling vacuum(), no
911 * autovacuum worker should reach this code.
912 */
914
915 /*
916 * We transiently take AccessShareLock to protect the syscache lookup
917 * below, as well as find_all_inheritors's expectation that the caller
918 * holds some lock on the starting relation.
919 */
922 AccessShareLock,
923 rvr_opts,
924 NULL, NULL);
925
926 /*
927 * If the lock is unavailable, emit the same log statement that
928 * vacuum_rel() and analyze_rel() would.
929 */
931 {
934 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
937 else
939 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
942 return vacrels;
943 }
944
945 /*
946 * To check whether the relation is a partitioned table and its
947 * ownership, fetch its syscache entry.
948 */
953
954 /*
955 * Make a returnable VacuumRelation for this rel if the user has the
956 * required privileges.
957 */
959 {
960 oldcontext = MemoryContextSwitchTo(vac_context);
962 relid,
963 vrel->va_cols));
964 MemoryContextSwitchTo(oldcontext);
965 }
966
967 /*
968 * Vacuuming a partitioned table with ONLY will not do anything since
969 * the partitioned table itself is empty. Issue a warning if the user
970 * requests this.
971 */
973 is_partitioned_table = (classForm->relkind == RELKIND_PARTITIONED_TABLE);
978
979 ReleaseSysCache(tuple);
980
981 /*
982 * Unless the user has specified ONLY, make relation list entries for
983 * its partitions or inheritance child tables. Note that the list
984 * returned by find_all_inheritors() includes the passed-in OID, so we
985 * have to skip that. There's no point in taking locks on the
986 * individual partitions or child tables yet, and doing so would just
987 * add unnecessary deadlock risk. For this last reason, we do not yet
988 * check the ownership of the partitions/tables, which get added to
989 * the list to process. Ownership will be checked later on anyway.
990 */
991 if (include_children)
992 {
994 ListCell *part_lc;
995
996 foreach(part_lc, part_oids)
997 {
999
1000 if (part_oid == relid)
1001 continue; /* ignore original table */
1002
1003 /*
1004 * We omit a RangeVar since it wouldn't be appropriate to
1005 * complain about failure to open one of these relations
1006 * later.
1007 */
1008 oldcontext = MemoryContextSwitchTo(vac_context);
1010 part_oid,
1011 vrel->va_cols));
1012 MemoryContextSwitchTo(oldcontext);
1013 }
1014 }
1015
1016 /*
1017 * Release lock again. This means that by the time we actually try to
1018 * process the table, it might be gone or renamed. In the former case
1019 * we'll silently ignore it; in the latter case we'll process it
1020 * anyway, but we must beware that the RangeVar doesn't necessarily
1021 * identify it anymore. This isn't ideal, perhaps, but there's little
1022 * practical alternative, since we're typically going to commit this
1023 * transaction and begin a new one between now and then. Moreover,
1024 * holding locks on multiple relations would create significant risk
1025 * of deadlock.
1026 */
1028 }
1029
1030 return vacrels;
1031}
VacuumRelation * makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols)
Definition: makefuncs.c:907
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition: namespace.c:440
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
Definition: pg_inherits.c:255
Definition: htup.h:63
Definition: pg_list.h:54
Definition: oid2name.c:30
bool vacuum_is_permitted_for_relation(Oid relid, Form_pg_class reltuple, bits32 options)
Definition: vacuum.c:719
References AccessShareLock, AmAutoVacuumWorkerProcess, Assert(), elog, ereport, errcode(), errmsg(), ERROR, find_all_inheritors(), GETSTRUCT(), HeapTupleIsValid, RangeVar::inh, 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 |
Definition at line 1038 of file vacuum.c.
1039{
1041 Relation pgclass;
1042 TableScanDesc scan;
1043 HeapTuple tuple;
1044
1046
1047 scan = table_beginscan_catalog(pgclass, 0, NULL);
1048
1050 {
1052 MemoryContext oldcontext;
1053 Oid relid = classForm->oid;
1054
1055 /*
1056 * We include partitioned tables here; depending on which operation is
1057 * to be performed, caller will decide whether to process or ignore
1058 * them.
1059 */
1060 if (classForm->relkind != RELKIND_RELATION &&
1061 classForm->relkind != RELKIND_MATVIEW &&
1062 classForm->relkind != RELKIND_PARTITIONED_TABLE)
1063 continue;
1064
1065 /* check permissions of relation */
1067 continue;
1068
1069 /*
1070 * Build VacuumRelation(s) specifying the table OIDs to be processed.
1071 * We omit a RangeVar since it wouldn't be appropriate to complain
1072 * about failure to open one of these relations later.
1073 */
1074 oldcontext = MemoryContextSwitchTo(vac_context);
1076 relid,
1077 NIL));
1078 MemoryContextSwitchTo(oldcontext);
1079 }
1080
1081 table_endscan(scan);
1083
1084 return vacrels;
1085}
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1361
Definition: rel.h:56
Definition: relscan.h:34
TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, ScanKeyData *key)
Definition: tableam.c:113
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 |
Definition at line 2622 of file vacuum.c.
2623{
2625}
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 2633 of file vacuum.c.
2635{
2636 /* Do bulk deletion */
2638 dead_items);
2639
2643 dead_items_info->num_items)));
2644
2645 return istat;
2646}
IndexBulkDeleteResult * index_bulk_delete(IndexVacuumInfo *info, IndexBulkDeleteResult *istat, IndexBulkDeleteCallback callback, void *callback_state)
Definition: indexam.c:805
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 2654 of file vacuum.c.
2655{
2656 istat = index_vacuum_cleanup(ivinfo, istat);
2657
2658 if (istat)
2662 istat->num_index_tuples,
2663 istat->num_pages),
2665 "%u index pages were newly deleted.\n"
2666 "%u index pages are currently deleted, of which %u are currently reusable.",
2667 istat->tuples_removed,
2668 istat->pages_newly_deleted,
2670
2671 return istat;
2672}
IndexBulkDeleteResult * index_vacuum_cleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *istat)
Definition: indexam.c:826
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()
Definition at line 2405 of file vacuum.c.
2406{
2407 if (Irel == NULL)
2408 return;
2409
2410 while (nindexes--)
2411 {
2413
2415 }
2416 pfree(Irel);
2417}
Definition: preproc-array_of_struct.c:43
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 1330 of file vacuum.c.
1334{
1337 double old_density;
1338 double unscanned_pages;
1339 double total_tuples;
1340
1341 /* If we did scan the whole table, just use the count as-is */
1342 if (scanned_pages >= total_pages)
1343 return scanned_tuples;
1344
1345 /*
1346 * When successive VACUUM commands scan the same few pages again and
1347 * again, without anything from the table really changing, there is a risk
1348 * that our beliefs about tuple density will gradually become distorted.
1349 * This might be caused by vacuumlazy.c implementation details, such as
1350 * its tendency to always scan the last heap page. Handle that here.
1351 *
1352 * If the relation is _exactly_ the same size according to the existing
1353 * pg_class entry, and only a few of its pages (less than 2%) were
1354 * scanned, keep the existing value of reltuples. Also keep the existing
1355 * value when only a subset of rel's pages <= a single page were scanned.
1356 *
1357 * (Note: we might be returning -1 here.)
1358 */
1359 if (old_rel_pages == total_pages &&
1360 scanned_pages < (double) total_pages * 0.02)
1361 return old_rel_tuples;
1362 if (scanned_pages <= 1)
1363 return old_rel_tuples;
1364
1365 /*
1366 * If old density is unknown, we can't do much except scale up
1367 * scanned_tuples to match total_pages.
1368 */
1369 if (old_rel_tuples < 0 || old_rel_pages == 0)
1370 return floor((scanned_tuples / scanned_pages) * total_pages + 0.5);
1371
1372 /*
1373 * Okay, we've covered the corner cases. The normal calculation is to
1374 * convert the old measurement to a density (tuples per page), then
1375 * estimate the number of tuples in the unscanned pages using that figure,
1376 * and finally add on the number of tuples in the scanned pages.
1377 */
1378 old_density = old_rel_tuples / old_rel_pages;
1379 unscanned_pages = (double) total_pages - (double) scanned_pages;
1380 total_tuples = old_density * unscanned_pages + scanned_tuples;
1381 return floor(total_tuples + 0.5);
1382}
References RelationData::rd_rel.
Referenced by lazy_scan_heap(), and statapprox_heap().
◆ vac_open_indexes()
Definition at line 2362 of file vacuum.c.
2364{
2365 List *indexoidlist;
2366 ListCell *indexoidscan;
2368
2370
2371 indexoidlist = RelationGetIndexList(relation);
2372
2373 /* allocate enough memory for all indexes */
2375
2378 else
2379 *Irel = NULL;
2380
2381 /* collect just the ready indexes */
2382 i = 0;
2383 foreach(indexoidscan, indexoidlist)
2384 {
2386 Relation indrel;
2387
2388 indrel = index_open(indexoid, lockmode);
2390 (*Irel)[i++] = indrel;
2391 else
2392 index_close(indrel, lockmode);
2393 }
2394
2395 *nindexes = i;
2396
2397 list_free(indexoidlist);
2398}
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 |
Definition at line 2680 of file vacuum.c.
2681{
2683
2685}
Definition: tidstore.c:115
Definition: regguts.h:323
bool TidStoreIsMember(TidStore *ts, const ItemPointerData *tid)
Definition: tidstore.c:421
References TidStoreIsMember().
Referenced by vac_bulkdel_one_index().
◆ vac_truncate_clog()
|
static |
Definition at line 1827 of file vacuum.c.
1831{
1833 Relation relation;
1834 TableScanDesc scan;
1835 HeapTuple tuple;
1836 Oid oldestxid_datoid;
1837 Oid minmulti_datoid;
1838 bool bogus = false;
1839 bool frozenAlreadyWrapped = false;
1840
1841 /* Restrict task to one backend per cluster; see SimpleLruTruncate(). */
1843
1844 /* init oldest datoids to sync with my frozenXID/minMulti values */
1845 oldestxid_datoid = MyDatabaseId;
1846 minmulti_datoid = MyDatabaseId;
1847
1848 /*
1849 * Scan pg_database to compute the minimum datfrozenxid/datminmxid
1850 *
1851 * Since vac_update_datfrozenxid updates datfrozenxid/datminmxid in-place,
1852 * the values could change while we look at them. Fetch each one just
1853 * once to ensure sane behavior of the comparison logic. (Here, as in
1854 * many other places, we assume that fetching or updating an XID in shared
1855 * storage is atomic.)
1856 *
1857 * Note: we need not worry about a race condition with new entries being
1858 * inserted by CREATE DATABASE. Any such entry will have a copy of some
1859 * existing DB's datfrozenxid, and that source DB cannot be ours because
1860 * of the interlock against copying a DB containing an active backend.
1861 * Hence the new entry will not reduce the minimum. Also, if two VACUUMs
1862 * concurrently modify the datfrozenxid's of different databases, the
1863 * worst possible outcome is that pg_xact is not truncated as aggressively
1864 * as it could be.
1865 */
1867
1868 scan = table_beginscan_catalog(relation, 0, NULL);
1869
1871 {
1875
1878
1879 /*
1880 * If database is in the process of getting dropped, or has been
1881 * interrupted while doing so, no connections to it are possible
1882 * anymore. Therefore we don't need to take it into account here.
1883 * Which is good, because it can't be processed by autovacuum either.
1884 */
1886 {
1888 "skipping invalid database \"%s\" while computing relfrozenxid",
1889 NameStr(dbform->datname));
1890 continue;
1891 }
1892
1893 /*
1894 * If things are working properly, no database should have a
1895 * datfrozenxid or datminmxid that is "in the future". However, such
1896 * cases have been known to arise due to bugs in pg_upgrade. If we
1897 * see any entries that are "in the future", chicken out and don't do
1898 * anything. This ensures we won't truncate clog before those
1899 * databases have been scanned and cleaned up. (We will issue the
1900 * "already wrapped" warning if appropriate, though.)
1901 */
1904 bogus = true;
1905
1907 frozenAlreadyWrapped = true;
1909 {
1910 frozenXID = datfrozenxid;
1911 oldestxid_datoid = dbform->oid;
1912 }
1913
1915 {
1916 minMulti = datminmxid;
1917 minmulti_datoid = dbform->oid;
1918 }
1919 }
1920
1921 table_endscan(scan);
1922
1924
1925 /*
1926 * Do not truncate CLOG if we seem to have suffered wraparound already;
1927 * the computed minimum XID might be bogus. This case should now be
1928 * impossible due to the defenses in GetNewTransactionId, but we keep the
1929 * test anyway.
1930 */
1931 if (frozenAlreadyWrapped)
1932 {
1936 LWLockRelease(WrapLimitsVacuumLock);
1937 return;
1938 }
1939
1940 /* chicken out if data is bogus in any other way */
1941 if (bogus)
1942 {
1943 LWLockRelease(WrapLimitsVacuumLock);
1944 return;
1945 }
1946
1947 /*
1948 * Freeze any old transaction IDs in the async notification queue before
1949 * CLOG truncation.
1950 */
1951 AsyncNotifyFreezeXids(frozenXID);
1952
1953 /*
1954 * Advance the oldest value for commit timestamps before truncating, so
1955 * that if a user requests a timestamp for a transaction we're truncating
1956 * away right after this point, they get NULL instead of an ugly "file not
1957 * found" error from slru.c. This doesn't matter for xact/multixact
1958 * because they are not subject to arbitrary lookups from users.
1959 */
1960 AdvanceOldestCommitTsXid(frozenXID);
1961
1962 /*
1963 * Truncate CLOG, multixact and CommitTs to the oldest computed value.
1964 */
1965 TruncateCLOG(frozenXID, oldestxid_datoid);
1966 TruncateCommitTs(frozenXID);
1967 TruncateMultiXact(minMulti, minmulti_datoid);
1968
1969 /*
1970 * Update the wrap limit for GetNewTransactionId and creation of new
1971 * MultiXactIds. Note: these functions will also signal the postmaster
1972 * for an(other) autovac cycle if needed. XXX should we avoid possibly
1973 * signaling twice?
1974 */
1975 SetTransactionIdLimit(frozenXID, oldestxid_datoid);
1976 SetMultiXactIdLimit(minMulti, minmulti_datoid);
1977
1978 LWLockRelease(WrapLimitsVacuumLock);
1979}
void AdvanceOldestCommitTsXid(TransactionId oldestXact)
Definition: commit_ts.c:914
bool database_is_invalid_form(Form_pg_database datform)
Definition: dbcommands.c:3215
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:2828
void TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
Definition: multixact.c:2619
void SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid)
Definition: multixact.c:2011
static bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.h:263
void SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
Definition: varsup.c:372
References AccessShareLock, AdvanceOldestCommitTsXid(), Assert(), AsyncNotifyFreezeXids(), 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 1608 of file vacuum.c.
1609{
1610 HeapTuple tuple;
1611 Form_pg_database dbform;
1612 Relation relation;
1613 SysScanDesc scan;
1614 HeapTuple classTup;
1615 TransactionId newFrozenXid;
1616 MultiXactId newMinMulti;
1617 TransactionId lastSaneFrozenXid;
1618 MultiXactId lastSaneMinMulti;
1619 bool bogus = false;
1620 bool dirty = false;
1622 void *inplace_state;
1623
1624 /*
1625 * Restrict this task to one backend per database. This avoids race
1626 * conditions that would move datfrozenxid or datminmxid backward. It
1627 * avoids calling vac_truncate_clog() with a datfrozenxid preceding a
1628 * datfrozenxid passed to an earlier vac_truncate_clog() call.
1629 */
1631
1632 /*
1633 * Initialize the "min" calculation with
1634 * GetOldestNonRemovableTransactionId(), which is a reasonable
1635 * approximation to the minimum relfrozenxid for not-yet-committed
1636 * pg_class entries for new tables; see AddNewRelationTuple(). So we
1637 * cannot produce a wrong minimum by starting with this.
1638 */
1639 newFrozenXid = GetOldestNonRemovableTransactionId(NULL);
1640
1641 /*
1642 * Similarly, initialize the MultiXact "min" with the value that would be
1643 * used on pg_class for new tables. See AddNewRelationTuple().
1644 */
1645 newMinMulti = GetOldestMultiXactId();
1646
1647 /*
1648 * Identify the latest relfrozenxid and relminmxid values that we could
1649 * validly see during the scan. These are conservative values, but it's
1650 * not really worth trying to be more exact.
1651 */
1652 lastSaneFrozenXid = ReadNextTransactionId();
1653 lastSaneMinMulti = ReadNextMultiXactId();
1654
1655 /*
1656 * We must seqscan pg_class to find the minimum Xid, because there is no
1657 * index that can help us here.
1658 *
1659 * See vac_truncate_clog() for the race condition to prevent.
1660 */
1662
1664 NULL, 0, NULL);
1665
1667 {
1669 TransactionId relfrozenxid = classForm->relfrozenxid;
1670 TransactionId relminmxid = classForm->relminmxid;
1671
1672 /*
1673 * Only consider relations able to hold unfrozen XIDs (anything else
1674 * should have InvalidTransactionId in relfrozenxid anyway).
1675 */
1676 if (classForm->relkind != RELKIND_RELATION &&
1677 classForm->relkind != RELKIND_MATVIEW &&
1678 classForm->relkind != RELKIND_TOASTVALUE)
1679 {
1682 continue;
1683 }
1684
1685 /*
1686 * Some table AMs might not need per-relation xid / multixid horizons.
1687 * It therefore seems reasonable to allow relfrozenxid and relminmxid
1688 * to not be set (i.e. set to their respective Invalid*Id)
1689 * independently. Thus validate and compute horizon for each only if
1690 * set.
1691 *
1692 * If things are working properly, no relation should have a
1693 * relfrozenxid or relminmxid that is "in the future". However, such
1694 * cases have been known to arise due to bugs in pg_upgrade. If we
1695 * see any entries that are "in the future", chicken out and don't do
1696 * anything. This ensures we won't truncate clog & multixact SLRUs
1697 * before those relations have been scanned and cleaned up.
1698 */
1699
1701 {
1703
1704 /* check for values in the future */
1706 {
1707 bogus = true;
1708 break;
1709 }
1710
1711 /* determine new horizon */
1713 newFrozenXid = relfrozenxid;
1714 }
1715
1717 {
1718 /* check for values in the future */
1720 {
1721 bogus = true;
1722 break;
1723 }
1724
1725 /* determine new horizon */
1727 newMinMulti = relminmxid;
1728 }
1729 }
1730
1731 /* we're done with pg_class */
1732 systable_endscan(scan);
1734
1735 /* chicken out if bogus data found */
1736 if (bogus)
1737 return;
1738
1741
1742 /* Now fetch the pg_database tuple we need to update. */
1744
1745 /*
1746 * Fetch a copy of the tuple to scribble on. We could check the syscache
1747 * tuple first. If that concluded !dirty, we'd avoid waiting on
1748 * concurrent heap_update() and would avoid exclusive-locking the buffer.
1749 * For now, don't optimize that.
1750 */
1752 Anum_pg_database_oid,
1753 BTEqualStrategyNumber, F_OIDEQ,
1755
1757 NULL, 1, key, &tuple, &inplace_state);
1758
1761
1763
1764 /*
1765 * As in vac_update_relstats(), we ordinarily don't want to let
1766 * datfrozenxid go backward; but if it's "in the future" then it must be
1767 * corrupt and it seems best to overwrite it.
1768 */
1769 if (dbform->datfrozenxid != newFrozenXid &&
1770 (TransactionIdPrecedes(dbform->datfrozenxid, newFrozenXid) ||
1771 TransactionIdPrecedes(lastSaneFrozenXid, dbform->datfrozenxid)))
1772 {
1773 dbform->datfrozenxid = newFrozenXid;
1774 dirty = true;
1775 }
1776 else
1777 newFrozenXid = dbform->datfrozenxid;
1778
1779 /* Ditto for datminmxid */
1780 if (dbform->datminmxid != newMinMulti &&
1781 (MultiXactIdPrecedes(dbform->datminmxid, newMinMulti) ||
1782 MultiXactIdPrecedes(lastSaneMinMulti, dbform->datminmxid)))
1783 {
1784 dbform->datminmxid = newMinMulti;
1785 dirty = true;
1786 }
1787 else
1788 newMinMulti = dbform->datminmxid;
1789
1790 if (dirty)
1791 systable_inplace_update_finish(inplace_state, tuple);
1792 else
1793 systable_inplace_update_cancel(inplace_state);
1794
1795 heap_freetuple(tuple);
1797
1798 /*
1799 * If we were able to advance datfrozenxid or datminmxid, see if we can
1800 * truncate pg_xact and/or pg_multixact. Also do it if the shared
1801 * XID-wrap-limit info is stale, since this action will update that too.
1802 */
1804 vac_truncate_clog(newFrozenXid, newMinMulti,
1805 lastSaneFrozenXid, lastSaneMinMulti);
1806}
void systable_inplace_update_cancel(void *state)
Definition: genam.c:902
void systable_inplace_update_begin(Relation relation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, const ScanKeyData *key, HeapTuple *oldtupcopy, void **state)
Definition: genam.c:807
void systable_inplace_update_finish(void *state, HeapTuple tuple)
Definition: genam.c:883
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:388
TransactionId GetOldestNonRemovableTransactionId(Relation rel)
Definition: procarray.c:1953
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
Definition: skey.h:65
Definition: relscan.h:210
static void vac_truncate_clog(TransactionId frozenXID, MultiXactId minMulti, TransactionId lastSaneFrozenXid, MultiXactId lastSaneMinMulti)
Definition: vacuum.c:1827
References AccessShareLock, Assert(), BTEqualStrategyNumber, elog, ERROR, ExclusiveLock, ForceTransactionIdLimitUpdate(), FormData_pg_class, GetOldestMultiXactId(), GetOldestNonRemovableTransactionId(), GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, InvalidOid, sort-test::key, LockDatabaseFrozenIds(), MultiXactIdIsValid, MultiXactIdPrecedes(), MyDatabaseId, ObjectIdGetDatum(), ReadNextMultiXactId(), ReadNextTransactionId(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), systable_inplace_update_begin(), systable_inplace_update_cancel(), systable_inplace_update_finish(), 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, | ||
| BlockNumber | num_all_frozen_pages, | ||
| bool | hasindex, | ||
| TransactionId | frozenxid, | ||
| MultiXactId | minmulti, | ||
| bool * | frozenxid_updated, | ||
| bool * | minmulti_updated, | ||
| bool | in_outer_xact | ||
| ) |
Definition at line 1426 of file vacuum.c.
1434{
1436 Relation rd;
1438 HeapTuple ctup;
1439 void *inplace_state;
1440 Form_pg_class pgcform;
1441 bool dirty,
1442 futurexid,
1443 futuremxid;
1444 TransactionId oldfrozenxid;
1445 MultiXactId oldminmulti;
1446
1448
1449 /* Fetch a copy of the tuple to scribble on */
1451 Anum_pg_class_oid,
1452 BTEqualStrategyNumber, F_OIDEQ,
1453 ObjectIdGetDatum(relid));
1455 NULL, 1, key, &ctup, &inplace_state);
1458 relid);
1460
1461 /* Apply statistical updates, if any, to copied tuple */
1462
1463 dirty = false;
1465 {
1466 pgcform->relpages = (int32) num_pages;
1467 dirty = true;
1468 }
1470 {
1471 pgcform->reltuples = (float4) num_tuples;
1472 dirty = true;
1473 }
1475 {
1476 pgcform->relallvisible = (int32) num_all_visible_pages;
1477 dirty = true;
1478 }
1480 {
1481 pgcform->relallfrozen = (int32) num_all_frozen_pages;
1482 dirty = true;
1483 }
1484
1485 /* Apply DDL updates, but not inside an outer transaction (see above) */
1486
1487 if (!in_outer_xact)
1488 {
1489 /*
1490 * If we didn't find any indexes, reset relhasindex.
1491 */
1492 if (pgcform->relhasindex && !hasindex)
1493 {
1494 pgcform->relhasindex = false;
1495 dirty = true;
1496 }
1497
1498 /* We also clear relhasrules and relhastriggers if needed */
1500 {
1501 pgcform->relhasrules = false;
1502 dirty = true;
1503 }
1505 {
1506 pgcform->relhastriggers = false;
1507 dirty = true;
1508 }
1509 }
1510
1511 /*
1512 * Update relfrozenxid, unless caller passed InvalidTransactionId
1513 * indicating it has no new data.
1514 *
1515 * Ordinarily, we don't let relfrozenxid go backwards. However, if the
1516 * stored relfrozenxid is "in the future" then it seems best to assume
1517 * it's corrupt, and overwrite with the oldest remaining XID in the table.
1518 * This should match vac_update_datfrozenxid() concerning what we consider
1519 * to be "in the future".
1520 */
1521 oldfrozenxid = pgcform->relfrozenxid;
1522 futurexid = false;
1523 if (frozenxid_updated)
1524 *frozenxid_updated = false;
1526 {
1527 bool update = false;
1528
1530 update = true;
1532 futurexid = update = true;
1533
1534 if (update)
1535 {
1536 pgcform->relfrozenxid = frozenxid;
1537 dirty = true;
1538 if (frozenxid_updated)
1539 *frozenxid_updated = true;
1540 }
1541 }
1542
1543 /* Similarly for relminmxid */
1544 oldminmulti = pgcform->relminmxid;
1545 futuremxid = false;
1546 if (minmulti_updated)
1547 *minmulti_updated = false;
1549 {
1550 bool update = false;
1551
1553 update = true;
1555 futuremxid = update = true;
1556
1557 if (update)
1558 {
1559 pgcform->relminmxid = minmulti;
1560 dirty = true;
1561 if (minmulti_updated)
1562 *minmulti_updated = true;
1563 }
1564 }
1565
1566 /* If anything changed, write out the tuple. */
1567 if (dirty)
1568 systable_inplace_update_finish(inplace_state, ctup);
1569 else
1570 systable_inplace_update_cancel(inplace_state);
1571
1573
1574 if (futurexid)
1578 oldfrozenxid, frozenxid,
1579 RelationGetRelationName(relation))));
1580 if (futuremxid)
1584 oldminmulti, minmulti,
1585 RelationGetRelationName(relation))));
1586}
References BTEqualStrategyNumber, elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, GETSTRUCT(), HeapTupleIsValid, sort-test::key, MultiXactIdIsValid, MultiXactIdPrecedes(), ObjectIdGetDatum(), RelationData::rd_rules, ReadNextMultiXactId(), ReadNextTransactionId(), RelationGetRelationName, RelationGetRelid, RowExclusiveLock, ScanKeyInit(), systable_inplace_update_begin(), systable_inplace_update_cancel(), systable_inplace_update_finish(), 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, |
| const VacuumParams | params, | ||
| BufferAccessStrategy | bstrategy, | ||
| MemoryContext | vac_context, | ||
| bool | isTopLevel | ||
| ) |
Definition at line 494 of file vacuum.c.
496{
497 static bool in_vacuum = false;
498
499 const char *stmttype;
500 volatile bool in_outer_xact,
501 use_own_xacts;
502
504
505 /*
506 * We cannot run VACUUM inside a user transaction block; if we were inside
507 * a transaction, then our commit- and start-transaction-command calls
508 * would not have the intended effect! There are numerous other subtle
509 * dependencies on this, too.
510 *
511 * ANALYZE (without VACUUM) can run either way.
512 */
514 {
515 PreventInTransactionBlock(isTopLevel, stmttype);
516 in_outer_xact = false;
517 }
518 else
519 in_outer_xact = IsInTransactionBlock(isTopLevel);
520
521 /*
522 * Check for and disallow recursive calls. This could happen when VACUUM
523 * FULL or ANALYZE calls a hostile index expression that itself calls
524 * ANALYZE.
525 */
526 if (in_vacuum)
528 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
530 stmttype)));
531
532 /*
533 * Build list of relation(s) to process, putting any new data in
534 * vac_context for safekeeping.
535 */
537 {
538 /* We don't process any tables in this case */
540 }
542 {
544 ListCell *lc;
545
546 foreach(lc, relations)
547 {
549 List *sublist;
550 MemoryContext old_context;
551
553 old_context = MemoryContextSwitchTo(vac_context);
554 newrels = list_concat(newrels, sublist);
555 MemoryContextSwitchTo(old_context);
556 }
557 relations = newrels;
558 }
559 else
561
562 /*
563 * Decide whether we need to start/commit our own transactions.
564 *
565 * For VACUUM (with or without ANALYZE): always do so, so that we can
566 * release locks as soon as possible. (We could possibly use the outer
567 * transaction for a one-table VACUUM, but handling TOAST tables would be
568 * problematic.)
569 *
570 * For ANALYZE (no VACUUM): if inside a transaction block, we cannot
571 * start/commit our own transactions. Also, there's no need to do so if
572 * only processing one relation. For multiple relations when not within a
573 * transaction block, and also in an autovacuum worker, use own
574 * transactions so we can release locks sooner.
575 */
577 use_own_xacts = true;
578 else
579 {
582 use_own_xacts = true;
583 else if (in_outer_xact)
584 use_own_xacts = false;
586 use_own_xacts = true;
587 else
588 use_own_xacts = false;
589 }
590
591 /*
592 * vacuum_rel expects to be entered with no transaction active; it will
593 * start and commit its own transaction. But we are called by an SQL
594 * command, and so we are executing inside a transaction already. We
595 * commit the transaction started in PostgresMain() here, and start
596 * another one before exiting to match the commit waiting for us back in
597 * PostgresMain().
598 */
599 if (use_own_xacts)
600 {
601 Assert(!in_outer_xact);
602
603 /* ActiveSnapshot is not set by autovacuum */
605 PopActiveSnapshot();
606
607 /* matches the StartTransaction in PostgresMain() */
608 CommitTransactionCommand();
609 }
610
611 /* Turn vacuum cost accounting on or off, and set/clear in_vacuum */
612 PG_TRY();
613 {
615
616 in_vacuum = true;
618 VacuumUpdateCosts();
619 VacuumCostBalance = 0;
620 VacuumCostBalanceLocal = 0;
621 VacuumSharedCostBalance = NULL;
622 VacuumActiveNWorkers = NULL;
623
624 /*
625 * Loop to process each selected relation.
626 */
628 {
630
632 {
634 continue;
635 }
636
638 {
639 /*
640 * If using separate xacts, start one for analyze. Otherwise,
641 * we can use the outer transaction.
642 */
643 if (use_own_xacts)
644 {
645 StartTransactionCommand();
646 /* functions in indexes may want a snapshot set */
648 }
649
651 vrel->va_cols, in_outer_xact, bstrategy);
652
653 if (use_own_xacts)
654 {
655 PopActiveSnapshot();
656 /* standard_ProcessUtility() does CCI if !use_own_xacts */
657 CommandCounterIncrement();
658 CommitTransactionCommand();
659 }
660 else
661 {
662 /*
663 * If we're not using separate xacts, better separate the
664 * ANALYZE actions with CCIs. This avoids trouble if user
665 * says "ANALYZE t, t".
666 */
667 CommandCounterIncrement();
668 }
669 }
670
671 /*
672 * Ensure VacuumFailsafeActive has been reset before vacuuming the
673 * next relation.
674 */
676 }
677 }
678 PG_FINALLY();
679 {
680 in_vacuum = false;
683 VacuumCostBalance = 0;
684 }
685 PG_END_TRY();
686
687 /*
688 * Finish up processing.
689 */
690 if (use_own_xacts)
691 {
692 /* here, we are not in a transaction */
693
694 /*
695 * This matches the CommitTransaction waiting for us in
696 * PostgresMain().
697 */
698 StartTransactionCommand();
699 }
700
703 {
704 /*
705 * Update pg_database.datfrozenxid, and truncate pg_xact if possible.
706 */
707 vac_update_datfrozenxid();
708 }
709
710}
void analyze_rel(Oid relid, RangeVar *relation, const VacuumParams params, List *va_cols, bool in_outer_xact, BufferAccessStrategy bstrategy)
Definition: analyze.c:108
static List * expand_vacuum_rel(VacuumRelation *vrel, MemoryContext vac_context, int options)
Definition: vacuum.c:883
static List * get_all_vacuum_rels(MemoryContext vac_context, int options)
Definition: vacuum.c:1038
static bool vacuum_rel(Oid relid, RangeVar *relation, VacuumParams params, BufferAccessStrategy bstrategy)
Definition: vacuum.c:2002
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3666
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, 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 | ( | bool | is_analyze | ) |
Definition at line 2426 of file vacuum.c.
2427{
2428 double msec = 0;
2429
2430 /* Always check for interrupts */
2431 CHECK_FOR_INTERRUPTS();
2432
2435 return;
2436
2437 /*
2438 * Autovacuum workers should reload the configuration file if requested.
2439 * This allows changes to [autovacuum_]vacuum_cost_limit and
2440 * [autovacuum_]vacuum_cost_delay to take effect while a table is being
2441 * vacuumed or analyzed.
2442 */
2444 {
2447 VacuumUpdateCosts();
2448 }
2449
2450 /*
2451 * If we disabled cost-based delays after reloading the config file,
2452 * return.
2453 */
2455 return;
2456
2457 /*
2458 * For parallel vacuum, the delay is computed based on the shared cost
2459 * balance. See compute_parallel_delay.
2460 */
2462 msec = compute_parallel_delay();
2465
2466 /* Nap if appropriate */
2467 if (msec > 0)
2468 {
2469 instr_time delay_start;
2470
2472 msec = vacuum_cost_delay * 4;
2473
2475 INSTR_TIME_SET_CURRENT(delay_start);
2476
2477 pgstat_report_wait_start(WAIT_EVENT_VACUUM_DELAY);
2478 pg_usleep(msec * 1000);
2479 pgstat_report_wait_end();
2480
2482 {
2483 instr_time delay_end;
2484 instr_time delay;
2485
2486 INSTR_TIME_SET_CURRENT(delay_end);
2487 INSTR_TIME_SET_ZERO(delay);
2488 INSTR_TIME_ACCUM_DIFF(delay, delay_end, delay_start);
2489
2490 /*
2491 * For parallel workers, we only report the delay time every once
2492 * in a while to avoid overloading the leader with messages and
2493 * interrupts.
2494 */
2496 {
2498 instr_time time_since_last_report;
2499
2500 Assert(!is_analyze);
2501
2502 /* Accumulate the delay time */
2504
2505 /* Calculate interval since last report */
2506 INSTR_TIME_SET_ZERO(time_since_last_report);
2507 INSTR_TIME_ACCUM_DIFF(time_since_last_report, delay_end, last_report_time);
2508
2509 /* If we haven't reported in a while, do so now */
2512 {
2515
2516 /* Reset variables */
2517 last_report_time = delay_end;
2518 parallel_vacuum_worker_delay_ns = 0;
2519 }
2520 }
2521 else if (is_analyze)
2523 INSTR_TIME_GET_NANOSEC(delay));
2524 else
2526 INSTR_TIME_GET_NANOSEC(delay));
2527 }
2528
2529 /*
2530 * We don't want to ignore postmaster death during very long vacuums
2531 * with vacuum_cost_delay configured. We can't use the usual
2532 * WaitLatch() approach here because we want microsecond-based sleep
2533 * durations above.
2534 */
2536 exit(1);
2537
2538 VacuumCostBalance = 0;
2539
2540 /*
2541 * Balance and update limit values for autovacuum workers. We must do
2542 * this periodically, as the number of workers across which we are
2543 * balancing the limit may have changed.
2544 *
2545 * TODO: There may be better criteria for determining when to do this
2546 * besides "check after napping".
2547 */
2548 AutoVacuumUpdateCostLimit();
2549
2550 /* Might have gotten an interrupt while sleeping */
2551 CHECK_FOR_INTERRUPTS();
2552 }
2553}
void pgstat_progress_parallel_incr_param(int index, int64 incr)
Definition: backend_progress.c:91
void pgstat_progress_incr_param(int index, int64 incr)
Definition: backend_progress.c:69
Definition: instr_time.h:70
#define PARALLEL_VACUUM_DELAY_REPORT_INTERVAL_NS
Definition: vacuum.c:70
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:69
References AmAutoVacuumWorkerProcess, Assert(), AutoVacuumUpdateCostLimit(), CHECK_FOR_INTERRUPTS, compute_parallel_delay(), ConfigReloadPending, INSTR_TIME_ACCUM_DIFF, INSTR_TIME_GET_NANOSEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SET_ZERO, InterruptPending, IsParallelWorker, IsUnderPostmaster, PARALLEL_VACUUM_DELAY_REPORT_INTERVAL_NS, parallel_vacuum_worker_delay_ns, pg_usleep(), PGC_SIGHUP, pgstat_progress_incr_param(), pgstat_progress_parallel_incr_param(), pgstat_report_wait_end(), pgstat_report_wait_start(), PostmasterIsAlive, ProcessConfigFile(), PROGRESS_ANALYZE_DELAY_TIME, PROGRESS_VACUUM_DELAY_TIME, track_cost_delay_timing, vacuum_cost_delay, vacuum_cost_limit, VacuumCostActive, VacuumCostBalance, VacuumSharedCostBalance, and VacuumUpdateCosts().
Referenced by acquire_sample_rows(), blbulkdelete(), blvacuumcleanup(), btvacuumpage(), btvacuumscan(), 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(), gistvacuumscan(), hashbucketcleanup(), lazy_scan_heap(), lazy_vacuum_heap_rel(), spgprocesspending(), and spgvacuumscan().
◆ vacuum_get_cutoffs()
| bool vacuum_get_cutoffs | ( | Relation | rel, |
| const VacuumParams | params, | ||
| struct VacuumCutoffs * | cutoffs | ||
| ) |
Definition at line 1100 of file vacuum.c.
1102{
1103 int freeze_min_age,
1104 multixact_freeze_min_age,
1105 freeze_table_age,
1106 multixact_freeze_table_age,
1107 effective_multixact_freeze_max_age;
1108 TransactionId nextXID,
1109 safeOldestXmin,
1110 aggressiveXIDCutoff;
1111 MultiXactId nextMXID,
1112 safeOldestMxact,
1113 aggressiveMXIDCutoff;
1114
1115 /* Use mutable copies of freeze age parameters */
1116 freeze_min_age = params.freeze_min_age;
1117 multixact_freeze_min_age = params.multixact_freeze_min_age;
1118 freeze_table_age = params.freeze_table_age;
1119 multixact_freeze_table_age = params.multixact_freeze_table_age;
1120
1121 /* Set pg_class fields in cutoffs */
1124
1125 /*
1126 * Acquire OldestXmin.
1127 *
1128 * We can always ignore processes running lazy vacuum. This is because we
1129 * use these values only for deciding which tuples we must keep in the
1130 * tables. Since lazy vacuum doesn't write its XID anywhere (usually no
1131 * XID assigned), it's safe to ignore it. In theory it could be
1132 * problematic to ignore lazy vacuums in a full vacuum, but keep in mind
1133 * that only one vacuum process can be working on a particular table at
1134 * any time, and that each vacuum is always an independent transaction.
1135 */
1137
1139
1140 /* Acquire OldestMxact */
1143
1144 /* Acquire next XID/next MXID values used to apply age-based settings */
1145 nextXID = ReadNextTransactionId();
1146 nextMXID = ReadNextMultiXactId();
1147
1148 /*
1149 * Also compute the multixact age for which freezing is urgent. This is
1150 * normally autovacuum_multixact_freeze_max_age, but may be less if
1151 * multixact members are bloated.
1152 */
1153 effective_multixact_freeze_max_age = MultiXactMemberFreezeThreshold();
1154
1155 /*
1156 * Almost ready to set freeze output parameters; check if OldestXmin or
1157 * OldestMxact are held back to an unsafe degree before we start on that
1158 */
1159 safeOldestXmin = nextXID - autovacuum_freeze_max_age;
1161 safeOldestXmin = FirstNormalTransactionId;
1162 safeOldestMxact = nextMXID - effective_multixact_freeze_max_age;
1164 safeOldestMxact = FirstMultiXactId;
1169 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1174 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
1175
1176 /*
1177 * Determine the minimum freeze age to use: as specified by the caller, or
1178 * vacuum_freeze_min_age, but in any case not more than half
1179 * autovacuum_freeze_max_age, so that autovacuums to prevent XID
1180 * wraparound won't occur too frequently.
1181 */
1182 if (freeze_min_age < 0)
1183 freeze_min_age = vacuum_freeze_min_age;
1185 Assert(freeze_min_age >= 0);
1186
1187 /* Compute FreezeLimit, being careful to generate a normal XID */
1188 cutoffs->FreezeLimit = nextXID - freeze_min_age;
1191 /* FreezeLimit must always be <= OldestXmin */
1194
1195 /*
1196 * Determine the minimum multixact freeze age to use: as specified by
1197 * caller, or vacuum_multixact_freeze_min_age, but in any case not more
1198 * than half effective_multixact_freeze_max_age, so that autovacuums to
1199 * prevent MultiXact wraparound won't occur too frequently.
1200 */
1201 if (multixact_freeze_min_age < 0)
1202 multixact_freeze_min_age = vacuum_multixact_freeze_min_age;
1203 multixact_freeze_min_age = Min(multixact_freeze_min_age,
1204 effective_multixact_freeze_max_age / 2);
1205 Assert(multixact_freeze_min_age >= 0);
1206
1207 /* Compute MultiXactCutoff, being careful to generate a valid value */
1208 cutoffs->MultiXactCutoff = nextMXID - multixact_freeze_min_age;
1211 /* MultiXactCutoff must always be <= OldestMxact */
1214
1215 /*
1216 * Finally, figure out if caller needs to do an aggressive VACUUM or not.
1217 *
1218 * Determine the table freeze age to use: as specified by the caller, or
1219 * the value of the vacuum_freeze_table_age GUC, but in any case not more
1220 * than autovacuum_freeze_max_age * 0.95, so that if you have e.g nightly
1221 * VACUUM schedule, the nightly VACUUM gets a chance to freeze XIDs before
1222 * anti-wraparound autovacuum is launched.
1223 */
1224 if (freeze_table_age < 0)
1225 freeze_table_age = vacuum_freeze_table_age;
1227 Assert(freeze_table_age >= 0);
1228 aggressiveXIDCutoff = nextXID - freeze_table_age;
1230 aggressiveXIDCutoff = FirstNormalTransactionId;
1232 aggressiveXIDCutoff))
1233 return true;
1234
1235 /*
1236 * Similar to the above, determine the table freeze age to use for
1237 * multixacts: as specified by the caller, or the value of the
1238 * vacuum_multixact_freeze_table_age GUC, but in any case not more than
1239 * effective_multixact_freeze_max_age * 0.95, so that if you have e.g.
1240 * nightly VACUUM schedule, the nightly VACUUM gets a chance to freeze
1241 * multixacts before anti-wraparound autovacuum is launched.
1242 */
1243 if (multixact_freeze_table_age < 0)
1244 multixact_freeze_table_age = vacuum_multixact_freeze_table_age;
1245 multixact_freeze_table_age =
1246 Min(multixact_freeze_table_age,
1247 effective_multixact_freeze_max_age * 0.95);
1248 Assert(multixact_freeze_table_age >= 0);
1249 aggressiveMXIDCutoff = nextMXID - multixact_freeze_table_age;
1251 aggressiveMXIDCutoff = FirstMultiXactId;
1253 aggressiveMXIDCutoff))
1254 return true;
1255
1256 /* Non-aggressive VACUUM */
1257 return false;
1258}
bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:2842
static bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
Definition: transam.h:282
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 719 of file vacuum.c.
721{
723
725
726 /*----------
727 * A role has privileges to vacuum or analyze the relation if any of the
728 * following are true:
729 * - the role owns the current database and the relation is not shared
730 * - the role has the MAINTAIN privilege on the relation
731 *----------
732 */
734 !reltuple->relisshared) ||
736 return true;
737
739
741 {
744 relname)));
745
746 /*
747 * For VACUUM ANALYZE, both logs could show up, but just generate
748 * information for VACUUM as that would be the first one to be
749 * processed.
750 */
751 return false;
752 }
753
757 relname)));
758
759 return false;
760}
bool object_ownercheck(Oid classid, Oid objectid, Oid roleid)
Definition: aclchk.c:4090
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4039
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 771 of file vacuum.c.
773{
774 Relation rel;
775 bool rel_lock = true;
776 int elevel;
777
779
780 /*
781 * Open the relation and get the appropriate lock on it.
782 *
783 * There's a race condition here: the relation may have gone away since
784 * the last time we saw it. If so, we don't need to vacuum or analyze it.
785 *
786 * If we've been asked not to wait for the relation lock, acquire it first
787 * in non-blocking mode, before calling try_relation_open().
788 */
790 rel = try_relation_open(relid, lmode);
793 else
794 {
795 rel = NULL;
796 rel_lock = false;
797 }
798
799 /* if relation is opened, leave */
800 if (rel)
801 return rel;
802
803 /*
804 * Relation could not be opened, hence generate if possible a log
805 * informing on the situation.
806 *
807 * If the RangeVar is not defined, we do not have enough information to
808 * provide a meaningful log statement. Chances are that the caller has
809 * intentionally not provided this information so that this logging is
810 * skipped, anyway.
811 */
812 if (relation == NULL)
813 return NULL;
814
815 /*
816 * Determine the log level.
817 *
818 * For manual VACUUM or ANALYZE, we emit a WARNING to match the log
819 * statements in the permission checks; otherwise, only log if the caller
820 * so requested.
821 */
823 elevel = WARNING;
825 elevel = LOG;
826 else
827 return NULL;
828
830 {
831 if (!rel_lock)
832 ereport(elevel,
833 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
835 relation->relname)));
836 else
837 ereport(elevel,
840 relation->relname)));
841
842 /*
843 * For VACUUM ANALYZE, both logs could show up, but just generate
844 * information for VACUUM as that would be the first one to be
845 * processed.
846 */
847 return NULL;
848 }
849
851 {
852 if (!rel_lock)
853 ereport(elevel,
854 (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
856 relation->relname)));
857 else
858 ereport(elevel,
861 relation->relname)));
862 }
863
864 return NULL;
865}
bool ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode)
Definition: lmgr.c:151
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 |
Definition at line 2002 of file vacuum.c.
2004{
2005 LOCKMODE lmode;
2006 Relation rel;
2007 LockRelId lockrelid;
2008 Oid priv_relid;
2009 Oid toast_relid;
2010 Oid save_userid;
2011 int save_sec_context;
2012 int save_nestlevel;
2013 VacuumParams toast_vacuum_params;
2014
2015 /*
2016 * This function scribbles on the parameters, so make a copy early to
2017 * avoid affecting the TOAST table (if we do end up recursing to it).
2018 */
2020
2021 /* Begin a transaction for vacuuming this relation */
2022 StartTransactionCommand();
2023
2025 {
2026 /*
2027 * In lazy vacuum, we can set the PROC_IN_VACUUM flag, which lets
2028 * other concurrent VACUUMs know that they can ignore this one while
2029 * determining their OldestXmin. (The reason we don't set it during a
2030 * full VACUUM is exactly that we may have to run user-defined
2031 * functions for functional indexes, and we want to make sure that if
2032 * they use the snapshot set above, any tuples it requires can't get
2033 * removed from other tables. An index function that depends on the
2034 * contents of other tables is arguably broken, but we won't break it
2035 * here by violating transaction semantics.)
2036 *
2037 * We also set the VACUUM_FOR_WRAPAROUND flag, which is passed down by
2038 * autovacuum; it's used to avoid canceling a vacuum that was invoked
2039 * in an emergency.
2040 *
2041 * Note: these flags remain set until CommitTransaction or
2042 * AbortTransaction. We don't want to clear them until we reset
2043 * MyProc->xid/xmin, otherwise GetOldestNonRemovableTransactionId()
2044 * might appear to go backwards, which is probably Not Good. (We also
2045 * set PROC_IN_VACUUM *before* taking our own snapshot, so that our
2046 * xmin doesn't become visible ahead of setting the flag.)
2047 */
2053 LWLockRelease(ProcArrayLock);
2054 }
2055
2056 /*
2057 * Need to acquire a snapshot to prevent pg_subtrans from being truncated,
2058 * cutoff xids in local memory wrapping around, and to have updated xmin
2059 * horizons.
2060 */
2062
2063 /*
2064 * Check for user-requested abort. Note we want this to be inside a
2065 * transaction, so xact.c doesn't issue useless WARNING.
2066 */
2067 CHECK_FOR_INTERRUPTS();
2068
2069 /*
2070 * Determine the type of lock we want --- hard exclusive lock for a FULL
2071 * vacuum, but just ShareUpdateExclusiveLock for concurrent vacuum. Either
2072 * way, we can be sure that no other backend is vacuuming the same table.
2073 */
2076
2077 /* open the relation and get the appropriate lock on it */
2079 params.log_vacuum_min_duration >= 0, lmode);
2080
2081 /* leave if relation could not be opened or locked */
2082 if (!rel)
2083 {
2084 PopActiveSnapshot();
2085 CommitTransactionCommand();
2086 return false;
2087 }
2088
2089 /*
2090 * When recursing to a TOAST table, check privileges on the parent. NB:
2091 * This is only safe to do because we hold a session lock on the main
2092 * relation that prevents concurrent deletion.
2093 */
2095 priv_relid = params.toast_parent;
2096 else
2097 priv_relid = RelationGetRelid(rel);
2098
2099 /*
2100 * Check if relation needs to be skipped based on privileges. This check
2101 * happens also when building the relation list to vacuum for a manual
2102 * operation, and needs to be done additionally here as VACUUM could
2103 * happen across multiple transactions where privileges could have changed
2104 * in-between. Make sure to only generate logs for VACUUM in this case.
2105 */
2107 rel->rd_rel,
2109 {
2110 relation_close(rel, lmode);
2111 PopActiveSnapshot();
2112 CommitTransactionCommand();
2113 return false;
2114 }
2115
2116 /*
2117 * Check that it's of a vacuumable relkind.
2118 */
2120 rel->rd_rel->relkind != RELKIND_MATVIEW &&
2121 rel->rd_rel->relkind != RELKIND_TOASTVALUE &&
2122 rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
2123 {
2126 RelationGetRelationName(rel))));
2127 relation_close(rel, lmode);
2128 PopActiveSnapshot();
2129 CommitTransactionCommand();
2130 return false;
2131 }
2132
2133 /*
2134 * Silently ignore tables that are temp tables of other backends ---
2135 * trying to vacuum these will lead to great unhappiness, since their
2136 * contents are probably not up-to-date on disk. (We don't throw a
2137 * warning here; it would just lead to chatter during a database-wide
2138 * VACUUM.)
2139 */
2141 {
2142 relation_close(rel, lmode);
2143 PopActiveSnapshot();
2144 CommitTransactionCommand();
2145 return false;
2146 }
2147
2148 /*
2149 * Silently ignore partitioned tables as there is no work to be done. The
2150 * useful work is on their child partitions, which have been queued up for
2151 * us separately.
2152 */
2154 {
2155 relation_close(rel, lmode);
2156 PopActiveSnapshot();
2157 CommitTransactionCommand();
2158 /* It's OK to proceed with ANALYZE on this table */
2159 return true;
2160 }
2161
2162 /*
2163 * Get a session-level lock too. This will protect our access to the
2164 * relation across multiple transactions, so that we can vacuum the
2165 * relation's TOAST table (if any) secure in the knowledge that no one is
2166 * deleting the parent relation.
2167 *
2168 * NOTE: this cannot block, even if someone else is waiting for access,
2169 * because the lock manager knows that both lock requests are from the
2170 * same process.
2171 */
2173 LockRelationIdForSession(&lockrelid, lmode);
2174
2175 /*
2176 * Set index_cleanup option based on index_cleanup reloption if it wasn't
2177 * specified in VACUUM command, or when running in an autovacuum worker
2178 */
2180 {
2181 StdRdOptIndexCleanup vacuum_index_cleanup;
2182
2184 vacuum_index_cleanup = STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO;
2185 else
2186 vacuum_index_cleanup =
2188
2193 else
2194 {
2195 Assert(vacuum_index_cleanup ==
2198 }
2199 }
2200
2201#ifdef USE_INJECTION_POINTS
2208#endif
2209
2210 /*
2211 * Check if the vacuum_max_eager_freeze_failure_rate table storage
2212 * parameter was specified. This overrides the GUC value.
2213 */
2216 params.max_eager_freeze_failure_rate =
2218
2219 /*
2220 * Set truncate option based on truncate reloption or GUC if it wasn't
2221 * specified in VACUUM command, or when running in an autovacuum worker
2222 */
2224 {
2226
2228 {
2231 else
2233 }
2236 else
2238 }
2239
2240#ifdef USE_INJECTION_POINTS
2247#endif
2248
2249 /*
2250 * Remember the relation's TOAST relation for later, if the caller asked
2251 * us to process it. In VACUUM FULL, though, the toast table is
2252 * automatically rebuilt by cluster_rel so we shouldn't recurse to it,
2253 * unless PROCESS_MAIN is disabled.
2254 */
2258 toast_relid = rel->rd_rel->reltoastrelid;
2259 else
2260 toast_relid = InvalidOid;
2261
2262 /*
2263 * Switch to the table owner's userid, so that any index functions are run
2264 * as that user. Also lock down security-restricted operations and
2265 * arrange to make GUC variable changes local to this command. (This is
2266 * unnecessary, but harmless, for lazy VACUUM.)
2267 */
2268 GetUserIdAndSecContext(&save_userid, &save_sec_context);
2270 save_sec_context | SECURITY_RESTRICTED_OPERATION);
2271 save_nestlevel = NewGUCNestLevel();
2272 RestrictSearchPath();
2273
2274 /*
2275 * If PROCESS_MAIN is set (the default), it's time to vacuum the main
2276 * relation. Otherwise, we can skip this part. If processing the TOAST
2277 * table is required (e.g., PROCESS_TOAST is set), we force PROCESS_MAIN
2278 * to be set when we recurse to the TOAST table.
2279 */
2281 {
2282 /*
2283 * Do the actual work --- either FULL or "lazy" vacuum
2284 */
2286 {
2287 ClusterParams cluster_params = {0};
2288
2291
2292 /* VACUUM FULL is now a variant of CLUSTER; see cluster.c */
2294 /* cluster_rel closes the relation, but keeps lock */
2295
2296 rel = NULL;
2297 }
2298 else
2299 table_relation_vacuum(rel, params, bstrategy);
2300 }
2301
2302 /* Roll back any GUC changes executed by index functions */
2304
2305 /* Restore userid and security context */
2306 SetUserIdAndSecContext(save_userid, save_sec_context);
2307
2308 /* all done with this class, but hold lock until commit */
2309 if (rel)
2311
2312 /*
2313 * Complete the transaction and free all temporary memory used.
2314 */
2315 PopActiveSnapshot();
2316 CommitTransactionCommand();
2317
2318 /*
2319 * If the relation has a secondary toast rel, vacuum that too while we
2320 * still hold the session lock on the main table. Note however that
2321 * "analyze" will not get done on the toast table. This is good, because
2322 * the toaster always uses hardcoded index access and statistics are
2323 * totally unimportant for toast relations.
2324 */
2326 {
2327 /*
2328 * Force VACOPT_PROCESS_MAIN so vacuum_rel() processes it. Likewise,
2329 * set toast_parent so that the privilege checks are done on the main
2330 * relation. NB: This is only safe to do because we hold a session
2331 * lock on the main relation that prevents concurrent deletion.
2332 */
2334 toast_vacuum_params.toast_parent = relid;
2335
2336 vacuum_rel(toast_relid, NULL, toast_vacuum_params, bstrategy);
2337 }
2338
2339 /*
2340 * Now release the session-level lock on the main table.
2341 */
2342 UnlockRelationIdForSession(&lockrelid, lmode);
2343
2344 /* Report that we really did it. */
2345 return true;
2346}
void cluster_rel(Relation OldHeap, Oid indexOid, ClusterParams *params)
Definition: cluster.c:311
void LockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:391
void UnlockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:404
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
Definition: miscinit.c:612
void SetUserIdAndSecContext(Oid userid, int sec_context)
Definition: miscinit.c:619
Definition: cluster.h:29
Definition: rel.h:342
static void table_relation_vacuum(Relation rel, const VacuumParams params, BufferAccessStrategy bstrategy)
Definition: tableam.h:1686
Relation vacuum_open_relation(Oid relid, RangeVar *relation, bits32 options, bool verbose, LOCKMODE lmode)
Definition: vacuum.c:771
References AccessExclusiveLock, Assert(), AtEOXact_GUC(), CHECK_FOR_INTERRUPTS, CLUOPT_VERBOSE, cluster_rel(), CommitTransactionCommand(), ereport, errmsg(), GetTransactionSnapshot(), GetUserIdAndSecContext(), if(), VacuumParams::index_cleanup, INJECTION_POINT, InvalidOid, VacuumParams::is_wraparound, LockRelationIdForSession(), LockInfoData::lockRelId, VacuumParams::log_vacuum_min_duration, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VacuumParams::max_eager_freeze_failure_rate, MyProc, NewGUCNestLevel(), NoLock, OidIsValid, ClusterParams::options, VacuumParams::options, opts, 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(), vacuum_rel(), vacuum_truncate, and WARNING.
Referenced by vacuum(), and vacuum_rel().
◆ vacuum_xid_failsafe_check()
| bool vacuum_xid_failsafe_check | ( | const struct VacuumCutoffs * | cutoffs | ) |
Definition at line 1268 of file vacuum.c.
1269{
1272 TransactionId xid_skip_limit;
1273 MultiXactId multi_skip_limit;
1274 int skip_index_vacuum;
1275
1278
1279 /*
1280 * Determine the index skipping age to use. In any case no less than
1281 * autovacuum_freeze_max_age * 1.05.
1282 */
1284
1285 xid_skip_limit = ReadNextTransactionId() - skip_index_vacuum;
1287 xid_skip_limit = FirstNormalTransactionId;
1288
1290 {
1291 /* The table's relfrozenxid is too old */
1292 return true;
1293 }
1294
1295 /*
1296 * Similar to above, determine the index skipping age to use for
1297 * multixact. In any case no less than autovacuum_multixact_freeze_max_age *
1298 * 1.05.
1299 */
1301 autovacuum_multixact_freeze_max_age * 1.05);
1302
1303 multi_skip_limit = ReadNextMultiXactId() - skip_index_vacuum;
1305 multi_skip_limit = FirstMultiXactId;
1306
1308 {
1309 /* The table's relminmxid is too old */
1310 return true;
1311 }
1312
1313 return false;
1314}
int autovacuum_multixact_freeze_max_age
Definition: autovacuum.c:130
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
◆ parallel_vacuum_worker_delay_ns
| int64 parallel_vacuum_worker_delay_ns = 0 |
Definition at line 95 of file vacuum.c.
Referenced by parallel_vacuum_main(), and vacuum_delay_point().
◆ track_cost_delay_timing
| bool track_cost_delay_timing |
Definition at line 82 of file vacuum.c.
Referenced by do_analyze_rel(), heap_vacuum_rel(), parallel_vacuum_main(), and vacuum_delay_point().
◆ vacuum_cost_delay
| double vacuum_cost_delay = 0 |
Definition at line 91 of file vacuum.c.
Referenced by compute_parallel_delay(), default_reloptions(), vacuum_delay_point(), and VacuumUpdateCosts().
◆ vacuum_cost_limit
| int vacuum_cost_limit = 200 |
Definition at line 92 of file vacuum.c.
Referenced by AutoVacuumUpdateCostLimit(), compute_parallel_delay(), default_reloptions(), vacuum_delay_point(), and VacuumUpdateCosts().
◆ vacuum_failsafe_age
| int vacuum_failsafe_age |
Definition at line 79 of file vacuum.c.
Referenced by vacuum_xid_failsafe_check().
◆ vacuum_freeze_min_age
| int vacuum_freeze_min_age |
Definition at line 75 of file vacuum.c.
Referenced by do_autovacuum(), and vacuum_get_cutoffs().
◆ vacuum_freeze_table_age
| int vacuum_freeze_table_age |
Definition at line 76 of file vacuum.c.
Referenced by do_autovacuum(), and vacuum_get_cutoffs().
◆ vacuum_max_eager_freeze_failure_rate
| double vacuum_max_eager_freeze_failure_rate |
Definition at line 81 of file vacuum.c.
Referenced by default_reloptions(), ExecVacuum(), and table_recheck_autovac().
◆ vacuum_multixact_failsafe_age
| int vacuum_multixact_failsafe_age |
Definition at line 80 of file vacuum.c.
Referenced by vacuum_xid_failsafe_check().
◆ vacuum_multixact_freeze_min_age
| int vacuum_multixact_freeze_min_age |
Definition at line 77 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 78 of file vacuum.c.
Referenced by do_autovacuum(), and vacuum_get_cutoffs().
◆ vacuum_truncate
| bool vacuum_truncate |
Definition at line 83 of file vacuum.c.
Referenced by default_reloptions(), and vacuum_rel().
◆ VacuumActiveNWorkers
| pg_atomic_uint32* VacuumActiveNWorkers = NULL |
Definition at line 117 of file vacuum.c.
Referenced by compute_parallel_delay(), parallel_vacuum_main(), parallel_vacuum_process_all_indexes(), parallel_vacuum_process_safe_indexes(), parallel_vacuum_process_unsafe_indexes(), and vacuum().
◆ VacuumCostBalanceLocal
| int VacuumCostBalanceLocal = 0 |
Definition at line 118 of file vacuum.c.
Referenced by compute_parallel_delay(), parallel_vacuum_main(), parallel_vacuum_process_all_indexes(), and vacuum().
◆ VacuumFailsafeActive
| bool VacuumFailsafeActive = false |
Definition at line 110 of file vacuum.c.
Referenced by heap_vacuum_rel(), lazy_check_wraparound_failsafe(), lazy_vacuum(), lazy_vacuum_all_indexes(), should_attempt_truncation(), vacuum(), and VacuumUpdateCosts().
◆ VacuumSharedCostBalance
| pg_atomic_uint32* VacuumSharedCostBalance = NULL |
Definition at line 116 of file vacuum.c.
Referenced by compute_parallel_delay(), parallel_vacuum_main(), parallel_vacuum_process_all_indexes(), vacuum(), and vacuum_delay_point().
