#include "access/htup.h"
#include "access/genam.h"
#include "access/parallel.h"
#include "access/tidstore.h"
#include "catalog/pg_class.h"
#include "catalog/pg_statistic.h"
#include "catalog/pg_type.h"
#include "parser/parse_node.h"
#include "storage/buf.h"
#include "storage/lock.h"
#include "utils/relcache.h"

Include dependency graph for vacuum.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	VacAttrStats

struct	VacuumParams

struct	VacuumCutoffs

struct	VacDeadItemsInfo

Macros
#define	VACUUM_OPTION_NO_PARALLEL 0

#define	VACUUM_OPTION_PARALLEL_BULKDEL (1 << 0)

#define	VACUUM_OPTION_PARALLEL_COND_CLEANUP (1 << 1)

#define	VACUUM_OPTION_PARALLEL_CLEANUP (1 << 2)

#define	VACUUM_OPTION_MAX_VALID_VALUE ((1 << 3) - 1)

#define	VACOPT_VACUUM 0x01 /* do VACUUM */

#define	VACOPT_ANALYZE 0x02 /* do ANALYZE */

#define	VACOPT_VERBOSE 0x04 /* output INFO instrumentation messages */

#define	VACOPT_FREEZE 0x08 /* FREEZE option */

#define	VACOPT_FULL 0x10 /* FULL (non-concurrent) vacuum */

#define	VACOPT_SKIP_LOCKED 0x20 /* skip if cannot get lock */

#define	VACOPT_PROCESS_MAIN 0x40 /* process main relation */

#define	VACOPT_PROCESS_TOAST 0x80 /* process the TOAST table, if any */

#define	VACOPT_DISABLE_PAGE_SKIPPING 0x100 /* don't skip any pages */

#define	VACOPT_SKIP_DATABASE_STATS 0x200 /* skip vac_update_datfrozenxid() */

#define	VACOPT_ONLY_DATABASE_STATS 0x400 /* only vac_update_datfrozenxid() */

#define	MAX_STATISTICS_TARGET 10000

Typedefs
typedef struct ParallelVacuumState	ParallelVacuumState

typedef struct VacAttrStats *	VacAttrStatsP

typedef Datum(*	AnalyzeAttrFetchFunc) (VacAttrStatsP stats, int rownum, bool *isNull)

typedef void(*	AnalyzeAttrComputeStatsFunc) (VacAttrStatsP stats, AnalyzeAttrFetchFunc fetchfunc, int samplerows, double totalrows)

typedef struct VacAttrStats	VacAttrStats

typedef enum VacOptValue	VacOptValue

typedef struct VacuumParams	VacuumParams

typedef struct VacDeadItemsInfo	VacDeadItemsInfo

Enumerations
enum	VacOptValue { VACOPTVALUE_UNSPECIFIED = 0 , VACOPTVALUE_AUTO , VACOPTVALUE_DISABLED , VACOPTVALUE_ENABLED }

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

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

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

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

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, BlockNumber num_all_frozen_pages, bool hasindex, TransactionId frozenxid, MultiXactId minmulti, bool frozenxid_updated, bool minmulti_updated, bool in_outer_xact)

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

bool	vacuum_xid_failsafe_check (const struct VacuumCutoffs *cutoffs)

void	vac_update_datfrozenxid (void)

void	vacuum_delay_point (bool is_analyze)

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)

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

IndexBulkDeleteResult *	vac_cleanup_one_index (IndexVacuumInfo ivinfo, IndexBulkDeleteResult istat)

void	AutoVacuumUpdateCostLimit (void)

void	VacuumUpdateCosts (void)

ParallelVacuumState *	parallel_vacuum_init (Relation rel, Relation *indrels, int nindexes, int nrequested_workers, int vac_work_mem, int elevel, BufferAccessStrategy bstrategy)

void	parallel_vacuum_end (ParallelVacuumState pvs, IndexBulkDeleteResult *istats)

TidStore *	parallel_vacuum_get_dead_items (ParallelVacuumState pvs, VacDeadItemsInfo *dead_items_info_p)

void	parallel_vacuum_reset_dead_items (ParallelVacuumState *pvs)

void	parallel_vacuum_bulkdel_all_indexes (ParallelVacuumState *pvs, long num_table_tuples, int num_index_scans)

void	parallel_vacuum_cleanup_all_indexes (ParallelVacuumState *pvs, long num_table_tuples, int num_index_scans, bool estimated_count)

void	parallel_vacuum_main (dsm_segment seg, shm_toc toc)

void	analyze_rel (Oid relid, RangeVar relation, const VacuumParams params, List va_cols, bool in_outer_xact, BufferAccessStrategy bstrategy)

bool	std_typanalyze (VacAttrStats *stats)

double	anl_random_fract (void)

double	anl_init_selection_state (int n)

double	anl_get_next_S (double t, int n, double *stateptr)

Macro Definition Documentation

◆ MAX_STATISTICS_TARGET

#define MAX_STATISTICS_TARGET 10000

Definition at line 324 of file vacuum.h.

◆ VACOPT_ANALYZE

#define VACOPT_ANALYZE 0x02 /* do ANALYZE */

Definition at line 181 of file vacuum.h.

◆ VACOPT_DISABLE_PAGE_SKIPPING

#define VACOPT_DISABLE_PAGE_SKIPPING 0x100 /* don't skip any pages */

Definition at line 188 of file vacuum.h.

◆ VACOPT_FREEZE

#define VACOPT_FREEZE 0x08 /* FREEZE option */

Definition at line 183 of file vacuum.h.

◆ VACOPT_FULL

#define VACOPT_FULL 0x10 /* FULL (non-concurrent) vacuum */

Definition at line 184 of file vacuum.h.

◆ VACOPT_ONLY_DATABASE_STATS

#define VACOPT_ONLY_DATABASE_STATS 0x400 /* only vac_update_datfrozenxid() */

Definition at line 190 of file vacuum.h.

◆ VACOPT_PROCESS_MAIN

#define VACOPT_PROCESS_MAIN 0x40 /* process main relation */

Definition at line 186 of file vacuum.h.

◆ VACOPT_PROCESS_TOAST

#define VACOPT_PROCESS_TOAST 0x80 /* process the TOAST table, if any */

Definition at line 187 of file vacuum.h.

◆ VACOPT_SKIP_DATABASE_STATS

#define VACOPT_SKIP_DATABASE_STATS 0x200 /* skip vac_update_datfrozenxid() */

Definition at line 189 of file vacuum.h.

◆ VACOPT_SKIP_LOCKED

#define VACOPT_SKIP_LOCKED 0x20 /* skip if cannot get lock */

Definition at line 185 of file vacuum.h.

◆ VACOPT_VACUUM

#define VACOPT_VACUUM 0x01 /* do VACUUM */

Definition at line 180 of file vacuum.h.

◆ VACOPT_VERBOSE

#define VACOPT_VERBOSE 0x04 /* output INFO instrumentation messages */

Definition at line 182 of file vacuum.h.

◆ VACUUM_OPTION_MAX_VALID_VALUE

#define VACUUM_OPTION_MAX_VALID_VALUE ((1 << 3) - 1)

Definition at line 66 of file vacuum.h.

◆ VACUUM_OPTION_NO_PARALLEL

#define VACUUM_OPTION_NO_PARALLEL 0

Definition at line 42 of file vacuum.h.

◆ VACUUM_OPTION_PARALLEL_BULKDEL

#define VACUUM_OPTION_PARALLEL_BULKDEL (1 << 0)

Definition at line 48 of file vacuum.h.

◆ VACUUM_OPTION_PARALLEL_CLEANUP

#define VACUUM_OPTION_PARALLEL_CLEANUP (1 << 2)

Definition at line 63 of file vacuum.h.

◆ VACUUM_OPTION_PARALLEL_COND_CLEANUP

#define VACUUM_OPTION_PARALLEL_COND_CLEANUP (1 << 1)

Definition at line 55 of file vacuum.h.

Typedef Documentation

◆ AnalyzeAttrComputeStatsFunc

typedef void(* AnalyzeAttrComputeStatsFunc) (VacAttrStatsP stats, AnalyzeAttrFetchFunc fetchfunc, int samplerows, double totalrows)

Definition at line 111 of file vacuum.h.

◆ AnalyzeAttrFetchFunc

typedef Datum(* AnalyzeAttrFetchFunc) (VacAttrStatsP stats, int rownum, bool *isNull)

Definition at line 108 of file vacuum.h.

◆ ParallelVacuumState

typedef struct ParallelVacuumState ParallelVacuumState

Definition at line 69 of file vacuum.h.

◆ VacAttrStats

typedef struct VacAttrStats VacAttrStats

◆ VacAttrStatsP

typedef struct VacAttrStats* VacAttrStatsP

Definition at line 106 of file vacuum.h.

◆ VacDeadItemsInfo

typedef struct VacDeadItemsInfo VacDeadItemsInfo

◆ VacOptValue

typedef enum VacOptValue VacOptValue

◆ VacuumParams

typedef struct VacuumParams VacuumParams

Enumeration Type Documentation

◆ VacOptValue

enum VacOptValue

Enumerator
VACOPTVALUE_UNSPECIFIED
VACOPTVALUE_AUTO
VACOPTVALUE_DISABLED
VACOPTVALUE_ENABLED

Definition at line 200 of file vacuum.h.

{
    VACOPTVALUE_UNSPECIFIED = 0,
    VACOPTVALUE_AUTO,
    VACOPTVALUE_DISABLED,
    VACOPTVALUE_ENABLED,
} VacOptValue;

Function Documentation

◆ analyze_rel()

void analyze_rel	(	Oid	relid,
		RangeVar *	relation,
		const VacuumParams	params,
		List *	va_cols,
		bool	in_outer_xact,
		BufferAccessStrategy	bstrategy
	)

Definition at line 108 of file analyze.c.

{
    Relation    onerel;
    int         elevel;
    AcquireSampleRowsFunc acquirefunc = NULL;
    BlockNumber relpages = 0;
 
    /* Select logging level */
    if (params.options & VACOPT_VERBOSE)
        elevel = INFO;
    else
        elevel = DEBUG2;
 
    /* Set up static variables */
    vac_strategy = bstrategy;
 
    /*
     * Check for user-requested abort.
     */
    CHECK_FOR_INTERRUPTS();
 
    /*
     * Open the relation, getting ShareUpdateExclusiveLock to ensure that two
     * ANALYZEs don't run on it concurrently.  (This also locks out a
     * concurrent VACUUM, which doesn't matter much at the moment but might
     * matter if we ever try to accumulate stats on dead tuples.) If the rel
     * has been dropped since we last saw it, we don't need to process it.
     *
     * Make sure to generate only logs for ANALYZE in this case.
     */
    onerel = vacuum_open_relation(relid, relation, params.options & ~(VACOPT_VACUUM),
                                  params.log_min_duration >= 0,
                                  ShareUpdateExclusiveLock);
 
    /* leave if relation could not be opened or locked */
    if (!onerel)
        return;
 
    /*
     * Check if relation needs to be skipped based on privileges.  This check
     * happens also when building the relation list to analyze for a manual
     * operation, and needs to be done additionally here as ANALYZE could
     * happen across multiple transactions where privileges could have changed
     * in-between.  Make sure to generate only logs for ANALYZE in this case.
     */
    if (!vacuum_is_permitted_for_relation(RelationGetRelid(onerel),
                                          onerel->rd_rel,
                                          params.options & ~VACOPT_VACUUM))
    {
        relation_close(onerel, ShareUpdateExclusiveLock);
        return;
    }
 
    /*
     * Silently ignore tables that are temp tables of other backends ---
     * trying to analyze these is rather pointless, since their contents are
     * probably not up-to-date on disk.  (We don't throw a warning here; it
     * would just lead to chatter during a database-wide ANALYZE.)
     */
    if (RELATION_IS_OTHER_TEMP(onerel))
    {
        relation_close(onerel, ShareUpdateExclusiveLock);
        return;
    }
 
    /*
     * We can ANALYZE any table except pg_statistic. See update_attstats
     */
    if (RelationGetRelid(onerel) == StatisticRelationId)
    {
        relation_close(onerel, ShareUpdateExclusiveLock);
        return;
    }
 
    /*
     * Check that it's of an analyzable relkind, and set up appropriately.
     */
    if (onerel->rd_rel->relkind == RELKIND_RELATION ||
        onerel->rd_rel->relkind == RELKIND_MATVIEW)
    {
        /* Regular table, so we'll use the regular row acquisition function */
        acquirefunc = acquire_sample_rows;
        /* Also get regular table's size */
        relpages = RelationGetNumberOfBlocks(onerel);
    }
    else if (onerel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
    {
        /*
         * For a foreign table, call the FDW's hook function to see whether it
         * supports analysis.
         */
        FdwRoutine *fdwroutine;
        bool        ok = false;
 
        fdwroutine = GetFdwRoutineForRelation(onerel, false);
 
        if (fdwroutine->AnalyzeForeignTable != NULL)
            ok = fdwroutine->AnalyzeForeignTable(onerel,
                                                 &acquirefunc,
                                                 &relpages);
 
        if (!ok)
        {
            ereport(WARNING,
                    (errmsg("skipping \"%s\" --- cannot analyze this foreign table",
                            RelationGetRelationName(onerel))));
            relation_close(onerel, ShareUpdateExclusiveLock);
            return;
        }
    }
    else if (onerel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        /*
         * For partitioned tables, we want to do the recursive ANALYZE below.
         */
    }
    else
    {
        /* No need for a WARNING if we already complained during VACUUM */
        if (!(params.options & VACOPT_VACUUM))
            ereport(WARNING,
                    (errmsg("skipping \"%s\" --- cannot analyze non-tables or special system tables",
                            RelationGetRelationName(onerel))));
        relation_close(onerel, ShareUpdateExclusiveLock);
        return;
    }
 
    /*
     * OK, let's do it.  First, initialize progress reporting.
     */
    pgstat_progress_start_command(PROGRESS_COMMAND_ANALYZE,
                                  RelationGetRelid(onerel));
 
    /*
     * Do the normal non-recursive ANALYZE.  We can skip this for partitioned
     * tables, which don't contain any rows.
     */
    if (onerel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
        do_analyze_rel(onerel, params, va_cols, acquirefunc,
                       relpages, false, in_outer_xact, elevel);
 
    /*
     * If there are child tables, do recursive ANALYZE.
     */
    if (onerel->rd_rel->relhassubclass)
        do_analyze_rel(onerel, params, va_cols, acquirefunc, relpages,
                       true, in_outer_xact, elevel);
 
    /*
     * Close source relation now, but keep lock so that no one deletes it
     * before we commit.  (If someone did, they'd fail to clean up the entries
     * we made in pg_statistic.  Also, releasing the lock before commit would
     * expose us to concurrent-update failures in update_attstats.)
     */
    relation_close(onerel, NoLock);
 
    pgstat_progress_end_command();
}

References acquire_sample_rows(), FdwRoutine::AnalyzeForeignTable, CHECK_FOR_INTERRUPTS, DEBUG2, do_analyze_rel(), ereport, errmsg(), GetFdwRoutineForRelation(), INFO, VacuumParams::log_min_duration, NoLock, VacuumParams::options, pgstat_progress_end_command(), pgstat_progress_start_command(), PROGRESS_COMMAND_ANALYZE, RelationData::rd_rel, relation_close(), RELATION_IS_OTHER_TEMP, RelationGetNumberOfBlocks, RelationGetRelationName, RelationGetRelid, ShareUpdateExclusiveLock, vac_strategy, VACOPT_VACUUM, VACOPT_VERBOSE, vacuum_is_permitted_for_relation(), vacuum_open_relation(), and WARNING.

Referenced by vacuum().

◆ anl_get_next_S()

double anl_get_next_S	(	double	t,
		int	n,
		double *	stateptr
	)

Definition at line 296 of file sampling.c.

{
    double      result;
 
    oldrs.W = *stateptr;
    result = reservoir_get_next_S(&oldrs, t, n);
    *stateptr = oldrs.W;
    return result;
}

◆ anl_init_selection_state()

double anl_init_selection_state ( int n )

Definition at line 281 of file sampling.c.

{
    /* initialize if first time through */
    if (unlikely(!oldrs_initialized))
    {
        sampler_random_init_state(pg_prng_uint32(&pg_global_prng_state),
                                  &oldrs.randstate);
        oldrs_initialized = true;
    }
 
    /* Initial value of W (for use when Algorithm Z is first applied) */
    return exp(-log(sampler_random_fract(&oldrs.randstate)) / n);
}

◆ anl_random_fract()

double anl_random_fract ( void )

Definition at line 266 of file sampling.c.

{
    /* initialize if first time through */
    if (unlikely(!oldrs_initialized))
    {
        sampler_random_init_state(pg_prng_uint32(&pg_global_prng_state),
                                  &oldrs.randstate);
        oldrs_initialized = true;
    }
 
    /* and compute a random fraction */
    return sampler_random_fract(&oldrs.randstate);
}

◆ AutoVacuumUpdateCostLimit()

void AutoVacuumUpdateCostLimit ( void )

Definition at line 1736 of file autovacuum.c.

{
    if (!MyWorkerInfo)
        return;
 
    /*
     * note: in cost_limit, zero also means use value from elsewhere, because
     * zero is not a valid value.
     */
 
    if (av_storage_param_cost_limit > 0)
        vacuum_cost_limit = av_storage_param_cost_limit;
    else
    {
        int         nworkers_for_balance;
 
        if (autovacuum_vac_cost_limit > 0)
            vacuum_cost_limit = autovacuum_vac_cost_limit;
        else
            vacuum_cost_limit = VacuumCostLimit;
 
        /* Only balance limit if no cost-related storage parameters specified */
        if (pg_atomic_unlocked_test_flag(&MyWorkerInfo->wi_dobalance))
            return;
 
        Assert(vacuum_cost_limit > 0);
 
        nworkers_for_balance = pg_atomic_read_u32(&AutoVacuumShmem->av_nworkersForBalance);
 
        /* There is at least 1 autovac worker (this worker) */
        if (nworkers_for_balance <= 0)
            elog(ERROR, "nworkers_for_balance must be > 0");
 
        vacuum_cost_limit = Max(vacuum_cost_limit / nworkers_for_balance, 1);
    }
}

References Assert(), autovacuum_vac_cost_limit, AutoVacuumShmem, AutoVacuumShmemStruct::av_nworkersForBalance, av_storage_param_cost_limit, elog, ERROR, Max, MyWorkerInfo, pg_atomic_read_u32(), pg_atomic_unlocked_test_flag(), vacuum_cost_limit, VacuumCostLimit, and WorkerInfoData::wi_dobalance.

Referenced by vacuum_delay_point(), and VacuumUpdateCosts().

◆ ExecVacuum()

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

Definition at line 161 of file vacuum.c.

{
    VacuumParams params;
    BufferAccessStrategy bstrategy = NULL;
    bool        verbose = false;
    bool        skip_locked = false;
    bool        analyze = false;
    bool        freeze = false;
    bool        full = false;
    bool        disable_page_skipping = false;
    bool        process_main = true;
    bool        process_toast = true;
    int         ring_size;
    bool        skip_database_stats = false;
    bool        only_database_stats = false;
    MemoryContext vac_context;
    ListCell   *lc;
 
    /* index_cleanup and truncate values unspecified for now */
    params.index_cleanup = VACOPTVALUE_UNSPECIFIED;
    params.truncate = VACOPTVALUE_UNSPECIFIED;
 
    /* By default parallel vacuum is enabled */
    params.nworkers = 0;
 
    /* Will be set later if we recurse to a TOAST table. */
    params.toast_parent = InvalidOid;
 
    /*
     * Set this to an invalid value so it is clear whether or not a
     * BUFFER_USAGE_LIMIT was specified when making the access strategy.
     */
    ring_size = -1;
 
    /* Parse options list */
    foreach(lc, vacstmt->options)
    {
        DefElem    *opt = (DefElem *) lfirst(lc);
 
        /* Parse common options for VACUUM and ANALYZE */
        if (strcmp(opt->defname, "verbose") == 0)
            verbose = defGetBoolean(opt);
        else if (strcmp(opt->defname, "skip_locked") == 0)
            skip_locked = defGetBoolean(opt);
        else if (strcmp(opt->defname, "buffer_usage_limit") == 0)
        {
            const char *hintmsg;
            int         result;
            char       *vac_buffer_size;
 
            vac_buffer_size = defGetString(opt);
 
            /*
             * Check that the specified value is valid and the size falls
             * within the hard upper and lower limits if it is not 0.
             */
            if (!parse_int(vac_buffer_size, &result, GUC_UNIT_KB, &hintmsg) ||
                (result != 0 &&
                 (result < MIN_BAS_VAC_RING_SIZE_KB || result > MAX_BAS_VAC_RING_SIZE_KB)))
            {
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("BUFFER_USAGE_LIMIT option must be 0 or between %d kB and %d kB",
                                MIN_BAS_VAC_RING_SIZE_KB, MAX_BAS_VAC_RING_SIZE_KB),
                         hintmsg ? errhint("%s", _(hintmsg)) : 0));
            }
 
            ring_size = result;
        }
        else if (!vacstmt->is_vacuumcmd)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("unrecognized ANALYZE option \"%s\"", opt->defname),
                     parser_errposition(pstate, opt->location)));
 
        /* Parse options available on VACUUM */
        else if (strcmp(opt->defname, "analyze") == 0)
            analyze = defGetBoolean(opt);
        else if (strcmp(opt->defname, "freeze") == 0)
            freeze = defGetBoolean(opt);
        else if (strcmp(opt->defname, "full") == 0)
            full = defGetBoolean(opt);
        else if (strcmp(opt->defname, "disable_page_skipping") == 0)
            disable_page_skipping = defGetBoolean(opt);
        else if (strcmp(opt->defname, "index_cleanup") == 0)
        {
            /* Interpret no string as the default, which is 'auto' */
            if (!opt->arg)
                params.index_cleanup = VACOPTVALUE_AUTO;
            else
            {
                char       *sval = defGetString(opt);
 
                /* Try matching on 'auto' string, or fall back on boolean */
                if (pg_strcasecmp(sval, "auto") == 0)
                    params.index_cleanup = VACOPTVALUE_AUTO;
                else
                    params.index_cleanup = get_vacoptval_from_boolean(opt);
            }
        }
        else if (strcmp(opt->defname, "process_main") == 0)
            process_main = defGetBoolean(opt);
        else if (strcmp(opt->defname, "process_toast") == 0)
            process_toast = defGetBoolean(opt);
        else if (strcmp(opt->defname, "truncate") == 0)
            params.truncate = get_vacoptval_from_boolean(opt);
        else if (strcmp(opt->defname, "parallel") == 0)
        {
            if (opt->arg == NULL)
            {
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("parallel option requires a value between 0 and %d",
                                MAX_PARALLEL_WORKER_LIMIT),
                         parser_errposition(pstate, opt->location)));
            }
            else
            {
                int         nworkers;
 
                nworkers = defGetInt32(opt);
                if (nworkers < 0 || nworkers > MAX_PARALLEL_WORKER_LIMIT)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("parallel workers for vacuum must be between 0 and %d",
                                    MAX_PARALLEL_WORKER_LIMIT),
                             parser_errposition(pstate, opt->location)));
 
                /*
                 * Disable parallel vacuum, if user has specified parallel
                 * degree as zero.
                 */
                if (nworkers == 0)
                    params.nworkers = -1;
                else
                    params.nworkers = nworkers;
            }
        }
        else if (strcmp(opt->defname, "skip_database_stats") == 0)
            skip_database_stats = defGetBoolean(opt);
        else if (strcmp(opt->defname, "only_database_stats") == 0)
            only_database_stats = defGetBoolean(opt);
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("unrecognized VACUUM option \"%s\"", opt->defname),
                     parser_errposition(pstate, opt->location)));
    }
 
    /* Set vacuum options */
    params.options =
        (vacstmt->is_vacuumcmd ? VACOPT_VACUUM : VACOPT_ANALYZE) |
        (verbose ? VACOPT_VERBOSE : 0) |
        (skip_locked ? VACOPT_SKIP_LOCKED : 0) |
        (analyze ? VACOPT_ANALYZE : 0) |
        (freeze ? VACOPT_FREEZE : 0) |
        (full ? VACOPT_FULL : 0) |
        (disable_page_skipping ? VACOPT_DISABLE_PAGE_SKIPPING : 0) |
        (process_main ? VACOPT_PROCESS_MAIN : 0) |
        (process_toast ? VACOPT_PROCESS_TOAST : 0) |
        (skip_database_stats ? VACOPT_SKIP_DATABASE_STATS : 0) |
        (only_database_stats ? VACOPT_ONLY_DATABASE_STATS : 0);
 
    /* sanity checks on options */
    Assert(params.options & (VACOPT_VACUUM | VACOPT_ANALYZE));
    Assert((params.options & VACOPT_VACUUM) ||
           !(params.options & (VACOPT_FULL | VACOPT_FREEZE)));
 
    if ((params.options & VACOPT_FULL) && params.nworkers > 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("VACUUM FULL cannot be performed in parallel")));
 
    /*
     * BUFFER_USAGE_LIMIT does nothing for VACUUM (FULL) so just raise an
     * ERROR for that case.  VACUUM (FULL, ANALYZE) does make use of it, so
     * we'll permit that.
     */
    if (ring_size != -1 && (params.options & VACOPT_FULL) &&
        !(params.options & VACOPT_ANALYZE))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("BUFFER_USAGE_LIMIT cannot be specified for VACUUM FULL")));
 
    /*
     * Make sure VACOPT_ANALYZE is specified if any column lists are present.
     */
    if (!(params.options & VACOPT_ANALYZE))
    {
        foreach(lc, vacstmt->rels)
        {
            VacuumRelation *vrel = lfirst_node(VacuumRelation, lc);
 
            if (vrel->va_cols != NIL)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("ANALYZE option must be specified when a column list is provided")));
        }
    }
 
 
    /*
     * Sanity check DISABLE_PAGE_SKIPPING option.
     */
    if ((params.options & VACOPT_FULL) != 0 &&
        (params.options & VACOPT_DISABLE_PAGE_SKIPPING) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("VACUUM option DISABLE_PAGE_SKIPPING cannot be used with FULL")));
 
    /* sanity check for PROCESS_TOAST */
    if ((params.options & VACOPT_FULL) != 0 &&
        (params.options & VACOPT_PROCESS_TOAST) == 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("PROCESS_TOAST required with VACUUM FULL")));
 
    /* sanity check for ONLY_DATABASE_STATS */
    if (params.options & VACOPT_ONLY_DATABASE_STATS)
    {
        Assert(params.options & VACOPT_VACUUM);
        if (vacstmt->rels != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("ONLY_DATABASE_STATS cannot be specified with a list of tables")));
        /* don't require people to turn off PROCESS_TOAST/MAIN explicitly */
        if (params.options & ~(VACOPT_VACUUM |
                               VACOPT_VERBOSE |
                               VACOPT_PROCESS_MAIN |
                               VACOPT_PROCESS_TOAST |
                               VACOPT_ONLY_DATABASE_STATS))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("ONLY_DATABASE_STATS cannot be specified with other VACUUM options")));
    }
 
    /*
     * All freeze ages are zero if the FREEZE option is given; otherwise pass
     * them as -1 which means to use the default values.
     */
    if (params.options & VACOPT_FREEZE)
    {
        params.freeze_min_age = 0;
        params.freeze_table_age = 0;
        params.multixact_freeze_min_age = 0;
        params.multixact_freeze_table_age = 0;
    }
    else
    {
        params.freeze_min_age = -1;
        params.freeze_table_age = -1;
        params.multixact_freeze_min_age = -1;
        params.multixact_freeze_table_age = -1;
    }
 
    /* user-invoked vacuum is never "for wraparound" */
    params.is_wraparound = false;
 
    /* user-invoked vacuum uses VACOPT_VERBOSE instead of log_min_duration */
    params.log_min_duration = -1;
 
    /*
     * Later, in vacuum_rel(), we check if a reloption override was specified.
     */
    params.max_eager_freeze_failure_rate = vacuum_max_eager_freeze_failure_rate;
 
    /*
     * Create special memory context for cross-transaction storage.
     *
     * Since it is a child of PortalContext, it will go away eventually even
     * if we suffer an error; there's no need for special abort cleanup logic.
     */
    vac_context = AllocSetContextCreate(PortalContext,
                                        "Vacuum",
                                        ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Make a buffer strategy object in the cross-transaction memory context.
     * We needn't bother making this for VACUUM (FULL) or VACUUM
     * (ONLY_DATABASE_STATS) as they'll not make use of it.  VACUUM (FULL,
     * ANALYZE) is possible, so we'd better ensure that we make a strategy
     * when we see ANALYZE.
     */
    if ((params.options & (VACOPT_ONLY_DATABASE_STATS |
                           VACOPT_FULL)) == 0 ||
        (params.options & VACOPT_ANALYZE) != 0)
    {
 
        MemoryContext old_context = MemoryContextSwitchTo(vac_context);
 
        Assert(ring_size >= -1);
 
        /*
         * If BUFFER_USAGE_LIMIT was specified by the VACUUM or ANALYZE
         * command, it overrides the value of VacuumBufferUsageLimit.  Either
         * value may be 0, in which case GetAccessStrategyWithSize() will
         * return NULL, effectively allowing full use of shared buffers.
         */
        if (ring_size == -1)
            ring_size = VacuumBufferUsageLimit;
 
        bstrategy = GetAccessStrategyWithSize(BAS_VACUUM, ring_size);
 
        MemoryContextSwitchTo(old_context);
    }
 
    /* Now go through the common routine */
    vacuum(vacstmt->rels, params, bstrategy, vac_context, isTopLevel);
 
    /* Finally, clean up the vacuum memory context */
    MemoryContextDelete(vac_context);
}

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, 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().

◆ parallel_vacuum_bulkdel_all_indexes()

void parallel_vacuum_bulkdel_all_indexes	(	ParallelVacuumState *	pvs,
		long	num_table_tuples,
		int	num_index_scans
	)

Definition at line 500 of file vacuumparallel.c.

{
    Assert(!IsParallelWorker());
 
    /*
     * We can only provide an approximate value of num_heap_tuples, at least
     * for now.
     */
    pvs->shared->reltuples = num_table_tuples;
    pvs->shared->estimated_count = true;
 
    parallel_vacuum_process_all_indexes(pvs, num_index_scans, true);
}

References Assert(), PVShared::estimated_count, IsParallelWorker, parallel_vacuum_process_all_indexes(), PVShared::reltuples, and ParallelVacuumState::shared.

Referenced by lazy_vacuum_all_indexes().

◆ parallel_vacuum_cleanup_all_indexes()

void parallel_vacuum_cleanup_all_indexes	(	ParallelVacuumState *	pvs,
		long	num_table_tuples,
		int	num_index_scans,
		bool	estimated_count
	)

Definition at line 519 of file vacuumparallel.c.

{
    Assert(!IsParallelWorker());
 
    /*
     * We can provide a better estimate of total number of surviving tuples
     * (we assume indexes are more interested in that than in the number of
     * nominally live tuples).
     */
    pvs->shared->reltuples = num_table_tuples;
    pvs->shared->estimated_count = estimated_count;
 
    parallel_vacuum_process_all_indexes(pvs, num_index_scans, false);
}

References Assert(), PVShared::estimated_count, IsParallelWorker, parallel_vacuum_process_all_indexes(), PVShared::reltuples, and ParallelVacuumState::shared.

Referenced by lazy_cleanup_all_indexes().

◆ parallel_vacuum_end()

void parallel_vacuum_end	(	ParallelVacuumState *	pvs,
		IndexBulkDeleteResult **	istats
	)

Definition at line 436 of file vacuumparallel.c.

{
    Assert(!IsParallelWorker());
 
    /* Copy the updated statistics */
    for (int i = 0; i < pvs->nindexes; i++)
    {
        PVIndStats *indstats = &(pvs->indstats[i]);
 
        if (indstats->istat_updated)
        {
            istats[i] = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
            memcpy(istats[i], &indstats->istat, sizeof(IndexBulkDeleteResult));
        }
        else
            istats[i] = NULL;
    }
 
    TidStoreDestroy(pvs->dead_items);
 
    DestroyParallelContext(pvs->pcxt);
    ExitParallelMode();
 
    pfree(pvs->will_parallel_vacuum);
    pfree(pvs);
}

References Assert(), ParallelVacuumState::dead_items, DestroyParallelContext(), ExitParallelMode(), i, ParallelVacuumState::indstats, IsParallelWorker, PVIndStats::istat, PVIndStats::istat_updated, ParallelVacuumState::nindexes, palloc0(), ParallelVacuumState::pcxt, pfree(), TidStoreDestroy(), and ParallelVacuumState::will_parallel_vacuum.

Referenced by dead_items_cleanup().

◆ parallel_vacuum_get_dead_items()

TidStore * parallel_vacuum_get_dead_items	(	ParallelVacuumState *	pvs,
		VacDeadItemsInfo **	dead_items_info_p
	)

Definition at line 467 of file vacuumparallel.c.

{
    *dead_items_info_p = &(pvs->shared->dead_items_info);
    return pvs->dead_items;
}

References ParallelVacuumState::dead_items, PVShared::dead_items_info, and ParallelVacuumState::shared.

Referenced by dead_items_alloc().

◆ parallel_vacuum_init()

ParallelVacuumState * parallel_vacuum_init	(	Relation	rel,
		Relation *	indrels,
		int	nindexes,
		int	nrequested_workers,
		int	vac_work_mem,
		int	elevel,
		BufferAccessStrategy	bstrategy
	)

Definition at line 243 of file vacuumparallel.c.

{
    ParallelVacuumState *pvs;
    ParallelContext *pcxt;
    PVShared   *shared;
    TidStore   *dead_items;
    PVIndStats *indstats;
    BufferUsage *buffer_usage;
    WalUsage   *wal_usage;
    bool       *will_parallel_vacuum;
    Size        est_indstats_len;
    Size        est_shared_len;
    int         nindexes_mwm = 0;
    int         parallel_workers = 0;
    int         querylen;
 
    /*
     * A parallel vacuum must be requested and there must be indexes on the
     * relation
     */
    Assert(nrequested_workers >= 0);
    Assert(nindexes > 0);
 
    /*
     * Compute the number of parallel vacuum workers to launch
     */
    will_parallel_vacuum = (bool *) palloc0(sizeof(bool) * nindexes);
    parallel_workers = parallel_vacuum_compute_workers(indrels, nindexes,
                                                       nrequested_workers,
                                                       will_parallel_vacuum);
    if (parallel_workers <= 0)
    {
        /* Can't perform vacuum in parallel -- return NULL */
        pfree(will_parallel_vacuum);
        return NULL;
    }
 
    pvs = (ParallelVacuumState *) palloc0(sizeof(ParallelVacuumState));
    pvs->indrels = indrels;
    pvs->nindexes = nindexes;
    pvs->will_parallel_vacuum = will_parallel_vacuum;
    pvs->bstrategy = bstrategy;
    pvs->heaprel = rel;
 
    EnterParallelMode();
    pcxt = CreateParallelContext("postgres", "parallel_vacuum_main",
                                 parallel_workers);
    Assert(pcxt->nworkers > 0);
    pvs->pcxt = pcxt;
 
    /* Estimate size for index vacuum stats -- PARALLEL_VACUUM_KEY_INDEX_STATS */
    est_indstats_len = mul_size(sizeof(PVIndStats), nindexes);
    shm_toc_estimate_chunk(&pcxt->estimator, est_indstats_len);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
 
    /* Estimate size for shared information -- PARALLEL_VACUUM_KEY_SHARED */
    est_shared_len = sizeof(PVShared);
    shm_toc_estimate_chunk(&pcxt->estimator, est_shared_len);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
 
    /*
     * Estimate space for BufferUsage and WalUsage --
     * PARALLEL_VACUUM_KEY_BUFFER_USAGE and PARALLEL_VACUUM_KEY_WAL_USAGE.
     *
     * If there are no extensions loaded that care, we could skip this.  We
     * have no way of knowing whether anyone's looking at pgBufferUsage or
     * pgWalUsage, so do it unconditionally.
     */
    shm_toc_estimate_chunk(&pcxt->estimator,
                           mul_size(sizeof(BufferUsage), pcxt->nworkers));
    shm_toc_estimate_keys(&pcxt->estimator, 1);
    shm_toc_estimate_chunk(&pcxt->estimator,
                           mul_size(sizeof(WalUsage), pcxt->nworkers));
    shm_toc_estimate_keys(&pcxt->estimator, 1);
 
    /* Finally, estimate PARALLEL_VACUUM_KEY_QUERY_TEXT space */
    if (debug_query_string)
    {
        querylen = strlen(debug_query_string);
        shm_toc_estimate_chunk(&pcxt->estimator, querylen + 1);
        shm_toc_estimate_keys(&pcxt->estimator, 1);
    }
    else
        querylen = 0;           /* keep compiler quiet */
 
    InitializeParallelDSM(pcxt);
 
    /* Prepare index vacuum stats */
    indstats = (PVIndStats *) shm_toc_allocate(pcxt->toc, est_indstats_len);
    MemSet(indstats, 0, est_indstats_len);
    for (int i = 0; i < nindexes; i++)
    {
        Relation    indrel = indrels[i];
        uint8       vacoptions = indrel->rd_indam->amparallelvacuumoptions;
 
        /*
         * Cleanup option should be either disabled, always performing in
         * parallel or conditionally performing in parallel.
         */
        Assert(((vacoptions & VACUUM_OPTION_PARALLEL_CLEANUP) == 0) ||
               ((vacoptions & VACUUM_OPTION_PARALLEL_COND_CLEANUP) == 0));
        Assert(vacoptions <= VACUUM_OPTION_MAX_VALID_VALUE);
 
        if (!will_parallel_vacuum[i])
            continue;
 
        if (indrel->rd_indam->amusemaintenanceworkmem)
            nindexes_mwm++;
 
        /*
         * Remember the number of indexes that support parallel operation for
         * each phase.
         */
        if ((vacoptions & VACUUM_OPTION_PARALLEL_BULKDEL) != 0)
            pvs->nindexes_parallel_bulkdel++;
        if ((vacoptions & VACUUM_OPTION_PARALLEL_CLEANUP) != 0)
            pvs->nindexes_parallel_cleanup++;
        if ((vacoptions & VACUUM_OPTION_PARALLEL_COND_CLEANUP) != 0)
            pvs->nindexes_parallel_condcleanup++;
    }
    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_INDEX_STATS, indstats);
    pvs->indstats = indstats;
 
    /* Prepare shared information */
    shared = (PVShared *) shm_toc_allocate(pcxt->toc, est_shared_len);
    MemSet(shared, 0, est_shared_len);
    shared->relid = RelationGetRelid(rel);
    shared->elevel = elevel;
    shared->queryid = pgstat_get_my_query_id();
    shared->maintenance_work_mem_worker =
        (nindexes_mwm > 0) ?
        maintenance_work_mem / Min(parallel_workers, nindexes_mwm) :
        maintenance_work_mem;
    shared->dead_items_info.max_bytes = vac_work_mem * (size_t) 1024;
 
    /* Prepare DSA space for dead items */
    dead_items = TidStoreCreateShared(shared->dead_items_info.max_bytes,
                                      LWTRANCHE_PARALLEL_VACUUM_DSA);
    pvs->dead_items = dead_items;
    shared->dead_items_handle = TidStoreGetHandle(dead_items);
    shared->dead_items_dsa_handle = dsa_get_handle(TidStoreGetDSA(dead_items));
 
    /* Use the same buffer size for all workers */
    shared->ring_nbuffers = GetAccessStrategyBufferCount(bstrategy);
 
    pg_atomic_init_u32(&(shared->cost_balance), 0);
    pg_atomic_init_u32(&(shared->active_nworkers), 0);
    pg_atomic_init_u32(&(shared->idx), 0);
 
    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_SHARED, shared);
    pvs->shared = shared;
 
    /*
     * Allocate space for each worker's BufferUsage and WalUsage; no need to
     * initialize
     */
    buffer_usage = shm_toc_allocate(pcxt->toc,
                                    mul_size(sizeof(BufferUsage), pcxt->nworkers));
    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_BUFFER_USAGE, buffer_usage);
    pvs->buffer_usage = buffer_usage;
    wal_usage = shm_toc_allocate(pcxt->toc,
                                 mul_size(sizeof(WalUsage), pcxt->nworkers));
    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_WAL_USAGE, wal_usage);
    pvs->wal_usage = wal_usage;
 
    /* Store query string for workers */
    if (debug_query_string)
    {
        char       *sharedquery;
 
        sharedquery = (char *) shm_toc_allocate(pcxt->toc, querylen + 1);
        memcpy(sharedquery, debug_query_string, querylen + 1);
        sharedquery[querylen] = '\0';
        shm_toc_insert(pcxt->toc,
                       PARALLEL_VACUUM_KEY_QUERY_TEXT, sharedquery);
    }
 
    /* Success -- return parallel vacuum state */
    return pvs;
}

Referenced by dead_items_alloc().

◆ parallel_vacuum_main()

void parallel_vacuum_main	(	dsm_segment *	seg,
		shm_toc *	toc
	)

Definition at line 989 of file vacuumparallel.c.

{
    ParallelVacuumState pvs;
    Relation    rel;
    Relation   *indrels;
    PVIndStats *indstats;
    PVShared   *shared;
    TidStore   *dead_items;
    BufferUsage *buffer_usage;
    WalUsage   *wal_usage;
    int         nindexes;
    char       *sharedquery;
    ErrorContextCallback errcallback;
 
    /*
     * A parallel vacuum worker must have only PROC_IN_VACUUM flag since we
     * don't support parallel vacuum for autovacuum as of now.
     */
    Assert(MyProc->statusFlags == PROC_IN_VACUUM);
 
    elog(DEBUG1, "starting parallel vacuum worker");
 
    shared = (PVShared *) shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_SHARED, false);
 
    /* Set debug_query_string for individual workers */
    sharedquery = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_QUERY_TEXT, true);
    debug_query_string = sharedquery;
    pgstat_report_activity(STATE_RUNNING, debug_query_string);
 
    /* Track query ID */
    pgstat_report_query_id(shared->queryid, false);
 
    /*
     * Open table.  The lock mode is the same as the leader process.  It's
     * okay because the lock mode does not conflict among the parallel
     * workers.
     */
    rel = table_open(shared->relid, ShareUpdateExclusiveLock);
 
    /*
     * Open all indexes. indrels are sorted in order by OID, which should be
     * matched to the leader's one.
     */
    vac_open_indexes(rel, RowExclusiveLock, &nindexes, &indrels);
    Assert(nindexes > 0);
 
    /*
     * Apply the desired value of maintenance_work_mem within this process.
     * Really we should use SetConfigOption() to change a GUC, but since we're
     * already in parallel mode guc.c would complain about that.  Fortunately,
     * by the same token guc.c will not let any user-defined code change it.
     * So just avert your eyes while we do this:
     */
    if (shared->maintenance_work_mem_worker > 0)
        maintenance_work_mem = shared->maintenance_work_mem_worker;
 
    /* Set index statistics */
    indstats = (PVIndStats *) shm_toc_lookup(toc,
                                             PARALLEL_VACUUM_KEY_INDEX_STATS,
                                             false);
 
    /* Find dead_items in shared memory */
    dead_items = TidStoreAttach(shared->dead_items_dsa_handle,
                                shared->dead_items_handle);
 
    /* Set cost-based vacuum delay */
    VacuumUpdateCosts();
    VacuumCostBalance = 0;
    VacuumCostBalanceLocal = 0;
    VacuumSharedCostBalance = &(shared->cost_balance);
    VacuumActiveNWorkers = &(shared->active_nworkers);
 
    /* Set parallel vacuum state */
    pvs.indrels = indrels;
    pvs.nindexes = nindexes;
    pvs.indstats = indstats;
    pvs.shared = shared;
    pvs.dead_items = dead_items;
    pvs.relnamespace = get_namespace_name(RelationGetNamespace(rel));
    pvs.relname = pstrdup(RelationGetRelationName(rel));
    pvs.heaprel = rel;
 
    /* These fields will be filled during index vacuum or cleanup */
    pvs.indname = NULL;
    pvs.status = PARALLEL_INDVAC_STATUS_INITIAL;
 
    /* Each parallel VACUUM worker gets its own access strategy. */
    pvs.bstrategy = GetAccessStrategyWithSize(BAS_VACUUM,
                                              shared->ring_nbuffers * (BLCKSZ / 1024));
 
    /* Setup error traceback support for ereport() */
    errcallback.callback = parallel_vacuum_error_callback;
    errcallback.arg = &pvs;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;
 
    /* Prepare to track buffer usage during parallel execution */
    InstrStartParallelQuery();
 
    /* Process indexes to perform vacuum/cleanup */
    parallel_vacuum_process_safe_indexes(&pvs);
 
    /* Report buffer/WAL usage during parallel execution */
    buffer_usage = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_BUFFER_USAGE, false);
    wal_usage = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_WAL_USAGE, false);
    InstrEndParallelQuery(&buffer_usage[ParallelWorkerNumber],
                          &wal_usage[ParallelWorkerNumber]);
 
    /* Report any remaining cost-based vacuum delay time */
    if (track_cost_delay_timing)
        pgstat_progress_parallel_incr_param(PROGRESS_VACUUM_DELAY_TIME,
                                            parallel_vacuum_worker_delay_ns);
 
    TidStoreDetach(dead_items);
 
    /* Pop the error context stack */
    error_context_stack = errcallback.previous;
 
    vac_close_indexes(nindexes, indrels, RowExclusiveLock);
    table_close(rel, ShareUpdateExclusiveLock);
    FreeAccessStrategy(pvs.bstrategy);
}

References PVShared::active_nworkers, ErrorContextCallback::arg, Assert(), BAS_VACUUM, ParallelVacuumState::bstrategy, ErrorContextCallback::callback, PVShared::cost_balance, ParallelVacuumState::dead_items, PVShared::dead_items_dsa_handle, PVShared::dead_items_handle, DEBUG1, debug_query_string, elog, error_context_stack, FreeAccessStrategy(), get_namespace_name(), GetAccessStrategyWithSize(), ParallelVacuumState::heaprel, ParallelVacuumState::indname, ParallelVacuumState::indrels, ParallelVacuumState::indstats, InstrEndParallelQuery(), InstrStartParallelQuery(), maintenance_work_mem, PVShared::maintenance_work_mem_worker, MyProc, ParallelVacuumState::nindexes, PARALLEL_INDVAC_STATUS_INITIAL, parallel_vacuum_error_callback(), PARALLEL_VACUUM_KEY_BUFFER_USAGE, PARALLEL_VACUUM_KEY_INDEX_STATS, PARALLEL_VACUUM_KEY_QUERY_TEXT, PARALLEL_VACUUM_KEY_SHARED, PARALLEL_VACUUM_KEY_WAL_USAGE, parallel_vacuum_process_safe_indexes(), parallel_vacuum_worker_delay_ns, ParallelWorkerNumber, pgstat_progress_parallel_incr_param(), pgstat_report_activity(), pgstat_report_query_id(), ErrorContextCallback::previous, PROC_IN_VACUUM, PROGRESS_VACUUM_DELAY_TIME, pstrdup(), PVShared::queryid, RelationGetNamespace, RelationGetRelationName, PVShared::relid, ParallelVacuumState::relname, ParallelVacuumState::relnamespace, PVShared::ring_nbuffers, RowExclusiveLock, ParallelVacuumState::shared, ShareUpdateExclusiveLock, shm_toc_lookup(), STATE_RUNNING, ParallelVacuumState::status, PGPROC::statusFlags, table_close(), table_open(), TidStoreAttach(), TidStoreDetach(), track_cost_delay_timing, vac_close_indexes(), vac_open_indexes(), VacuumActiveNWorkers, VacuumCostBalance, VacuumCostBalanceLocal, VacuumSharedCostBalance, and VacuumUpdateCosts().

◆ parallel_vacuum_reset_dead_items()

void parallel_vacuum_reset_dead_items ( ParallelVacuumState * pvs )

Definition at line 475 of file vacuumparallel.c.

{
    VacDeadItemsInfo *dead_items_info = &(pvs->shared->dead_items_info);
 
    /*
     * Free the current tidstore and return allocated DSA segments to the
     * operating system. Then we recreate the tidstore with the same max_bytes
     * limitation we just used.
     */
    TidStoreDestroy(pvs->dead_items);
    pvs->dead_items = TidStoreCreateShared(dead_items_info->max_bytes,
                                           LWTRANCHE_PARALLEL_VACUUM_DSA);
 
    /* Update the DSA pointer for dead_items to the new one */
    pvs->shared->dead_items_dsa_handle = dsa_get_handle(TidStoreGetDSA(pvs->dead_items));
    pvs->shared->dead_items_handle = TidStoreGetHandle(pvs->dead_items);
 
    /* Reset the counter */
    dead_items_info->num_items = 0;
}

References ParallelVacuumState::dead_items, PVShared::dead_items_dsa_handle, PVShared::dead_items_handle, PVShared::dead_items_info, dsa_get_handle(), VacDeadItemsInfo::max_bytes, VacDeadItemsInfo::num_items, ParallelVacuumState::shared, TidStoreCreateShared(), TidStoreDestroy(), TidStoreGetDSA(), and TidStoreGetHandle().

Referenced by dead_items_reset().

◆ std_typanalyze()

bool std_typanalyze ( VacAttrStats * stats )

Definition at line 1889 of file analyze.c.

{
    Oid         ltopr;
    Oid         eqopr;
    StdAnalyzeData *mystats;
 
    /* If the attstattarget column is negative, use the default value */
    if (stats->attstattarget < 0)
        stats->attstattarget = default_statistics_target;
 
    /* Look for default "<" and "=" operators for column's type */
    get_sort_group_operators(stats->attrtypid,
                             false, false, false,
                             &ltopr, &eqopr, NULL,
                             NULL);
 
    /* Save the operator info for compute_stats routines */
    mystats = (StdAnalyzeData *) palloc(sizeof(StdAnalyzeData));
    mystats->eqopr = eqopr;
    mystats->eqfunc = OidIsValid(eqopr) ? get_opcode(eqopr) : InvalidOid;
    mystats->ltopr = ltopr;
    stats->extra_data = mystats;
 
    /*
     * Determine which standard statistics algorithm to use
     */
    if (OidIsValid(eqopr) && OidIsValid(ltopr))
    {
        /* Seems to be a scalar datatype */
        stats->compute_stats = compute_scalar_stats;
        /*--------------------
         * The following choice of minrows is based on the paper
         * "Random sampling for histogram construction: how much is enough?"
         * by Surajit Chaudhuri, Rajeev Motwani and Vivek Narasayya, in
         * Proceedings of ACM SIGMOD International Conference on Management
         * of Data, 1998, Pages 436-447.  Their Corollary 1 to Theorem 5
         * says that for table size n, histogram size k, maximum relative
         * error in bin size f, and error probability gamma, the minimum
         * random sample size is
         *      r = 4 * k * ln(2*n/gamma) / f^2
         * Taking f = 0.5, gamma = 0.01, n = 10^6 rows, we obtain
         *      r = 305.82 * k
         * Note that because of the log function, the dependence on n is
         * quite weak; even at n = 10^12, a 300*k sample gives <= 0.66
         * bin size error with probability 0.99.  So there's no real need to
         * scale for n, which is a good thing because we don't necessarily
         * know it at this point.
         *--------------------
         */
        stats->minrows = 300 * stats->attstattarget;
    }
    else if (OidIsValid(eqopr))
    {
        /* We can still recognize distinct values */
        stats->compute_stats = compute_distinct_stats;
        /* Might as well use the same minrows as above */
        stats->minrows = 300 * stats->attstattarget;
    }
    else
    {
        /* Can't do much but the trivial stuff */
        stats->compute_stats = compute_trivial_stats;
        /* Might as well use the same minrows as above */
        stats->minrows = 300 * stats->attstattarget;
    }
 
    return true;
}

References VacAttrStats::attrtypid, VacAttrStats::attstattarget, compute_distinct_stats(), compute_scalar_stats(), VacAttrStats::compute_stats, compute_trivial_stats(), default_statistics_target, StdAnalyzeData::eqfunc, StdAnalyzeData::eqopr, VacAttrStats::extra_data, get_opcode(), get_sort_group_operators(), InvalidOid, StdAnalyzeData::ltopr, VacAttrStats::minrows, OidIsValid, and palloc().

Referenced by array_typanalyze(), examine_attribute(), and examine_expression().

◆ vac_bulkdel_one_index()

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

Definition at line 2630 of file vacuum.c.

{
    /* Do bulk deletion */
    istat = index_bulk_delete(ivinfo, istat, vac_tid_reaped,
                              dead_items);
 
    ereport(ivinfo->message_level,
            (errmsg("scanned index \"%s\" to remove %" PRId64 " row versions",
                    RelationGetRelationName(ivinfo->index),
                    dead_items_info->num_items)));
 
    return istat;
}

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 2651 of file vacuum.c.

{
    istat = index_vacuum_cleanup(ivinfo, istat);
 
    if (istat)
        ereport(ivinfo->message_level,
                (errmsg("index \"%s\" now contains %.0f row versions in %u pages",
                        RelationGetRelationName(ivinfo->index),
                        istat->num_index_tuples,
                        istat->num_pages),
                 errdetail("%.0f index row versions were removed.\n"
                           "%u index pages were newly deleted.\n"
                           "%u index pages are currently deleted, of which %u are currently reusable.",
                           istat->tuples_removed,
                           istat->pages_newly_deleted,
                           istat->pages_deleted, istat->pages_free)));
 
    return istat;
}

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 2402 of file vacuum.c.

{
    if (Irel == NULL)
        return;
 
    while (nindexes--)
    {
        Relation    ind = Irel[nindexes];
 
        index_close(ind, lockmode);
    }
    pfree(Irel);
}

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 1333 of file vacuum.c.

{
    BlockNumber old_rel_pages = relation->rd_rel->relpages;
    double      old_rel_tuples = relation->rd_rel->reltuples;
    double      old_density;
    double      unscanned_pages;
    double      total_tuples;
 
    /* If we did scan the whole table, just use the count as-is */
    if (scanned_pages >= total_pages)
        return scanned_tuples;
 
    /*
     * When successive VACUUM commands scan the same few pages again and
     * again, without anything from the table really changing, there is a risk
     * that our beliefs about tuple density will gradually become distorted.
     * This might be caused by vacuumlazy.c implementation details, such as
     * its tendency to always scan the last heap page.  Handle that here.
     *
     * If the relation is _exactly_ the same size according to the existing
     * pg_class entry, and only a few of its pages (less than 2%) were
     * scanned, keep the existing value of reltuples.  Also keep the existing
     * value when only a subset of rel's pages <= a single page were scanned.
     *
     * (Note: we might be returning -1 here.)
     */
    if (old_rel_pages == total_pages &&
        scanned_pages < (double) total_pages * 0.02)
        return old_rel_tuples;
    if (scanned_pages <= 1)
        return old_rel_tuples;
 
    /*
     * If old density is unknown, we can't do much except scale up
     * scanned_tuples to match total_pages.
     */
    if (old_rel_tuples < 0 || old_rel_pages == 0)
        return floor((scanned_tuples / scanned_pages) * total_pages + 0.5);
 
    /*
     * Okay, we've covered the corner cases.  The normal calculation is to
     * convert the old measurement to a density (tuples per page), then
     * estimate the number of tuples in the unscanned pages using that figure,
     * and finally add on the number of tuples in the scanned pages.
     */
    old_density = old_rel_tuples / old_rel_pages;
    unscanned_pages = (double) total_pages - (double) scanned_pages;
    total_tuples = old_density * unscanned_pages + scanned_tuples;
    return floor(total_tuples + 0.5);
}

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 2359 of file vacuum.c.

{
    List       *indexoidlist;
    ListCell   *indexoidscan;
    int         i;
 
    Assert(lockmode != NoLock);
 
    indexoidlist = RelationGetIndexList(relation);
 
    /* allocate enough memory for all indexes */
    i = list_length(indexoidlist);
 
    if (i > 0)
        *Irel = (Relation *) palloc(i * sizeof(Relation));
    else
        *Irel = NULL;
 
    /* collect just the ready indexes */
    i = 0;
    foreach(indexoidscan, indexoidlist)
    {
        Oid         indexoid = lfirst_oid(indexoidscan);
        Relation    indrel;
 
        indrel = index_open(indexoid, lockmode);
        if (indrel->rd_index->indisready)
            (*Irel)[i++] = indrel;
        else
            index_close(indrel, lockmode);
    }
 
    *nindexes = i;
 
    list_free(indexoidlist);
}

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_update_datfrozenxid()

void vac_update_datfrozenxid ( void )

Definition at line 1611 of file vacuum.c.

{
    HeapTuple   tuple;
    Form_pg_database dbform;
    Relation    relation;
    SysScanDesc scan;
    HeapTuple   classTup;
    TransactionId newFrozenXid;
    MultiXactId newMinMulti;
    TransactionId lastSaneFrozenXid;
    MultiXactId lastSaneMinMulti;
    bool        bogus = false;
    bool        dirty = false;
    ScanKeyData key[1];
    void       *inplace_state;
 
    /*
     * Restrict this task to one backend per database.  This avoids race
     * conditions that would move datfrozenxid or datminmxid backward.  It
     * avoids calling vac_truncate_clog() with a datfrozenxid preceding a
     * datfrozenxid passed to an earlier vac_truncate_clog() call.
     */
    LockDatabaseFrozenIds(ExclusiveLock);
 
    /*
     * Initialize the "min" calculation with
     * GetOldestNonRemovableTransactionId(), which is a reasonable
     * approximation to the minimum relfrozenxid for not-yet-committed
     * pg_class entries for new tables; see AddNewRelationTuple().  So we
     * cannot produce a wrong minimum by starting with this.
     */
    newFrozenXid = GetOldestNonRemovableTransactionId(NULL);
 
    /*
     * Similarly, initialize the MultiXact "min" with the value that would be
     * used on pg_class for new tables.  See AddNewRelationTuple().
     */
    newMinMulti = GetOldestMultiXactId();
 
    /*
     * Identify the latest relfrozenxid and relminmxid values that we could
     * validly see during the scan.  These are conservative values, but it's
     * not really worth trying to be more exact.
     */
    lastSaneFrozenXid = ReadNextTransactionId();
    lastSaneMinMulti = ReadNextMultiXactId();
 
    /*
     * We must seqscan pg_class to find the minimum Xid, because there is no
     * index that can help us here.
     *
     * See vac_truncate_clog() for the race condition to prevent.
     */
    relation = table_open(RelationRelationId, AccessShareLock);
 
    scan = systable_beginscan(relation, InvalidOid, false,
                              NULL, 0, NULL);
 
    while ((classTup = systable_getnext(scan)) != NULL)
    {
        volatile FormData_pg_class *classForm = (Form_pg_class) GETSTRUCT(classTup);
        TransactionId relfrozenxid = classForm->relfrozenxid;
        TransactionId relminmxid = classForm->relminmxid;
 
        /*
         * Only consider relations able to hold unfrozen XIDs (anything else
         * should have InvalidTransactionId in relfrozenxid anyway).
         */
        if (classForm->relkind != RELKIND_RELATION &&
            classForm->relkind != RELKIND_MATVIEW &&
            classForm->relkind != RELKIND_TOASTVALUE)
        {
            Assert(!TransactionIdIsValid(relfrozenxid));
            Assert(!MultiXactIdIsValid(relminmxid));
            continue;
        }
 
        /*
         * Some table AMs might not need per-relation xid / multixid horizons.
         * It therefore seems reasonable to allow relfrozenxid and relminmxid
         * to not be set (i.e. set to their respective Invalid*Id)
         * independently. Thus validate and compute horizon for each only if
         * set.
         *
         * If things are working properly, no relation should have a
         * relfrozenxid or relminmxid that is "in the future".  However, such
         * cases have been known to arise due to bugs in pg_upgrade.  If we
         * see any entries that are "in the future", chicken out and don't do
         * anything.  This ensures we won't truncate clog & multixact SLRUs
         * before those relations have been scanned and cleaned up.
         */
 
        if (TransactionIdIsValid(relfrozenxid))
        {
            Assert(TransactionIdIsNormal(relfrozenxid));
 
            /* check for values in the future */
            if (TransactionIdPrecedes(lastSaneFrozenXid, relfrozenxid))
            {
                bogus = true;
                break;
            }
 
            /* determine new horizon */
            if (TransactionIdPrecedes(relfrozenxid, newFrozenXid))
                newFrozenXid = relfrozenxid;
        }
 
        if (MultiXactIdIsValid(relminmxid))
        {
            /* check for values in the future */
            if (MultiXactIdPrecedes(lastSaneMinMulti, relminmxid))
            {
                bogus = true;
                break;
            }
 
            /* determine new horizon */
            if (MultiXactIdPrecedes(relminmxid, newMinMulti))
                newMinMulti = relminmxid;
        }
    }
 
    /* we're done with pg_class */
    systable_endscan(scan);
    table_close(relation, AccessShareLock);
 
    /* chicken out if bogus data found */
    if (bogus)
        return;
 
    Assert(TransactionIdIsNormal(newFrozenXid));
    Assert(MultiXactIdIsValid(newMinMulti));
 
    /* Now fetch the pg_database tuple we need to update. */
    relation = table_open(DatabaseRelationId, RowExclusiveLock);
 
    /*
     * Fetch a copy of the tuple to scribble on.  We could check the syscache
     * tuple first.  If that concluded !dirty, we'd avoid waiting on
     * concurrent heap_update() and would avoid exclusive-locking the buffer.
     * For now, don't optimize that.
     */
    ScanKeyInit(&key[0],
                Anum_pg_database_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(MyDatabaseId));
 
    systable_inplace_update_begin(relation, DatabaseOidIndexId, true,
                                  NULL, 1, key, &tuple, &inplace_state);
 
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "could not find tuple for database %u", MyDatabaseId);
 
    dbform = (Form_pg_database) GETSTRUCT(tuple);
 
    /*
     * As in vac_update_relstats(), we ordinarily don't want to let
     * datfrozenxid go backward; but if it's "in the future" then it must be
     * corrupt and it seems best to overwrite it.
     */
    if (dbform->datfrozenxid != newFrozenXid &&
        (TransactionIdPrecedes(dbform->datfrozenxid, newFrozenXid) ||
         TransactionIdPrecedes(lastSaneFrozenXid, dbform->datfrozenxid)))
    {
        dbform->datfrozenxid = newFrozenXid;
        dirty = true;
    }
    else
        newFrozenXid = dbform->datfrozenxid;
 
    /* Ditto for datminmxid */
    if (dbform->datminmxid != newMinMulti &&
        (MultiXactIdPrecedes(dbform->datminmxid, newMinMulti) ||
         MultiXactIdPrecedes(lastSaneMinMulti, dbform->datminmxid)))
    {
        dbform->datminmxid = newMinMulti;
        dirty = true;
    }
    else
        newMinMulti = dbform->datminmxid;
 
    if (dirty)
        systable_inplace_update_finish(inplace_state, tuple);
    else
        systable_inplace_update_cancel(inplace_state);
 
    heap_freetuple(tuple);
    table_close(relation, RowExclusiveLock);
 
    /*
     * If we were able to advance datfrozenxid or datminmxid, see if we can
     * truncate pg_xact and/or pg_multixact.  Also do it if the shared
     * XID-wrap-limit info is stale, since this action will update that too.
     */
    if (dirty || ForceTransactionIdLimitUpdate())
        vac_truncate_clog(newFrozenXid, newMinMulti,
                          lastSaneFrozenXid, lastSaneMinMulti);
}

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 1429 of file vacuum.c.

{
    Oid         relid = RelationGetRelid(relation);
    Relation    rd;
    ScanKeyData key[1];
    HeapTuple   ctup;
    void       *inplace_state;
    Form_pg_class pgcform;
    bool        dirty,
                futurexid,
                futuremxid;
    TransactionId oldfrozenxid;
    MultiXactId oldminmulti;
 
    rd = table_open(RelationRelationId, RowExclusiveLock);
 
    /* Fetch a copy of the tuple to scribble on */
    ScanKeyInit(&key[0],
                Anum_pg_class_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(relid));
    systable_inplace_update_begin(rd, ClassOidIndexId, true,
                                  NULL, 1, key, &ctup, &inplace_state);
    if (!HeapTupleIsValid(ctup))
        elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
             relid);
    pgcform = (Form_pg_class) GETSTRUCT(ctup);
 
    /* Apply statistical updates, if any, to copied tuple */
 
    dirty = false;
    if (pgcform->relpages != (int32) num_pages)
    {
        pgcform->relpages = (int32) num_pages;
        dirty = true;
    }
    if (pgcform->reltuples != (float4) num_tuples)
    {
        pgcform->reltuples = (float4) num_tuples;
        dirty = true;
    }
    if (pgcform->relallvisible != (int32) num_all_visible_pages)
    {
        pgcform->relallvisible = (int32) num_all_visible_pages;
        dirty = true;
    }
    if (pgcform->relallfrozen != (int32) num_all_frozen_pages)
    {
        pgcform->relallfrozen = (int32) num_all_frozen_pages;
        dirty = true;
    }
 
    /* Apply DDL updates, but not inside an outer transaction (see above) */
 
    if (!in_outer_xact)
    {
        /*
         * If we didn't find any indexes, reset relhasindex.
         */
        if (pgcform->relhasindex && !hasindex)
        {
            pgcform->relhasindex = false;
            dirty = true;
        }
 
        /* We also clear relhasrules and relhastriggers if needed */
        if (pgcform->relhasrules && relation->rd_rules == NULL)
        {
            pgcform->relhasrules = false;
            dirty = true;
        }
        if (pgcform->relhastriggers && relation->trigdesc == NULL)
        {
            pgcform->relhastriggers = false;
            dirty = true;
        }
    }
 
    /*
     * Update relfrozenxid, unless caller passed InvalidTransactionId
     * indicating it has no new data.
     *
     * Ordinarily, we don't let relfrozenxid go backwards.  However, if the
     * stored relfrozenxid is "in the future" then it seems best to assume
     * it's corrupt, and overwrite with the oldest remaining XID in the table.
     * This should match vac_update_datfrozenxid() concerning what we consider
     * to be "in the future".
     */
    oldfrozenxid = pgcform->relfrozenxid;
    futurexid = false;
    if (frozenxid_updated)
        *frozenxid_updated = false;
    if (TransactionIdIsNormal(frozenxid) && oldfrozenxid != frozenxid)
    {
        bool        update = false;
 
        if (TransactionIdPrecedes(oldfrozenxid, frozenxid))
            update = true;
        else if (TransactionIdPrecedes(ReadNextTransactionId(), oldfrozenxid))
            futurexid = update = true;
 
        if (update)
        {
            pgcform->relfrozenxid = frozenxid;
            dirty = true;
            if (frozenxid_updated)
                *frozenxid_updated = true;
        }
    }
 
    /* Similarly for relminmxid */
    oldminmulti = pgcform->relminmxid;
    futuremxid = false;
    if (minmulti_updated)
        *minmulti_updated = false;
    if (MultiXactIdIsValid(minmulti) && oldminmulti != minmulti)
    {
        bool        update = false;
 
        if (MultiXactIdPrecedes(oldminmulti, minmulti))
            update = true;
        else if (MultiXactIdPrecedes(ReadNextMultiXactId(), oldminmulti))
            futuremxid = update = true;
 
        if (update)
        {
            pgcform->relminmxid = minmulti;
            dirty = true;
            if (minmulti_updated)
                *minmulti_updated = true;
        }
    }
 
    /* If anything changed, write out the tuple. */
    if (dirty)
        systable_inplace_update_finish(inplace_state, ctup);
    else
        systable_inplace_update_cancel(inplace_state);
 
    table_close(rd, RowExclusiveLock);
 
    if (futurexid)
        ereport(WARNING,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg_internal("overwrote invalid relfrozenxid value %u with new value %u for table \"%s\"",
                                 oldfrozenxid, frozenxid,
                                 RelationGetRelationName(relation))));
    if (futuremxid)
        ereport(WARNING,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg_internal("overwrote invalid relminmxid value %u with new value %u for table \"%s\"",
                                 oldminmulti, minmulti,
                                 RelationGetRelationName(relation))));
}

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 497 of file vacuum.c.

{
    static bool in_vacuum = false;
 
    const char *stmttype;
    volatile bool in_outer_xact,
                use_own_xacts;
 
    stmttype = (params.options & VACOPT_VACUUM) ? "VACUUM" : "ANALYZE";
 
    /*
     * We cannot run VACUUM inside a user transaction block; if we were inside
     * a transaction, then our commit- and start-transaction-command calls
     * would not have the intended effect!  There are numerous other subtle
     * dependencies on this, too.
     *
     * ANALYZE (without VACUUM) can run either way.
     */
    if (params.options & VACOPT_VACUUM)
    {
        PreventInTransactionBlock(isTopLevel, stmttype);
        in_outer_xact = false;
    }
    else
        in_outer_xact = IsInTransactionBlock(isTopLevel);
 
    /*
     * Check for and disallow recursive calls.  This could happen when VACUUM
     * FULL or ANALYZE calls a hostile index expression that itself calls
     * ANALYZE.
     */
    if (in_vacuum)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("%s cannot be executed from VACUUM or ANALYZE",
                        stmttype)));
 
    /*
     * Build list of relation(s) to process, putting any new data in
     * vac_context for safekeeping.
     */
    if (params.options & VACOPT_ONLY_DATABASE_STATS)
    {
        /* We don't process any tables in this case */
        Assert(relations == NIL);
    }
    else if (relations != NIL)
    {
        List       *newrels = NIL;
        ListCell   *lc;
 
        foreach(lc, relations)
        {
            VacuumRelation *vrel = lfirst_node(VacuumRelation, lc);
            List       *sublist;
            MemoryContext old_context;
 
            sublist = expand_vacuum_rel(vrel, vac_context, params.options);
            old_context = MemoryContextSwitchTo(vac_context);
            newrels = list_concat(newrels, sublist);
            MemoryContextSwitchTo(old_context);
        }
        relations = newrels;
    }
    else
        relations = get_all_vacuum_rels(vac_context, params.options);
 
    /*
     * Decide whether we need to start/commit our own transactions.
     *
     * For VACUUM (with or without ANALYZE): always do so, so that we can
     * release locks as soon as possible.  (We could possibly use the outer
     * transaction for a one-table VACUUM, but handling TOAST tables would be
     * problematic.)
     *
     * For ANALYZE (no VACUUM): if inside a transaction block, we cannot
     * start/commit our own transactions.  Also, there's no need to do so if
     * only processing one relation.  For multiple relations when not within a
     * transaction block, and also in an autovacuum worker, use own
     * transactions so we can release locks sooner.
     */
    if (params.options & VACOPT_VACUUM)
        use_own_xacts = true;
    else
    {
        Assert(params.options & VACOPT_ANALYZE);
        if (AmAutoVacuumWorkerProcess())
            use_own_xacts = true;
        else if (in_outer_xact)
            use_own_xacts = false;
        else if (list_length(relations) > 1)
            use_own_xacts = true;
        else
            use_own_xacts = false;
    }
 
    /*
     * vacuum_rel expects to be entered with no transaction active; it will
     * start and commit its own transaction.  But we are called by an SQL
     * command, and so we are executing inside a transaction already. We
     * commit the transaction started in PostgresMain() here, and start
     * another one before exiting to match the commit waiting for us back in
     * PostgresMain().
     */
    if (use_own_xacts)
    {
        Assert(!in_outer_xact);
 
        /* ActiveSnapshot is not set by autovacuum */
        if (ActiveSnapshotSet())
            PopActiveSnapshot();
 
        /* matches the StartTransaction in PostgresMain() */
        CommitTransactionCommand();
    }
 
    /* Turn vacuum cost accounting on or off, and set/clear in_vacuum */
    PG_TRY();
    {
        ListCell   *cur;
 
        in_vacuum = true;
        VacuumFailsafeActive = false;
        VacuumUpdateCosts();
        VacuumCostBalance = 0;
        VacuumCostBalanceLocal = 0;
        VacuumSharedCostBalance = NULL;
        VacuumActiveNWorkers = NULL;
 
        /*
         * Loop to process each selected relation.
         */
        foreach(cur, relations)
        {
            VacuumRelation *vrel = lfirst_node(VacuumRelation, cur);
 
            if (params.options & VACOPT_VACUUM)
            {
                if (!vacuum_rel(vrel->oid, vrel->relation, params, bstrategy))
                    continue;
            }
 
            if (params.options & VACOPT_ANALYZE)
            {
                /*
                 * If using separate xacts, start one for analyze. Otherwise,
                 * we can use the outer transaction.
                 */
                if (use_own_xacts)
                {
                    StartTransactionCommand();
                    /* functions in indexes may want a snapshot set */
                    PushActiveSnapshot(GetTransactionSnapshot());
                }
 
                analyze_rel(vrel->oid, vrel->relation, params,
                            vrel->va_cols, in_outer_xact, bstrategy);
 
                if (use_own_xacts)
                {
                    PopActiveSnapshot();
                    /* standard_ProcessUtility() does CCI if !use_own_xacts */
                    CommandCounterIncrement();
                    CommitTransactionCommand();
                }
                else
                {
                    /*
                     * If we're not using separate xacts, better separate the
                     * ANALYZE actions with CCIs.  This avoids trouble if user
                     * says "ANALYZE t, t".
                     */
                    CommandCounterIncrement();
                }
            }
 
            /*
             * Ensure VacuumFailsafeActive has been reset before vacuuming the
             * next relation.
             */
            VacuumFailsafeActive = false;
        }
    }
    PG_FINALLY();
    {
        in_vacuum = false;
        VacuumCostActive = false;
        VacuumFailsafeActive = false;
        VacuumCostBalance = 0;
    }
    PG_END_TRY();
 
    /*
     * Finish up processing.
     */
    if (use_own_xacts)
    {
        /* here, we are not in a transaction */
 
        /*
         * This matches the CommitTransaction waiting for us in
         * PostgresMain().
         */
        StartTransactionCommand();
    }
 
    if ((params.options & VACOPT_VACUUM) &&
        !(params.options & VACOPT_SKIP_DATABASE_STATS))
    {
        /*
         * Update pg_database.datfrozenxid, and truncate pg_xact if possible.
         */
        vac_update_datfrozenxid();
    }
 
}

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 2423 of file vacuum.c.

{
    double      msec = 0;
 
    /* Always check for interrupts */
    CHECK_FOR_INTERRUPTS();
 
    if (InterruptPending ||
        (!VacuumCostActive && !ConfigReloadPending))
        return;
 
    /*
     * Autovacuum workers should reload the configuration file if requested.
     * This allows changes to [autovacuum_]vacuum_cost_limit and
     * [autovacuum_]vacuum_cost_delay to take effect while a table is being
     * vacuumed or analyzed.
     */
    if (ConfigReloadPending && AmAutoVacuumWorkerProcess())
    {
        ConfigReloadPending = false;
        ProcessConfigFile(PGC_SIGHUP);
        VacuumUpdateCosts();
    }
 
    /*
     * If we disabled cost-based delays after reloading the config file,
     * return.
     */
    if (!VacuumCostActive)
        return;
 
    /*
     * For parallel vacuum, the delay is computed based on the shared cost
     * balance.  See compute_parallel_delay.
     */
    if (VacuumSharedCostBalance != NULL)
        msec = compute_parallel_delay();
    else if (VacuumCostBalance >= vacuum_cost_limit)
        msec = vacuum_cost_delay * VacuumCostBalance / vacuum_cost_limit;
 
    /* Nap if appropriate */
    if (msec > 0)
    {
        instr_time  delay_start;
 
        if (msec > vacuum_cost_delay * 4)
            msec = vacuum_cost_delay * 4;
 
        if (track_cost_delay_timing)
            INSTR_TIME_SET_CURRENT(delay_start);
 
        pgstat_report_wait_start(WAIT_EVENT_VACUUM_DELAY);
        pg_usleep(msec * 1000);
        pgstat_report_wait_end();
 
        if (track_cost_delay_timing)
        {
            instr_time  delay_end;
            instr_time  delay;
 
            INSTR_TIME_SET_CURRENT(delay_end);
            INSTR_TIME_SET_ZERO(delay);
            INSTR_TIME_ACCUM_DIFF(delay, delay_end, delay_start);
 
            /*
             * For parallel workers, we only report the delay time every once
             * in a while to avoid overloading the leader with messages and
             * interrupts.
             */
            if (IsParallelWorker())
            {
                static instr_time last_report_time;
                instr_time  time_since_last_report;
 
                Assert(!is_analyze);
 
                /* Accumulate the delay time */
                parallel_vacuum_worker_delay_ns += INSTR_TIME_GET_NANOSEC(delay);
 
                /* Calculate interval since last report */
                INSTR_TIME_SET_ZERO(time_since_last_report);
                INSTR_TIME_ACCUM_DIFF(time_since_last_report, delay_end, last_report_time);
 
                /* If we haven't reported in a while, do so now */
                if (INSTR_TIME_GET_NANOSEC(time_since_last_report) >=
                    PARALLEL_VACUUM_DELAY_REPORT_INTERVAL_NS)
                {
                    pgstat_progress_parallel_incr_param(PROGRESS_VACUUM_DELAY_TIME,
                                                        parallel_vacuum_worker_delay_ns);
 
                    /* Reset variables */
                    last_report_time = delay_end;
                    parallel_vacuum_worker_delay_ns = 0;
                }
            }
            else if (is_analyze)
                pgstat_progress_incr_param(PROGRESS_ANALYZE_DELAY_TIME,
                                           INSTR_TIME_GET_NANOSEC(delay));
            else
                pgstat_progress_incr_param(PROGRESS_VACUUM_DELAY_TIME,
                                           INSTR_TIME_GET_NANOSEC(delay));
        }
 
        /*
         * We don't want to ignore postmaster death during very long vacuums
         * with vacuum_cost_delay configured.  We can't use the usual
         * WaitLatch() approach here because we want microsecond-based sleep
         * durations above.
         */
        if (IsUnderPostmaster && !PostmasterIsAlive())
            exit(1);
 
        VacuumCostBalance = 0;
 
        /*
         * Balance and update limit values for autovacuum workers. We must do
         * this periodically, as the number of workers across which we are
         * balancing the limit may have changed.
         *
         * TODO: There may be better criteria for determining when to do this
         * besides "check after napping".
         */
        AutoVacuumUpdateCostLimit();
 
        /* Might have gotten an interrupt while sleeping */
        CHECK_FOR_INTERRUPTS();
    }
}

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 1103 of file vacuum.c.

{
    int         freeze_min_age,
                multixact_freeze_min_age,
                freeze_table_age,
                multixact_freeze_table_age,
                effective_multixact_freeze_max_age;
    TransactionId nextXID,
                safeOldestXmin,
                aggressiveXIDCutoff;
    MultiXactId nextMXID,
                safeOldestMxact,
                aggressiveMXIDCutoff;
 
    /* Use mutable copies of freeze age parameters */
    freeze_min_age = params.freeze_min_age;
    multixact_freeze_min_age = params.multixact_freeze_min_age;
    freeze_table_age = params.freeze_table_age;
    multixact_freeze_table_age = params.multixact_freeze_table_age;
 
    /* Set pg_class fields in cutoffs */
    cutoffs->relfrozenxid = rel->rd_rel->relfrozenxid;
    cutoffs->relminmxid = rel->rd_rel->relminmxid;
 
    /*
     * Acquire OldestXmin.
     *
     * We can always ignore processes running lazy vacuum.  This is because we
     * use these values only for deciding which tuples we must keep in the
     * tables.  Since lazy vacuum doesn't write its XID anywhere (usually no
     * XID assigned), it's safe to ignore it.  In theory it could be
     * problematic to ignore lazy vacuums in a full vacuum, but keep in mind
     * that only one vacuum process can be working on a particular table at
     * any time, and that each vacuum is always an independent transaction.
     */
    cutoffs->OldestXmin = GetOldestNonRemovableTransactionId(rel);
 
    Assert(TransactionIdIsNormal(cutoffs->OldestXmin));
 
    /* Acquire OldestMxact */
    cutoffs->OldestMxact = GetOldestMultiXactId();
    Assert(MultiXactIdIsValid(cutoffs->OldestMxact));
 
    /* Acquire next XID/next MXID values used to apply age-based settings */
    nextXID = ReadNextTransactionId();
    nextMXID = ReadNextMultiXactId();
 
    /*
     * Also compute the multixact age for which freezing is urgent.  This is
     * normally autovacuum_multixact_freeze_max_age, but may be less if we are
     * short of multixact member space.
     */
    effective_multixact_freeze_max_age = MultiXactMemberFreezeThreshold();
 
    /*
     * Almost ready to set freeze output parameters; check if OldestXmin or
     * OldestMxact are held back to an unsafe degree before we start on that
     */
    safeOldestXmin = nextXID - autovacuum_freeze_max_age;
    if (!TransactionIdIsNormal(safeOldestXmin))
        safeOldestXmin = FirstNormalTransactionId;
    safeOldestMxact = nextMXID - effective_multixact_freeze_max_age;
    if (safeOldestMxact < FirstMultiXactId)
        safeOldestMxact = FirstMultiXactId;
    if (TransactionIdPrecedes(cutoffs->OldestXmin, safeOldestXmin))
        ereport(WARNING,
                (errmsg("cutoff for removing and freezing tuples is far in the past"),
                 errhint("Close open transactions soon to avoid wraparound problems.\n"
                         "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
    if (MultiXactIdPrecedes(cutoffs->OldestMxact, safeOldestMxact))
        ereport(WARNING,
                (errmsg("cutoff for freezing multixacts is far in the past"),
                 errhint("Close open transactions soon to avoid wraparound problems.\n"
                         "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
 
    /*
     * Determine the minimum freeze age to use: as specified by the caller, or
     * vacuum_freeze_min_age, but in any case not more than half
     * autovacuum_freeze_max_age, so that autovacuums to prevent XID
     * wraparound won't occur too frequently.
     */
    if (freeze_min_age < 0)
        freeze_min_age = vacuum_freeze_min_age;
    freeze_min_age = Min(freeze_min_age, autovacuum_freeze_max_age / 2);
    Assert(freeze_min_age >= 0);
 
    /* Compute FreezeLimit, being careful to generate a normal XID */
    cutoffs->FreezeLimit = nextXID - freeze_min_age;
    if (!TransactionIdIsNormal(cutoffs->FreezeLimit))
        cutoffs->FreezeLimit = FirstNormalTransactionId;
    /* FreezeLimit must always be <= OldestXmin */
    if (TransactionIdPrecedes(cutoffs->OldestXmin, cutoffs->FreezeLimit))
        cutoffs->FreezeLimit = cutoffs->OldestXmin;
 
    /*
     * Determine the minimum multixact freeze age to use: as specified by
     * caller, or vacuum_multixact_freeze_min_age, but in any case not more
     * than half effective_multixact_freeze_max_age, so that autovacuums to
     * prevent MultiXact wraparound won't occur too frequently.
     */
    if (multixact_freeze_min_age < 0)
        multixact_freeze_min_age = vacuum_multixact_freeze_min_age;
    multixact_freeze_min_age = Min(multixact_freeze_min_age,
                                   effective_multixact_freeze_max_age / 2);
    Assert(multixact_freeze_min_age >= 0);
 
    /* Compute MultiXactCutoff, being careful to generate a valid value */
    cutoffs->MultiXactCutoff = nextMXID - multixact_freeze_min_age;
    if (cutoffs->MultiXactCutoff < FirstMultiXactId)
        cutoffs->MultiXactCutoff = FirstMultiXactId;
    /* MultiXactCutoff must always be <= OldestMxact */
    if (MultiXactIdPrecedes(cutoffs->OldestMxact, cutoffs->MultiXactCutoff))
        cutoffs->MultiXactCutoff = cutoffs->OldestMxact;
 
    /*
     * Finally, figure out if caller needs to do an aggressive VACUUM or not.
     *
     * Determine the table freeze age to use: as specified by the caller, or
     * the value of the vacuum_freeze_table_age GUC, but in any case not more
     * than autovacuum_freeze_max_age * 0.95, so that if you have e.g nightly
     * VACUUM schedule, the nightly VACUUM gets a chance to freeze XIDs before
     * anti-wraparound autovacuum is launched.
     */
    if (freeze_table_age < 0)
        freeze_table_age = vacuum_freeze_table_age;
    freeze_table_age = Min(freeze_table_age, autovacuum_freeze_max_age * 0.95);
    Assert(freeze_table_age >= 0);
    aggressiveXIDCutoff = nextXID - freeze_table_age;
    if (!TransactionIdIsNormal(aggressiveXIDCutoff))
        aggressiveXIDCutoff = FirstNormalTransactionId;
    if (TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid,
                                      aggressiveXIDCutoff))
        return true;
 
    /*
     * Similar to the above, determine the table freeze age to use for
     * multixacts: as specified by the caller, or the value of the
     * vacuum_multixact_freeze_table_age GUC, but in any case not more than
     * effective_multixact_freeze_max_age * 0.95, so that if you have e.g.
     * nightly VACUUM schedule, the nightly VACUUM gets a chance to freeze
     * multixacts before anti-wraparound autovacuum is launched.
     */
    if (multixact_freeze_table_age < 0)
        multixact_freeze_table_age = vacuum_multixact_freeze_table_age;
    multixact_freeze_table_age =
        Min(multixact_freeze_table_age,
            effective_multixact_freeze_max_age * 0.95);
    Assert(multixact_freeze_table_age >= 0);
    aggressiveMXIDCutoff = nextMXID - multixact_freeze_table_age;
    if (aggressiveMXIDCutoff < FirstMultiXactId)
        aggressiveMXIDCutoff = FirstMultiXactId;
    if (MultiXactIdPrecedesOrEquals(cutoffs->relminmxid,
                                    aggressiveMXIDCutoff))
        return true;
 
    /* Non-aggressive VACUUM */
    return false;
}

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 722 of file vacuum.c.

{
    char       *relname;
 
    Assert((options & (VACOPT_VACUUM | VACOPT_ANALYZE)) != 0);
 
    /*----------
     * A role has privileges to vacuum or analyze the relation if any of the
     * following are true:
     *   - the role owns the current database and the relation is not shared
     *   - the role has the MAINTAIN privilege on the relation
     *----------
     */
    if ((object_ownercheck(DatabaseRelationId, MyDatabaseId, GetUserId()) &&
         !reltuple->relisshared) ||
        pg_class_aclcheck(relid, GetUserId(), ACL_MAINTAIN) == ACLCHECK_OK)
        return true;
 
    relname = NameStr(reltuple->relname);
 
    if ((options & VACOPT_VACUUM) != 0)
    {
        ereport(WARNING,
                (errmsg("permission denied to vacuum \"%s\", skipping it",
                        relname)));
 
        /*
         * For VACUUM ANALYZE, both logs could show up, but just generate
         * information for VACUUM as that would be the first one to be
         * processed.
         */
        return false;
    }
 
    if ((options & VACOPT_ANALYZE) != 0)
        ereport(WARNING,
                (errmsg("permission denied to analyze \"%s\", skipping it",
                        relname)));
 
    return false;
}

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 774 of file vacuum.c.

{
    Relation    rel;
    bool        rel_lock = true;
    int         elevel;
 
    Assert((options & (VACOPT_VACUUM | VACOPT_ANALYZE)) != 0);
 
    /*
     * Open the relation and get the appropriate lock on it.
     *
     * There's a race condition here: the relation may have gone away since
     * the last time we saw it.  If so, we don't need to vacuum or analyze it.
     *
     * If we've been asked not to wait for the relation lock, acquire it first
     * in non-blocking mode, before calling try_relation_open().
     */
    if (!(options & VACOPT_SKIP_LOCKED))
        rel = try_relation_open(relid, lmode);
    else if (ConditionalLockRelationOid(relid, lmode))
        rel = try_relation_open(relid, NoLock);
    else
    {
        rel = NULL;
        rel_lock = false;
    }
 
    /* if relation is opened, leave */
    if (rel)
        return rel;
 
    /*
     * Relation could not be opened, hence generate if possible a log
     * informing on the situation.
     *
     * If the RangeVar is not defined, we do not have enough information to
     * provide a meaningful log statement.  Chances are that the caller has
     * intentionally not provided this information so that this logging is
     * skipped, anyway.
     */
    if (relation == NULL)
        return NULL;
 
    /*
     * Determine the log level.
     *
     * For manual VACUUM or ANALYZE, we emit a WARNING to match the log
     * statements in the permission checks; otherwise, only log if the caller
     * so requested.
     */
    if (!AmAutoVacuumWorkerProcess())
        elevel = WARNING;
    else if (verbose)
        elevel = LOG;
    else
        return NULL;
 
    if ((options & VACOPT_VACUUM) != 0)
    {
        if (!rel_lock)
            ereport(elevel,
                    (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                     errmsg("skipping vacuum of \"%s\" --- lock not available",
                            relation->relname)));
        else
            ereport(elevel,
                    (errcode(ERRCODE_UNDEFINED_TABLE),
                     errmsg("skipping vacuum of \"%s\" --- relation no longer exists",
                            relation->relname)));
 
        /*
         * For VACUUM ANALYZE, both logs could show up, but just generate
         * information for VACUUM as that would be the first one to be
         * processed.
         */
        return NULL;
    }
 
    if ((options & VACOPT_ANALYZE) != 0)
    {
        if (!rel_lock)
            ereport(elevel,
                    (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                     errmsg("skipping analyze of \"%s\" --- lock not available",
                            relation->relname)));
        else
            ereport(elevel,
                    (errcode(ERRCODE_UNDEFINED_TABLE),
                     errmsg("skipping analyze of \"%s\" --- relation no longer exists",
                            relation->relname)));
    }
 
    return NULL;
}

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_xid_failsafe_check()

bool vacuum_xid_failsafe_check ( const struct VacuumCutoffs * cutoffs )

Definition at line 1271 of file vacuum.c.

{
    TransactionId relfrozenxid = cutoffs->relfrozenxid;
    MultiXactId relminmxid = cutoffs->relminmxid;
    TransactionId xid_skip_limit;
    MultiXactId multi_skip_limit;
    int         skip_index_vacuum;
 
    Assert(TransactionIdIsNormal(relfrozenxid));
    Assert(MultiXactIdIsValid(relminmxid));
 
    /*
     * Determine the index skipping age to use. In any case no less than
     * autovacuum_freeze_max_age * 1.05.
     */
    skip_index_vacuum = Max(vacuum_failsafe_age, autovacuum_freeze_max_age * 1.05);
 
    xid_skip_limit = ReadNextTransactionId() - skip_index_vacuum;
    if (!TransactionIdIsNormal(xid_skip_limit))
        xid_skip_limit = FirstNormalTransactionId;
 
    if (TransactionIdPrecedes(relfrozenxid, xid_skip_limit))
    {
        /* The table's relfrozenxid is too old */
        return true;
    }
 
    /*
     * Similar to above, determine the index skipping age to use for
     * multixact. In any case no less than autovacuum_multixact_freeze_max_age *
     * 1.05.
     */
    skip_index_vacuum = Max(vacuum_multixact_failsafe_age,
                            autovacuum_multixact_freeze_max_age * 1.05);
 
    multi_skip_limit = ReadNextMultiXactId() - skip_index_vacuum;
    if (multi_skip_limit < FirstMultiXactId)
        multi_skip_limit = FirstMultiXactId;
 
    if (MultiXactIdPrecedes(relminmxid, multi_skip_limit))
    {
        /* The table's relminmxid is too old */
        return true;
    }
 
    return false;
}

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().

◆ VacuumUpdateCosts()

void VacuumUpdateCosts ( void )

Definition at line 1667 of file autovacuum.c.

{
    if (MyWorkerInfo)
    {
        if (av_storage_param_cost_delay >= 0)
            vacuum_cost_delay = av_storage_param_cost_delay;
        else if (autovacuum_vac_cost_delay >= 0)
            vacuum_cost_delay = autovacuum_vac_cost_delay;
        else
            /* fall back to VacuumCostDelay */
            vacuum_cost_delay = VacuumCostDelay;
 
        AutoVacuumUpdateCostLimit();
    }
    else
    {
        /* Must be explicit VACUUM or ANALYZE */
        vacuum_cost_delay = VacuumCostDelay;
        vacuum_cost_limit = VacuumCostLimit;
    }
 
    /*
     * If configuration changes are allowed to impact VacuumCostActive, make
     * sure it is updated.
     */
    if (VacuumFailsafeActive)
        Assert(!VacuumCostActive);
    else if (vacuum_cost_delay > 0)
        VacuumCostActive = true;
    else
    {
        VacuumCostActive = false;
        VacuumCostBalance = 0;
    }
 
    /*
     * Since the cost logging requires a lock, avoid rendering the log message
     * in case we are using a message level where the log wouldn't be emitted.
     */
    if (MyWorkerInfo && message_level_is_interesting(DEBUG2))
    {
        Oid         dboid,
                    tableoid;
 
        Assert(!LWLockHeldByMe(AutovacuumLock));
 
        LWLockAcquire(AutovacuumLock, LW_SHARED);
        dboid = MyWorkerInfo->wi_dboid;
        tableoid = MyWorkerInfo->wi_tableoid;
        LWLockRelease(AutovacuumLock);
 
        elog(DEBUG2,
             "Autovacuum VacuumUpdateCosts(db=%u, rel=%u, dobalance=%s, cost_limit=%d, cost_delay=%g active=%s failsafe=%s)",
             dboid, tableoid, pg_atomic_unlocked_test_flag(&MyWorkerInfo->wi_dobalance) ? "no" : "yes",
             vacuum_cost_limit, vacuum_cost_delay,
             vacuum_cost_delay > 0 ? "yes" : "no",
             VacuumFailsafeActive ? "yes" : "no");
    }
}

References Assert(), autovacuum_vac_cost_delay, AutoVacuumUpdateCostLimit(), av_storage_param_cost_delay, DEBUG2, elog, LW_SHARED, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), message_level_is_interesting(), MyWorkerInfo, pg_atomic_unlocked_test_flag(), vacuum_cost_delay, vacuum_cost_limit, VacuumCostActive, VacuumCostBalance, VacuumCostDelay, VacuumCostLimit, VacuumFailsafeActive, WorkerInfoData::wi_dboid, WorkerInfoData::wi_dobalance, and WorkerInfoData::wi_tableoid.

Referenced by do_autovacuum(), parallel_vacuum_main(), vacuum(), and vacuum_delay_point().

Variable Documentation

◆ default_statistics_target

PGDLLIMPORT int default_statistics_target

extern

Definition at line 70 of file analyze.c.

Referenced by multirange_typanalyze(), range_typanalyze(), statext_compute_stattarget(), std_typanalyze(), and ts_typanalyze().

◆ parallel_vacuum_worker_delay_ns

PGDLLIMPORT int64 parallel_vacuum_worker_delay_ns

extern

Definition at line 94 of file vacuum.c.

Referenced by parallel_vacuum_main(), and vacuum_delay_point().

◆ track_cost_delay_timing

PGDLLIMPORT bool track_cost_delay_timing

extern

Definition at line 81 of file vacuum.c.

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

◆ vacuum_cost_delay

PGDLLIMPORT double vacuum_cost_delay

extern

Definition at line 90 of file vacuum.c.

Referenced by compute_parallel_delay(), default_reloptions(), vacuum_delay_point(), and VacuumUpdateCosts().

◆ vacuum_cost_limit

PGDLLIMPORT int vacuum_cost_limit

extern

Definition at line 91 of file vacuum.c.

Referenced by AutoVacuumUpdateCostLimit(), compute_parallel_delay(), default_reloptions(), vacuum_delay_point(), and VacuumUpdateCosts().

◆ vacuum_failsafe_age

PGDLLIMPORT int vacuum_failsafe_age

extern

Definition at line 78 of file vacuum.c.

Referenced by vacuum_xid_failsafe_check().

◆ vacuum_freeze_min_age

PGDLLIMPORT int vacuum_freeze_min_age

extern

Definition at line 74 of file vacuum.c.

Referenced by do_autovacuum(), and vacuum_get_cutoffs().

◆ vacuum_freeze_table_age

PGDLLIMPORT int vacuum_freeze_table_age

extern

Definition at line 75 of file vacuum.c.

Referenced by do_autovacuum(), and vacuum_get_cutoffs().

◆ vacuum_max_eager_freeze_failure_rate

PGDLLIMPORT double vacuum_max_eager_freeze_failure_rate

extern

Definition at line 80 of file vacuum.c.

Referenced by default_reloptions(), ExecVacuum(), and table_recheck_autovac().

◆ vacuum_multixact_failsafe_age

PGDLLIMPORT int vacuum_multixact_failsafe_age

extern

Definition at line 79 of file vacuum.c.

Referenced by vacuum_xid_failsafe_check().

◆ vacuum_multixact_freeze_min_age

PGDLLIMPORT int vacuum_multixact_freeze_min_age

extern

Definition at line 76 of file vacuum.c.

Referenced by do_autovacuum(), and vacuum_get_cutoffs().

◆ vacuum_multixact_freeze_table_age

PGDLLIMPORT int vacuum_multixact_freeze_table_age

extern

Definition at line 77 of file vacuum.c.

Referenced by do_autovacuum(), and vacuum_get_cutoffs().

◆ vacuum_truncate

PGDLLIMPORT bool vacuum_truncate

extern

Definition at line 82 of file vacuum.c.

Referenced by default_reloptions(), and vacuum_rel().

◆ VacuumActiveNWorkers

PGDLLIMPORT pg_atomic_uint32* VacuumActiveNWorkers

extern

Definition at line 116 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

PGDLLIMPORT int VacuumCostBalanceLocal

extern

Definition at line 117 of file vacuum.c.

Referenced by compute_parallel_delay(), parallel_vacuum_main(), parallel_vacuum_process_all_indexes(), and vacuum().

◆ VacuumFailsafeActive

PGDLLIMPORT bool VacuumFailsafeActive

extern

Definition at line 109 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

PGDLLIMPORT pg_atomic_uint32* VacuumSharedCostBalance

extern

Definition at line 115 of file vacuum.c.

Referenced by compute_parallel_delay(), parallel_vacuum_main(), parallel_vacuum_process_all_indexes(), vacuum(), and vacuum_delay_point().

Variables
PGDLLIMPORT int	default_statistics_target

PGDLLIMPORT int	vacuum_freeze_min_age

PGDLLIMPORT int	vacuum_freeze_table_age

PGDLLIMPORT int	vacuum_multixact_freeze_min_age

PGDLLIMPORT int	vacuum_multixact_freeze_table_age

PGDLLIMPORT int	vacuum_failsafe_age

PGDLLIMPORT int	vacuum_multixact_failsafe_age

PGDLLIMPORT bool	track_cost_delay_timing

PGDLLIMPORT bool	vacuum_truncate

PGDLLIMPORT double	vacuum_max_eager_freeze_failure_rate

PGDLLIMPORT pg_atomic_uint32 *	VacuumSharedCostBalance

PGDLLIMPORT pg_atomic_uint32 *	VacuumActiveNWorkers

PGDLLIMPORT int	VacuumCostBalanceLocal

PGDLLIMPORT bool	VacuumFailsafeActive

PGDLLIMPORT double	vacuum_cost_delay

PGDLLIMPORT int	vacuum_cost_limit

PGDLLIMPORT int64	parallel_vacuum_worker_delay_ns

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ MAX_STATISTICS_TARGET

◆ 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

◆ VACUUM_OPTION_MAX_VALID_VALUE

◆ VACUUM_OPTION_NO_PARALLEL

◆ VACUUM_OPTION_PARALLEL_BULKDEL

◆ VACUUM_OPTION_PARALLEL_CLEANUP

◆ VACUUM_OPTION_PARALLEL_COND_CLEANUP

Typedef Documentation

◆ AnalyzeAttrComputeStatsFunc

◆ AnalyzeAttrFetchFunc

◆ ParallelVacuumState

◆ VacAttrStats

◆ VacAttrStatsP

◆ VacDeadItemsInfo

◆ VacOptValue

◆ VacuumParams

Enumeration Type Documentation

◆ VacOptValue

Function Documentation

◆ analyze_rel()

◆ anl_get_next_S()

◆ anl_init_selection_state()

◆ anl_random_fract()

◆ AutoVacuumUpdateCostLimit()

◆ ExecVacuum()

◆ parallel_vacuum_bulkdel_all_indexes()

◆ parallel_vacuum_cleanup_all_indexes()

◆ parallel_vacuum_end()

◆ parallel_vacuum_get_dead_items()

◆ parallel_vacuum_init()

◆ parallel_vacuum_main()

◆ parallel_vacuum_reset_dead_items()

◆ std_typanalyze()

◆ vac_bulkdel_one_index()

◆ vac_cleanup_one_index()

◆ vac_close_indexes()

◆ vac_estimate_reltuples()

◆ vac_open_indexes()

◆ vac_update_datfrozenxid()

◆ vac_update_relstats()

◆ vacuum()

◆ vacuum_delay_point()

◆ vacuum_get_cutoffs()

◆ vacuum_is_permitted_for_relation()

◆ vacuum_open_relation()

◆ vacuum_xid_failsafe_check()

◆ VacuumUpdateCosts()

Variable Documentation

◆ default_statistics_target

◆ parallel_vacuum_worker_delay_ns

◆ track_cost_delay_timing

◆ vacuum_cost_delay

◆ vacuum_cost_limit

◆ vacuum_failsafe_age

◆ vacuum_freeze_min_age

◆ vacuum_freeze_table_age

◆ vacuum_max_eager_freeze_failure_rate

◆ vacuum_multixact_failsafe_age

◆ vacuum_multixact_freeze_min_age

◆ vacuum_multixact_freeze_table_age

◆ vacuum_truncate

◆ VacuumActiveNWorkers

◆ VacuumCostBalanceLocal