From 65052d1efea09c429f8ba37b85178e6c8c2c49aa Mon Sep 17 00:00:00 2001 From: Michael Paquier Date: Sun, 1 Mar 2015 20:45:06 +0900 Subject: [PATCH] Move freeze parameters of VacuumStmt into a separate structure VACOPT_FREEZE was being limited in the query parser and still be used in a set of assertions at the beginning of vacuum(). On the contrary, the set of parameters controlling if FREEZE is used was being set in the query parser but not used in the same set of assertions, leading to confusion regarding both aspects of VacuumStmt. This commit fixes this inconsistency by moving all the freeze parameters to a dedicated structure used by autovacuum and by setting unconditionally VACOPT_FREEZE for all the code paths of the query parser, making the whole control of FREEZE more consistent in the autovacuum code path as well as in the query parser. At the same time, VacuumStmt is removed from all the existing code path, making its use limited at the highest level of vacuum.c where its execution is done as a utility. This has the advantage of making autovacuum code path more simple. --- src/backend/commands/analyze.c | 32 +++++----- src/backend/commands/vacuum.c | 121 +++++++++++++++++++++++++----------- src/backend/commands/vacuumlazy.c | 13 ++-- src/backend/nodes/copyfuncs.c | 4 -- src/backend/nodes/equalfuncs.c | 4 -- src/backend/parser/gram.y | 50 ++------------- src/backend/postmaster/autovacuum.c | 33 +++++----- src/backend/tcop/utility.c | 2 +- src/include/commands/vacuum.h | 29 +++++++-- src/include/nodes/parsenodes.h | 14 +---- 10 files changed, 159 insertions(+), 143 deletions(-) diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c index d2856a3..75b45f7 100644 --- a/src/backend/commands/analyze.c +++ b/src/backend/commands/analyze.c @@ -85,7 +85,7 @@ static MemoryContext anl_context = NULL; static BufferAccessStrategy vac_strategy; -static void do_analyze_rel(Relation onerel, VacuumStmt *vacstmt, +static void do_analyze_rel(Relation onerel, int options, List *va_cols, AcquireSampleRowsFunc acquirefunc, BlockNumber relpages, bool inh, bool in_outer_xact, int elevel); static void BlockSampler_Init(BlockSampler bs, BlockNumber nblocks, @@ -115,7 +115,7 @@ static Datum ind_fetch_func(VacAttrStatsP stats, int rownum, bool *isNull); * analyze_rel() -- analyze one relation */ void -analyze_rel(Oid relid, VacuumStmt *vacstmt, +analyze_rel(Oid relid, RangeVar *relation, int options, List *va_cols, bool in_outer_xact, BufferAccessStrategy bstrategy) { Relation onerel; @@ -124,7 +124,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt, BlockNumber relpages = 0; /* Select logging level */ - if (vacstmt->options & VACOPT_VERBOSE) + if (options & VACOPT_VERBOSE) elevel = INFO; else elevel = DEBUG2; @@ -144,7 +144,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt, * 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. */ - if (!(vacstmt->options & VACOPT_NOWAIT)) + if (!(options & VACOPT_NOWAIT)) onerel = try_relation_open(relid, ShareUpdateExclusiveLock); else if (ConditionalLockRelationOid(relid, ShareUpdateExclusiveLock)) onerel = try_relation_open(relid, NoLock); @@ -155,7 +155,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt, ereport(LOG, (errcode(ERRCODE_LOCK_NOT_AVAILABLE), errmsg("skipping analyze of \"%s\" --- lock not available", - vacstmt->relation->relname))); + relation->relname))); } if (!onerel) return; @@ -167,7 +167,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt, (pg_database_ownercheck(MyDatabaseId, GetUserId()) && !onerel->rd_rel->relisshared))) { /* No need for a WARNING if we already complained during VACUUM */ - if (!(vacstmt->options & VACOPT_VACUUM)) + if (!(options & VACOPT_VACUUM)) { if (onerel->rd_rel->relisshared) ereport(WARNING, @@ -248,7 +248,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt, else { /* No need for a WARNING if we already complained during VACUUM */ - if (!(vacstmt->options & VACOPT_VACUUM)) + if (!(options & VACOPT_VACUUM)) ereport(WARNING, (errmsg("skipping \"%s\" --- cannot analyze non-tables or special system tables", RelationGetRelationName(onerel)))); @@ -266,14 +266,14 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt, /* * Do the normal non-recursive ANALYZE. */ - do_analyze_rel(onerel, vacstmt, acquirefunc, relpages, + do_analyze_rel(onerel, options, 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, vacstmt, acquirefunc, relpages, + do_analyze_rel(onerel, options, va_cols, acquirefunc, relpages, true, in_outer_xact, elevel); /* @@ -302,7 +302,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt, * acquirefunc for each child table. */ static void -do_analyze_rel(Relation onerel, VacuumStmt *vacstmt, +do_analyze_rel(Relation onerel, int options, List *va_cols, AcquireSampleRowsFunc acquirefunc, BlockNumber relpages, bool inh, bool in_outer_xact, int elevel) { @@ -372,14 +372,14 @@ do_analyze_rel(Relation onerel, VacuumStmt *vacstmt, * * Note that system attributes are never analyzed. */ - if (vacstmt->va_cols != NIL) + if (va_cols != NIL) { ListCell *le; - vacattrstats = (VacAttrStats **) palloc(list_length(vacstmt->va_cols) * + vacattrstats = (VacAttrStats **) palloc(list_length(va_cols) * sizeof(VacAttrStats *)); tcnt = 0; - foreach(le, vacstmt->va_cols) + foreach(le, va_cols) { char *col = strVal(lfirst(le)); @@ -436,7 +436,7 @@ do_analyze_rel(Relation onerel, VacuumStmt *vacstmt, thisdata->indexInfo = indexInfo = BuildIndexInfo(Irel[ind]); thisdata->tupleFract = 1.0; /* fix later if partial */ - if (indexInfo->ii_Expressions != NIL && vacstmt->va_cols == NIL) + if (indexInfo->ii_Expressions != NIL && va_cols == NIL) { ListCell *indexpr_item = list_head(indexInfo->ii_Expressions); @@ -595,7 +595,7 @@ do_analyze_rel(Relation onerel, VacuumStmt *vacstmt, * VACUUM ANALYZE, don't overwrite the accurate count already inserted by * VACUUM. */ - if (!inh && !(vacstmt->options & VACOPT_VACUUM)) + if (!inh && !(options & VACOPT_VACUUM)) { for (ind = 0; ind < nindexes; ind++) { @@ -623,7 +623,7 @@ do_analyze_rel(Relation onerel, VacuumStmt *vacstmt, pgstat_report_analyze(onerel, totalrows, totaldeadrows); /* If this isn't part of VACUUM ANALYZE, let index AMs do cleanup */ - if (!(vacstmt->options & VACOPT_VACUUM)) + if (!(options & VACOPT_VACUUM)) { for (ind = 0; ind < nindexes; ind++) { diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 2f3f79d..885b5cd 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -71,35 +71,81 @@ static void vac_truncate_clog(TransactionId frozenXID, MultiXactId minMulti, TransactionId lastSaneFrozenXid, MultiXactId lastSaneMinMulti); -static bool vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, - bool for_wraparound); +static bool vacuum_rel(Oid relid, RangeVar *relation, int options, + VacuumParams *params, bool do_toast); +/* + * Primary entry point for manual VACUUM and ANALYZE commands + * + * This is mainly a preparation wrapper for the real operations that will + * happen in vacuum(). + */ +void +ExecVacuum(VacuumStmt *vacstmt, bool isTopLevel) +{ + VacuumParams *params; + + /* sanity checks on options */ + Assert(vacstmt->options & (VACOPT_VACUUM | VACOPT_ANALYZE)); + Assert((vacstmt->options & VACOPT_VACUUM) || + !(vacstmt->options & (VACOPT_FULL | VACOPT_FREEZE))); + Assert((vacstmt->options & VACOPT_ANALYZE) || vacstmt->va_cols == NIL); + + /* Build list of parameters */ + params = (VacuumParams *) palloc(sizeof(VacuumParams)); + if (vacstmt->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; + } + params->is_wraparound = false; + + /* Now go through the common routine */ + vacuum(params, vacstmt->relation, vacstmt->options, vacstmt->va_cols, + InvalidOid, true, NULL, isTopLevel); +} /* * Primary entry point for VACUUM and ANALYZE commands. * + * params contains a set of parameters used by autovacuum to customize the + * behavior of process. + * + * relation is the relation RangeVar that will be operated. + * + * options is the list of options passed by the parser in case of a manual + * VACUUM or ANALYZE, or the options defined by autovacuum. + * * relid is normally InvalidOid; if it is not, then it provides the relation * OID to be processed, and vacstmt->relation is ignored. (The non-invalid * case is currently only used by autovacuum.) * + * va_cols is a list of columns to analyze, or NIL to list all the columns. + * * do_toast is passed as FALSE by autovacuum, because it processes TOAST * tables separately. * - * for_wraparound is used by autovacuum to let us know when it's forcing - * a vacuum for wraparound, which should not be auto-canceled. - * * bstrategy is normally given as NULL, but in autovacuum it can be passed * in to use the same buffer strategy object across multiple vacuum() calls. * * isTopLevel should be passed down from ProcessUtility. * - * It is the caller's responsibility that vacstmt and bstrategy - * (if given) be allocated in a memory context that won't disappear - * at transaction commit. + * It is the caller's responsibility that params and bstrategy are allocated + * in a memory context that will not disappear at transaction commit. */ void -vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, - BufferAccessStrategy bstrategy, bool for_wraparound, bool isTopLevel) +vacuum(VacuumParams *params, RangeVar *relation, int options, + List *va_cols, Oid relid, bool do_toast, BufferAccessStrategy bstrategy, + bool isTopLevel) { const char *stmttype; volatile bool in_outer_xact, @@ -107,13 +153,9 @@ vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, List *relations; static bool in_vacuum = false; - /* sanity checks on options */ - Assert(vacstmt->options & (VACOPT_VACUUM | VACOPT_ANALYZE)); - Assert((vacstmt->options & VACOPT_VACUUM) || - !(vacstmt->options & (VACOPT_FULL | VACOPT_FREEZE))); - Assert((vacstmt->options & VACOPT_ANALYZE) || vacstmt->va_cols == NIL); + Assert(params != NULL); - stmttype = (vacstmt->options & VACOPT_VACUUM) ? "VACUUM" : "ANALYZE"; + stmttype = (options & VACOPT_VACUUM) ? "VACUUM" : "ANALYZE"; /* * We cannot run VACUUM inside a user transaction block; if we were inside @@ -123,7 +165,7 @@ vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, * * ANALYZE (without VACUUM) can run either way. */ - if (vacstmt->options & VACOPT_VACUUM) + if (options & VACOPT_VACUUM) { PreventTransactionChain(isTopLevel, stmttype); in_outer_xact = false; @@ -143,7 +185,7 @@ vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, * Send info about dead objects to the statistics collector, unless we are * in autovacuum --- autovacuum.c does this for itself. */ - if ((vacstmt->options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess()) + if ((options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess()) pgstat_vacuum_stat(); /* @@ -175,7 +217,7 @@ vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, * Build list of relations to process, unless caller gave us one. (If we * build one, we put it in vac_context for safekeeping.) */ - relations = get_rel_oids(relid, vacstmt->relation); + relations = get_rel_oids(relid, relation); /* * Decide whether we need to start/commit our own transactions. @@ -191,11 +233,11 @@ vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, * transaction block, and also in an autovacuum worker, use own * transactions so we can release locks sooner. */ - if (vacstmt->options & VACOPT_VACUUM) + if (options & VACOPT_VACUUM) use_own_xacts = true; else { - Assert(vacstmt->options & VACOPT_ANALYZE); + Assert(options & VACOPT_ANALYZE); if (IsAutoVacuumWorkerProcess()) use_own_xacts = true; else if (in_outer_xact) @@ -245,13 +287,14 @@ vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, { Oid relid = lfirst_oid(cur); - if (vacstmt->options & VACOPT_VACUUM) + if (options & VACOPT_VACUUM) { - if (!vacuum_rel(relid, vacstmt, do_toast, for_wraparound)) + if (!vacuum_rel(relid, relation, + options, params, do_toast)) continue; } - if (vacstmt->options & VACOPT_ANALYZE) + if (options & VACOPT_ANALYZE) { /* * If using separate xacts, start one for analyze. Otherwise, @@ -264,7 +307,8 @@ vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, PushActiveSnapshot(GetTransactionSnapshot()); } - analyze_rel(relid, vacstmt, in_outer_xact, vac_strategy); + analyze_rel(relid, relation, options, + va_cols, in_outer_xact, vac_strategy); if (use_own_xacts) { @@ -299,7 +343,7 @@ vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, StartTransactionCommand(); } - if ((vacstmt->options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess()) + if ((options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess()) { /* * Update pg_database.datfrozenxid, and truncate pg_clog if possible. @@ -1113,7 +1157,8 @@ vac_truncate_clog(TransactionId frozenXID, * At entry and exit, we are not inside a transaction. */ static bool -vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) +vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params, + bool do_toast) { LOCKMODE lmode; Relation onerel; @@ -1123,6 +1168,8 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) int save_sec_context; int save_nestlevel; + Assert(params != NULL); + /* Begin a transaction for vacuuming this relation */ StartTransactionCommand(); @@ -1132,7 +1179,7 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) */ PushActiveSnapshot(GetTransactionSnapshot()); - if (!(vacstmt->options & VACOPT_FULL)) + if (!(options & VACOPT_FULL)) { /* * In lazy vacuum, we can set the PROC_IN_VACUUM flag, which lets @@ -1156,7 +1203,7 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) */ LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE); MyPgXact->vacuumFlags |= PROC_IN_VACUUM; - if (for_wraparound) + if (params->is_wraparound) MyPgXact->vacuumFlags |= PROC_VACUUM_FOR_WRAPAROUND; LWLockRelease(ProcArrayLock); } @@ -1172,7 +1219,7 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) * vacuum, but just ShareUpdateExclusiveLock for concurrent vacuum. Either * way, we can be sure that no other backend is vacuuming the same table. */ - lmode = (vacstmt->options & VACOPT_FULL) ? AccessExclusiveLock : ShareUpdateExclusiveLock; + lmode = (options & VACOPT_FULL) ? AccessExclusiveLock : ShareUpdateExclusiveLock; /* * Open the relation and get the appropriate lock on it. @@ -1183,7 +1230,7 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) * 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 (!(vacstmt->options & VACOPT_NOWAIT)) + if (!(options & VACOPT_NOWAIT)) onerel = try_relation_open(relid, lmode); else if (ConditionalLockRelationOid(relid, lmode)) onerel = try_relation_open(relid, NoLock); @@ -1194,7 +1241,7 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) ereport(LOG, (errcode(ERRCODE_LOCK_NOT_AVAILABLE), errmsg("skipping vacuum of \"%s\" --- lock not available", - vacstmt->relation->relname))); + relation->relname))); } if (!onerel) @@ -1286,7 +1333,7 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) * us to process it. In VACUUM FULL, though, the toast table is * automatically rebuilt by cluster_rel so we shouldn't recurse to it. */ - if (do_toast && !(vacstmt->options & VACOPT_FULL)) + if (do_toast && !(options & VACOPT_FULL)) toast_relid = onerel->rd_rel->reltoastrelid; else toast_relid = InvalidOid; @@ -1305,7 +1352,7 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) /* * Do the actual work --- either FULL or "lazy" vacuum */ - if (vacstmt->options & VACOPT_FULL) + if (options & VACOPT_FULL) { /* close relation before vacuuming, but hold lock until commit */ relation_close(onerel, NoLock); @@ -1313,10 +1360,10 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) /* VACUUM FULL is now a variant of CLUSTER; see cluster.c */ cluster_rel(relid, InvalidOid, false, - (vacstmt->options & VACOPT_VERBOSE) != 0); + (options & VACOPT_VERBOSE) != 0); } else - lazy_vacuum_rel(onerel, vacstmt, vac_strategy); + lazy_vacuum_rel(onerel, options, params, vac_strategy); /* Roll back any GUC changes executed by index functions */ AtEOXact_GUC(false, save_nestlevel); @@ -1342,7 +1389,7 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound) * totally unimportant for toast relations. */ if (toast_relid != InvalidOid) - vacuum_rel(toast_relid, vacstmt, false, for_wraparound); + vacuum_rel(toast_relid, relation, options, params, false); /* * Now release the session-level lock on the master table. diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c index 7d9e49e..cd5ca4c 100644 --- a/src/backend/commands/vacuumlazy.c +++ b/src/backend/commands/vacuumlazy.c @@ -169,7 +169,7 @@ static bool heap_page_is_all_visible(Relation rel, Buffer buf, * and locked the relation. */ void -lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt, +lazy_vacuum_rel(Relation onerel, int options, VacuumParams *params, BufferAccessStrategy bstrategy) { LVRelStats *vacrelstats; @@ -193,6 +193,8 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt, TransactionId new_frozen_xid; MultiXactId new_min_multi; + Assert(params != NULL); + /* measure elapsed time iff autovacuum logging requires it */ if (IsAutoVacuumWorkerProcess() && Log_autovacuum_min_duration >= 0) { @@ -200,7 +202,7 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt, starttime = GetCurrentTimestamp(); } - if (vacstmt->options & VACOPT_VERBOSE) + if (options & VACOPT_VERBOSE) elevel = INFO; else elevel = DEBUG2; @@ -208,9 +210,10 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt, vac_strategy = bstrategy; vacuum_set_xid_limits(onerel, - vacstmt->freeze_min_age, vacstmt->freeze_table_age, - vacstmt->multixact_freeze_min_age, - vacstmt->multixact_freeze_table_age, + params->freeze_min_age, + params->freeze_table_age, + params->multixact_freeze_min_age, + params->multixact_freeze_table_age, &OldestXmin, &FreezeLimit, &xidFullScanLimit, &MultiXactCutoff, &mxactFullScanLimit); diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index 9fe8008..4f0e278 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -3292,10 +3292,6 @@ _copyVacuumStmt(const VacuumStmt *from) VacuumStmt *newnode = makeNode(VacuumStmt); COPY_SCALAR_FIELD(options); - COPY_SCALAR_FIELD(freeze_min_age); - COPY_SCALAR_FIELD(freeze_table_age); - COPY_SCALAR_FIELD(multixact_freeze_min_age); - COPY_SCALAR_FIELD(multixact_freeze_table_age); COPY_NODE_FIELD(relation); COPY_NODE_FIELD(va_cols); diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index fe509b0..6b55500 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -1507,10 +1507,6 @@ static bool _equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b) { COMPARE_SCALAR_FIELD(options); - COMPARE_SCALAR_FIELD(freeze_min_age); - COMPARE_SCALAR_FIELD(freeze_table_age); - COMPARE_SCALAR_FIELD(multixact_freeze_min_age); - COMPARE_SCALAR_FIELD(multixact_freeze_table_age); COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(va_cols); diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index 581f7a1..4b9a17f 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -9068,12 +9068,10 @@ VacuumStmt: VACUUM opt_full opt_freeze opt_verbose n->options = VACOPT_VACUUM; if ($2) n->options |= VACOPT_FULL; + if ($3) + n->options |= VACOPT_FREEZE; if ($4) n->options |= VACOPT_VERBOSE; - n->freeze_min_age = $3 ? 0 : -1; - n->freeze_table_age = $3 ? 0 : -1; - n->multixact_freeze_min_age = $3 ? 0 : -1; - n->multixact_freeze_table_age = $3 ? 0 : -1; n->relation = NULL; n->va_cols = NIL; $$ = (Node *)n; @@ -9084,12 +9082,10 @@ VacuumStmt: VACUUM opt_full opt_freeze opt_verbose n->options = VACOPT_VACUUM; if ($2) n->options |= VACOPT_FULL; + if ($3) + n->options |= VACOPT_FREEZE; if ($4) n->options |= VACOPT_VERBOSE; - n->freeze_min_age = $3 ? 0 : -1; - n->freeze_table_age = $3 ? 0 : -1; - n->multixact_freeze_min_age = $3 ? 0 : -1; - n->multixact_freeze_table_age = $3 ? 0 : -1; n->relation = $5; n->va_cols = NIL; $$ = (Node *)n; @@ -9100,30 +9096,16 @@ VacuumStmt: VACUUM opt_full opt_freeze opt_verbose n->options |= VACOPT_VACUUM; if ($2) n->options |= VACOPT_FULL; + if ($3) + n->options |= VACOPT_FREEZE; if ($4) n->options |= VACOPT_VERBOSE; - n->freeze_min_age = $3 ? 0 : -1; - n->freeze_table_age = $3 ? 0 : -1; - n->multixact_freeze_min_age = $3 ? 0 : -1; - n->multixact_freeze_table_age = $3 ? 0 : -1; $$ = (Node *)n; } | VACUUM '(' vacuum_option_list ')' { VacuumStmt *n = makeNode(VacuumStmt); n->options = VACOPT_VACUUM | $3; - if (n->options & VACOPT_FREEZE) - { - n->freeze_min_age = n->freeze_table_age = 0; - n->multixact_freeze_min_age = 0; - n->multixact_freeze_table_age = 0; - } - else - { - n->freeze_min_age = n->freeze_table_age = -1; - n->multixact_freeze_min_age = -1; - n->multixact_freeze_table_age = -1; - } n->relation = NULL; n->va_cols = NIL; $$ = (Node *) n; @@ -9132,18 +9114,6 @@ VacuumStmt: VACUUM opt_full opt_freeze opt_verbose { VacuumStmt *n = makeNode(VacuumStmt); n->options = VACOPT_VACUUM | $3; - if (n->options & VACOPT_FREEZE) - { - n->freeze_min_age = n->freeze_table_age = 0; - n->multixact_freeze_min_age = 0; - n->multixact_freeze_table_age = 0; - } - else - { - n->freeze_min_age = n->freeze_table_age = -1; - n->multixact_freeze_min_age = -1; - n->multixact_freeze_table_age = -1; - } n->relation = $5; n->va_cols = $6; if (n->va_cols != NIL) /* implies analyze */ @@ -9171,10 +9141,6 @@ AnalyzeStmt: n->options = VACOPT_ANALYZE; if ($2) n->options |= VACOPT_VERBOSE; - n->freeze_min_age = -1; - n->freeze_table_age = -1; - n->multixact_freeze_min_age = -1; - n->multixact_freeze_table_age = -1; n->relation = NULL; n->va_cols = NIL; $$ = (Node *)n; @@ -9185,10 +9151,6 @@ AnalyzeStmt: n->options = VACOPT_ANALYZE; if ($2) n->options |= VACOPT_VERBOSE; - n->freeze_min_age = -1; - n->freeze_table_age = -1; - n->multixact_freeze_min_age = -1; - n->multixact_freeze_table_age = -1; n->relation = $3; n->va_cols = $4; $$ = (Node *)n; diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 77158c1..447531e 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -2740,36 +2740,39 @@ static void autovacuum_do_vac_analyze(autovac_table *tab, BufferAccessStrategy bstrategy) { - VacuumStmt vacstmt; - RangeVar rangevar; + VacuumParams params; + RangeVar rangevar; + int options = 0; /* Set up command parameters --- use local variables instead of palloc */ - MemSet(&vacstmt, 0, sizeof(vacstmt)); MemSet(&rangevar, 0, sizeof(rangevar)); rangevar.schemaname = tab->at_nspname; rangevar.relname = tab->at_relname; rangevar.location = -1; - vacstmt.type = T_VacuumStmt; if (!tab->at_wraparound) - vacstmt.options = VACOPT_NOWAIT; + options = VACOPT_NOWAIT; if (tab->at_dovacuum) - vacstmt.options |= VACOPT_VACUUM; + options |= VACOPT_VACUUM; if (tab->at_doanalyze) - vacstmt.options |= VACOPT_ANALYZE; - vacstmt.freeze_min_age = tab->at_freeze_min_age; - vacstmt.freeze_table_age = tab->at_freeze_table_age; - vacstmt.multixact_freeze_min_age = tab->at_multixact_freeze_min_age; - vacstmt.multixact_freeze_table_age = tab->at_multixact_freeze_table_age; - /* we pass the OID, but might need this anyway for an error message */ - vacstmt.relation = &rangevar; - vacstmt.va_cols = NIL; + options |= VACOPT_ANALYZE; + + params.freeze_min_age = tab->at_freeze_min_age; + params.freeze_table_age = tab->at_freeze_table_age; + params.multixact_freeze_min_age = tab->at_multixact_freeze_min_age; + params.multixact_freeze_table_age = tab->at_multixact_freeze_table_age; + params.is_wraparound = tab->at_wraparound; /* Let pgstat know what we're doing */ autovac_report_activity(tab); - vacuum(&vacstmt, tab->at_relid, false, bstrategy, tab->at_wraparound, true); + /* + * Now go through the common routine. Note that we pass the OID, as it + * might be needed anyway for an error message. + */ + vacuum(¶ms, &rangevar, options, NIL, + tab->at_relid, false, bstrategy, true); } /* diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c index daf5326..bd26227 100644 --- a/src/backend/tcop/utility.c +++ b/src/backend/tcop/utility.c @@ -627,7 +627,7 @@ standard_ProcessUtility(Node *parsetree, /* we choose to allow this during "read only" transactions */ PreventCommandDuringRecovery((stmt->options & VACOPT_VACUUM) ? "VACUUM" : "ANALYZE"); - vacuum(stmt, InvalidOid, true, NULL, false, isTopLevel); + ExecVacuum(stmt, isTopLevel); } break; diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h index 4275484..11d618e 100644 --- a/src/include/commands/vacuum.h +++ b/src/include/commands/vacuum.h @@ -130,6 +130,20 @@ typedef struct VacAttrStats int rowstride; } VacAttrStats; +/* + * Parameters customizing behavior of a VACUUM or ANALYZE query. + */ +typedef struct VacuumParams +{ + int freeze_min_age; /* min freeze age, or -1 to use default */ + int freeze_table_age; /* age at which to scan whole table */ + int multixact_freeze_min_age; /* min multixact freeze age, + * or -1 to use default */ + int multixact_freeze_table_age; /* multixact age at which to + * scan whole table */ + bool is_wraparound; /* enforce a wraparound for vacuum, which + * should not be auto-canceled */ +} VacuumParams; /* GUC parameters */ extern PGDLLIMPORT int default_statistics_target; /* PGDLLIMPORT for @@ -141,8 +155,10 @@ extern int vacuum_multixact_freeze_table_age; /* in commands/vacuum.c */ -extern void vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast, - BufferAccessStrategy bstrategy, bool for_wraparound, bool isTopLevel); +extern void ExecVacuum(VacuumStmt *vacstmt, bool isTopLevel); +extern void vacuum(VacuumParams *params, RangeVar *relation, int options, + List *va_cols, Oid relid, bool do_toast, BufferAccessStrategy bstrategy, + bool isTopLevel); extern void vac_open_indexes(Relation relation, LOCKMODE lockmode, int *nindexes, Relation **Irel); extern void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode); @@ -171,12 +187,13 @@ extern void vac_update_datfrozenxid(void); extern void vacuum_delay_point(void); /* in commands/vacuumlazy.c */ -extern void lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt, - BufferAccessStrategy bstrategy); +extern void lazy_vacuum_rel(Relation onerel, int options, + VacuumParams *params, BufferAccessStrategy bstrategy); /* in commands/analyze.c */ -extern void analyze_rel(Oid relid, VacuumStmt *vacstmt, - bool in_outer_xact, BufferAccessStrategy bstrategy); +extern void analyze_rel(Oid relid, RangeVar *relation, int options, + List *va_cols, bool in_outer_xact, + BufferAccessStrategy bstrategy); extern bool std_typanalyze(VacAttrStats *stats); extern double anl_random_fract(void); extern double anl_init_selection_state(int n); diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h index ac13302..4c8b14c 100644 --- a/src/include/nodes/parsenodes.h +++ b/src/include/nodes/parsenodes.h @@ -2598,9 +2598,7 @@ typedef struct ClusterStmt * * Even though these are nominally two statements, it's convenient to use * just one node type for both. Note that at least one of VACOPT_VACUUM - * and VACOPT_ANALYZE must be set in options. VACOPT_FREEZE is an internal - * convenience for the grammar and is not examined at runtime --- the - * freeze_min_age and freeze_table_age fields are what matter. + * and VACOPT_ANALYZE must be set in options. * ---------------------- */ typedef enum VacuumOption @@ -2615,14 +2613,8 @@ typedef enum VacuumOption typedef struct VacuumStmt { - NodeTag type; - int options; /* OR of VacuumOption flags */ - int freeze_min_age; /* min freeze age, or -1 to use default */ - int freeze_table_age; /* age at which to scan whole table */ - int multixact_freeze_min_age; /* min multixact freeze age, - * or -1 to use default */ - int multixact_freeze_table_age; /* multixact age at which to - * scan whole table */ + NodeTag type; + int options; /* OR of VacuumOption flags */ RangeVar *relation; /* single table to process, or NULL */ List *va_cols; /* list of column names, or NIL for all */ } VacuumStmt; -- 2.3.1