Fold vacuum's 'int options' parameter into VacuumParams.

Many places need both, so this allows a few functions to take one
fewer parameter.  More importantly, as soon as we add a VACUUM
option that takes a non-Boolean parameter, we need to replace
'int options' with a struct, and it seems better to think
of adding more fields to VacuumParams rather than passing around
both VacuumParams and a separate struct as well.

Patch by me, reviewed by Masahiko Sawada

Discussion: http://postgr.es/m/CA+Tgmob6g6-s50fyv8E8he7APfwCYYJ4z0wbZC2yZeSz=26CYQ@mail.gmail.com

diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 9416c31889ede10803d20a451f9bc4a043965501..5c554f94659b60ff658e1156c20ba97d664c9ee4 100644 (file)
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -186,7 +186,7 @@ static bool heap_page_is_all_visible(Relation rel, Buffer buf,
  *             and locked the relation.
  */
 void
-heap_vacuum_rel(Relation onerel, int options, VacuumParams *params,
+heap_vacuum_rel(Relation onerel, VacuumParams *params,
                                BufferAccessStrategy bstrategy)
 {
        LVRelStats *vacrelstats;
@@ -217,7 +217,7 @@ heap_vacuum_rel(Relation onerel, int options, VacuumParams *params,
                starttime = GetCurrentTimestamp();
        }
 
-       if (options & VACOPT_VERBOSE)
+       if (params->options & VACOPT_VERBOSE)
                elevel = INFO;
        else
                elevel = DEBUG2;
@@ -245,7 +245,7 @@ heap_vacuum_rel(Relation onerel, int options, VacuumParams *params,
                                                                                           xidFullScanLimit);
        aggressive |= MultiXactIdPrecedesOrEquals(onerel->rd_rel->relminmxid,
                                                                                          mxactFullScanLimit);
-       if (options & VACOPT_DISABLE_PAGE_SKIPPING)
+       if (params->options & VACOPT_DISABLE_PAGE_SKIPPING)
                aggressive = true;
 
        vacrelstats = (LVRelStats *) palloc0(sizeof(LVRelStats));
@@ -261,7 +261,7 @@ heap_vacuum_rel(Relation onerel, int options, VacuumParams *params,
        vacrelstats->hasindex = (nindexes > 0);
 
        /* Do the vacuuming */
-       lazy_scan_heap(onerel, options, vacrelstats, Irel, nindexes, aggressive);
+       lazy_scan_heap(onerel, params->options, vacrelstats, Irel, nindexes, aggressive);
 
        /* Done with indexes */
        vac_close_indexes(nindexes, Irel, NoLock);

diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index c8192353ebe2643858ef9123a82c07c598523fc6..3465713d1084dc63fa3c4e3f66803157eefe7b24 100644 (file)
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -84,7 +84,7 @@ static MemoryContext anl_context = NULL;
 static BufferAccessStrategy vac_strategy;
 
 
-static void do_analyze_rel(Relation onerel, int options,
+static void do_analyze_rel(Relation onerel,
                           VacuumParams *params, List *va_cols,
                           AcquireSampleRowsFunc acquirefunc, BlockNumber relpages,
                           bool inh, bool in_outer_xact, int elevel);
@@ -115,7 +115,7 @@ static Datum ind_fetch_func(VacAttrStatsP stats, int rownum, bool *isNull);
  * use it once we've successfully opened the rel, since it might be stale.
  */
 void
-analyze_rel(Oid relid, RangeVar *relation, int options,
+analyze_rel(Oid relid, RangeVar *relation,
                        VacuumParams *params, List *va_cols, bool in_outer_xact,
                        BufferAccessStrategy bstrategy)
 {
@@ -125,7 +125,7 @@ analyze_rel(Oid relid, RangeVar *relation, int options,
        BlockNumber relpages = 0;
 
        /* Select logging level */
-       if (options & VACOPT_VERBOSE)
+       if (params->options & VACOPT_VERBOSE)
                elevel = INFO;
        else
                elevel = DEBUG2;
@@ -147,8 +147,8 @@ analyze_rel(Oid relid, RangeVar *relation, int options,
         *
         * Make sure to generate only logs for ANALYZE in this case.
         */
-       onerel = vacuum_open_relation(relid, relation, params,
-                                                                 options & ~(VACOPT_VACUUM),
+       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 */
@@ -165,7 +165,7 @@ analyze_rel(Oid relid, RangeVar *relation, int options,
         */
        if (!vacuum_is_relation_owner(RelationGetRelid(onerel),
                                                                  onerel->rd_rel,
-                                                                 options & VACOPT_ANALYZE))
+                                                                 params->options & VACOPT_ANALYZE))
        {
                relation_close(onerel, ShareUpdateExclusiveLock);
                return;
@@ -237,7 +237,7 @@ analyze_rel(Oid relid, RangeVar *relation, int options,
        else
        {
                /* No need for a WARNING if we already complained during VACUUM */
-               if (!(options & VACOPT_VACUUM))
+               if (!(params->options & VACOPT_VACUUM))
                        ereport(WARNING,
                                        (errmsg("skipping \"%s\" --- cannot analyze non-tables or special system tables",
                                                        RelationGetRelationName(onerel))));
@@ -257,14 +257,14 @@ analyze_rel(Oid relid, RangeVar *relation, int options,
         * tables, which don't contain any rows.
         */
        if (onerel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
-               do_analyze_rel(onerel, options, params, va_cols, acquirefunc,
+               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, options, params, va_cols, acquirefunc, relpages,
+               do_analyze_rel(onerel, params, va_cols, acquirefunc, relpages,
                                           true, in_outer_xact, elevel);
 
        /*
@@ -292,7 +292,7 @@ analyze_rel(Oid relid, RangeVar *relation, int options,
  * appropriate acquirefunc for each child table.
  */
 static void
-do_analyze_rel(Relation onerel, int options, VacuumParams *params,
+do_analyze_rel(Relation onerel, VacuumParams *params,
                           List *va_cols, AcquireSampleRowsFunc acquirefunc,
                           BlockNumber relpages, bool inh, bool in_outer_xact,
                           int elevel)
@@ -603,7 +603,7 @@ do_analyze_rel(Relation onerel, int options, VacuumParams *params,
         * VACUUM ANALYZE, don't overwrite the accurate count already inserted by
         * VACUUM.
         */
-       if (!inh && !(options & VACOPT_VACUUM))
+       if (!inh && !(params->options & VACOPT_VACUUM))
        {
                for (ind = 0; ind < nindexes; ind++)
                {
@@ -634,7 +634,7 @@ do_analyze_rel(Relation onerel, int options, VacuumParams *params,
                                                          (va_cols == NIL));
 
        /* If this isn't part of VACUUM ANALYZE, let index AMs do cleanup */
-       if (!(options & VACOPT_VACUUM))
+       if (!(params->options & VACOPT_VACUUM))
        {
                for (ind = 0; ind < nindexes; ind++)
                {

diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 1b5b50cf01958848bb09cbefd848f53656e8be93..be03185a7f7d7d4d813ce18d0efe764cb7d1b856 100644 (file)
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -74,8 +74,7 @@ static void vac_truncate_clog(TransactionId frozenXID,
                                  MultiXactId minMulti,
                                  TransactionId lastSaneFrozenXid,
                                  MultiXactId lastSaneMinMulti);
-static bool vacuum_rel(Oid relid, RangeVar *relation, int options,
-                  VacuumParams *params);
+static bool vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params);
 
 /*
  * Primary entry point for manual VACUUM and ANALYZE commands
@@ -112,6 +111,9 @@ ExecVacuum(VacuumStmt *vacstmt, bool isTopLevel)
                }
        }
 
+       /* copy options from parse tree */
+       params.options = vacstmt->options;
+
        /*
         * All freeze ages are zero if the FREEZE option is given; otherwise pass
         * them as -1 which means to use the default values.
@@ -138,14 +140,12 @@ ExecVacuum(VacuumStmt *vacstmt, bool isTopLevel)
        params.log_min_duration = -1;
 
        /* Now go through the common routine */
-       vacuum(vacstmt->options, vacstmt->rels, &params, NULL, isTopLevel);
+       vacuum(vacstmt->rels, &params, NULL, isTopLevel);
 }
 
 /*
  * Internal entry point for VACUUM and ANALYZE commands.
  *
- * options is a bitmask of VacuumOption flags, indicating what to do.
- *
  * relations, if not NIL, is a list of VacuumRelation to process; otherwise,
  * we process all relevant tables in the database.  For each VacuumRelation,
  * if a valid OID is supplied, the table with that OID is what to process;
@@ -163,7 +163,7 @@ ExecVacuum(VacuumStmt *vacstmt, bool isTopLevel)
  * memory context that will not disappear at transaction commit.
  */
 void
-vacuum(int options, List *relations, VacuumParams *params,
+vacuum(List *relations, VacuumParams *params,
           BufferAccessStrategy bstrategy, bool isTopLevel)
 {
        static bool in_vacuum = false;
@@ -174,7 +174,7 @@ vacuum(int options, List *relations, VacuumParams *params,
 
        Assert(params != NULL);
 
-       stmttype = (options & VACOPT_VACUUM) ? "VACUUM" : "ANALYZE";
+       stmttype = (params->options & VACOPT_VACUUM) ? "VACUUM" : "ANALYZE";
 
        /*
         * We cannot run VACUUM inside a user transaction block; if we were inside
@@ -184,7 +184,7 @@ vacuum(int options, List *relations, VacuumParams *params,
         *
         * ANALYZE (without VACUUM) can run either way.
         */
-       if (options & VACOPT_VACUUM)
+       if (params->options & VACOPT_VACUUM)
        {
                PreventInTransactionBlock(isTopLevel, stmttype);
                in_outer_xact = false;
@@ -206,8 +206,8 @@ vacuum(int options, List *relations, VacuumParams *params,
        /*
         * Sanity check DISABLE_PAGE_SKIPPING option.
         */
-       if ((options & VACOPT_FULL) != 0 &&
-               (options & VACOPT_DISABLE_PAGE_SKIPPING) != 0)
+       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")));
@@ -216,7 +216,7 @@ vacuum(int options, List *relations, VacuumParams *params,
         * Send info about dead objects to the statistics collector, unless we are
         * in autovacuum --- autovacuum.c does this for itself.
         */
-       if ((options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess())
+       if ((params->options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess())
                pgstat_vacuum_stat();
 
        /*
@@ -257,7 +257,7 @@ vacuum(int options, List *relations, VacuumParams *params,
                        List       *sublist;
                        MemoryContext old_context;
 
-                       sublist = expand_vacuum_rel(vrel, options);
+                       sublist = expand_vacuum_rel(vrel, params->options);
                        old_context = MemoryContextSwitchTo(vac_context);
                        newrels = list_concat(newrels, sublist);
                        MemoryContextSwitchTo(old_context);
@@ -265,7 +265,7 @@ vacuum(int options, List *relations, VacuumParams *params,
                relations = newrels;
        }
        else
-               relations = get_all_vacuum_rels(options);
+               relations = get_all_vacuum_rels(params->options);
 
        /*
         * Decide whether we need to start/commit our own transactions.
@@ -281,11 +281,11 @@ vacuum(int options, List *relations, VacuumParams *params,
         * transaction block, and also in an autovacuum worker, use own
         * transactions so we can release locks sooner.
         */
-       if (options & VACOPT_VACUUM)
+       if (params->options & VACOPT_VACUUM)
                use_own_xacts = true;
        else
        {
-               Assert(options & VACOPT_ANALYZE);
+               Assert(params->options & VACOPT_ANALYZE);
                if (IsAutoVacuumWorkerProcess())
                        use_own_xacts = true;
                else if (in_outer_xact)
@@ -335,13 +335,13 @@ vacuum(int options, List *relations, VacuumParams *params,
                {
                        VacuumRelation *vrel = lfirst_node(VacuumRelation, cur);
 
-                       if (options & VACOPT_VACUUM)
+                       if (params->options & VACOPT_VACUUM)
                        {
-                               if (!vacuum_rel(vrel->oid, vrel->relation, options, params))
+                               if (!vacuum_rel(vrel->oid, vrel->relation, params))
                                        continue;
                        }
 
-                       if (options & VACOPT_ANALYZE)
+                       if (params->options & VACOPT_ANALYZE)
                        {
                                /*
                                 * If using separate xacts, start one for analyze. Otherwise,
@@ -354,7 +354,7 @@ vacuum(int options, List *relations, VacuumParams *params,
                                        PushActiveSnapshot(GetTransactionSnapshot());
                                }
 
-                               analyze_rel(vrel->oid, vrel->relation, options, params,
+                               analyze_rel(vrel->oid, vrel->relation, params,
                                                        vrel->va_cols, in_outer_xact, vac_strategy);
 
                                if (use_own_xacts)
@@ -390,7 +390,7 @@ vacuum(int options, List *relations, VacuumParams *params,
                StartTransactionCommand();
        }
 
-       if ((options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess())
+       if ((params->options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess())
        {
                /*
                 * Update pg_database.datfrozenxid, and truncate pg_xact if possible.
@@ -490,14 +490,13 @@ vacuum_is_relation_owner(Oid relid, Form_pg_class reltuple, int options)
  * or locked, a log is emitted if possible.
  */
 Relation
-vacuum_open_relation(Oid relid, RangeVar *relation, VacuumParams *params,
-                                        int options, LOCKMODE lmode)
+vacuum_open_relation(Oid relid, RangeVar *relation, int options,
+                                        bool verbose, LOCKMODE lmode)
 {
        Relation        onerel;
        bool            rel_lock = true;
        int                     elevel;
 
-       Assert(params != NULL);
        Assert((options & (VACOPT_VACUUM | VACOPT_ANALYZE)) != 0);
 
        /*
@@ -538,13 +537,12 @@ vacuum_open_relation(Oid relid, RangeVar *relation, VacuumParams *params,
        /*
         * Determine the log level.
         *
-        * For autovacuum logs, we emit a LOG if log_autovacuum_min_duration is
-        * not disabled.  For manual VACUUM or ANALYZE, we emit a WARNING to match
-        * the log statements in the permission checks.
+        * 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 (!IsAutoVacuumWorkerProcess())
                elevel = WARNING;
-       else if (params->log_min_duration >= 0)
+       else if (verbose)
                elevel = LOG;
        else
                return NULL;
@@ -1521,7 +1519,7 @@ vac_truncate_clog(TransactionId frozenXID,
  *             At entry and exit, we are not inside a transaction.
  */
 static bool
-vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params)
+vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params)
 {
        LOCKMODE        lmode;
        Relation        onerel;
@@ -1542,7 +1540,7 @@ vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params)
         */
        PushActiveSnapshot(GetTransactionSnapshot());
 
-       if (!(options & VACOPT_FULL))
+       if (!(params->options & VACOPT_FULL))
        {
                /*
                 * In lazy vacuum, we can set the PROC_IN_VACUUM flag, which lets
@@ -1582,10 +1580,12 @@ vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params)
         * vacuum, but just ShareUpdateExclusiveLock for concurrent vacuum. Either
         * way, we can be sure that no other backend is vacuuming the same table.
         */
-       lmode = (options & VACOPT_FULL) ? AccessExclusiveLock : ShareUpdateExclusiveLock;
+       lmode = (params->options & VACOPT_FULL) ?
+               AccessExclusiveLock : ShareUpdateExclusiveLock;
 
        /* open the relation and get the appropriate lock on it */
-       onerel = vacuum_open_relation(relid, relation, params, options, lmode);
+       onerel = vacuum_open_relation(relid, relation, params->options,
+                                                                 params->log_min_duration >= 0, lmode);
 
        /* leave if relation could not be opened or locked */
        if (!onerel)
@@ -1605,7 +1605,7 @@ vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params)
         */
        if (!vacuum_is_relation_owner(RelationGetRelid(onerel),
                                                                  onerel->rd_rel,
-                                                                 options & VACOPT_VACUUM))
+                                                                 params->options & VACOPT_VACUUM))
        {
                relation_close(onerel, lmode);
                PopActiveSnapshot();
@@ -1677,7 +1677,7 @@ vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params)
         * 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 (!(options & VACOPT_SKIPTOAST) && !(options & VACOPT_FULL))
+       if (!(params->options & VACOPT_SKIPTOAST) && !(params->options & VACOPT_FULL))
                toast_relid = onerel->rd_rel->reltoastrelid;
        else
                toast_relid = InvalidOid;
@@ -1696,7 +1696,7 @@ vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params)
        /*
         * Do the actual work --- either FULL or "lazy" vacuum
         */
-       if (options & VACOPT_FULL)
+       if (params->options & VACOPT_FULL)
        {
                int                     cluster_options = 0;
 
@@ -1704,14 +1704,14 @@ vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params)
                relation_close(onerel, NoLock);
                onerel = NULL;
 
-               if ((options & VACOPT_VERBOSE) != 0)
+               if ((params->options & VACOPT_VERBOSE) != 0)
                        cluster_options |= CLUOPT_VERBOSE;
 
                /* VACUUM FULL is now a variant of CLUSTER; see cluster.c */
                cluster_rel(relid, InvalidOid, cluster_options);
        }
        else
-               heap_vacuum_rel(onerel, options, params, vac_strategy);
+               heap_vacuum_rel(onerel, params, vac_strategy);
 
        /* Roll back any GUC changes executed by index functions */
        AtEOXact_GUC(false, save_nestlevel);
@@ -1737,7 +1737,7 @@ vacuum_rel(Oid relid, RangeVar *relation, int options, VacuumParams *params)
         * totally unimportant for toast relations.
         */
        if (toast_relid != InvalidOid)
-               vacuum_rel(toast_relid, NULL, options, params);
+               vacuum_rel(toast_relid, NULL, params);
 
        /*
         * Now release the session-level lock on the master table.

diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index 3bfac919c43eeecea1dcf8433608891d5f106585..fa875db8160c440d5fbd7828c119e1136aa8dd0f 100644 (file)
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -188,7 +188,6 @@ typedef struct av_relation
 typedef struct autovac_table
 {
        Oid                     at_relid;
-       int                     at_vacoptions;  /* bitmask of VacuumOption */
        VacuumParams at_params;
        double          at_vacuum_cost_delay;
        int                     at_vacuum_cost_limit;
@@ -2482,7 +2481,7 @@ do_autovacuum(void)
                         * next table in our list.
                         */
                        HOLD_INTERRUPTS();
-                       if (tab->at_vacoptions & VACOPT_VACUUM)
+                       if (tab->at_params.options & VACOPT_VACUUM)
                                errcontext("automatic vacuum of table \"%s.%s.%s\"",
                                                   tab->at_datname, tab->at_nspname, tab->at_relname);
                        else
@@ -2883,7 +2882,7 @@ table_recheck_autovac(Oid relid, HTAB *table_toast_map,
                tab = palloc(sizeof(autovac_table));
                tab->at_relid = relid;
                tab->at_sharedrel = classForm->relisshared;
-               tab->at_vacoptions = VACOPT_SKIPTOAST |
+               tab->at_params.options = VACOPT_SKIPTOAST |
                        (dovacuum ? VACOPT_VACUUM : 0) |
                        (doanalyze ? VACOPT_ANALYZE : 0) |
                        (!wraparound ? VACOPT_SKIP_LOCKED : 0);
@@ -3110,7 +3109,7 @@ autovacuum_do_vac_analyze(autovac_table *tab, BufferAccessStrategy bstrategy)
        rel = makeVacuumRelation(rangevar, tab->at_relid, NIL);
        rel_list = list_make1(rel);
 
-       vacuum(tab->at_vacoptions, rel_list, &tab->at_params, bstrategy, true);
+       vacuum(rel_list, &tab->at_params, bstrategy, true);
 }
 
 /*
@@ -3132,10 +3131,10 @@ autovac_report_activity(autovac_table *tab)
        int                     len;
 
        /* Report the command and possible options */
-       if (tab->at_vacoptions & VACOPT_VACUUM)
+       if (tab->at_params.options & VACOPT_VACUUM)
                snprintf(activity, MAX_AUTOVAC_ACTIV_LEN,
                                 "autovacuum: VACUUM%s",
-                                tab->at_vacoptions & VACOPT_ANALYZE ? " ANALYZE" : "");
+                                tab->at_params.options & VACOPT_ANALYZE ? " ANALYZE" : "");
        else
                snprintf(activity, MAX_AUTOVAC_ACTIV_LEN,
                                 "autovacuum: ANALYZE");

diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index 1b6607fe902bae5608c755c35ff6902ce0f444fd..eb9e160bfd94657566e8f1e21ed00c396c5680ff 100644 (file)
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -217,7 +217,7 @@ extern Size SyncScanShmemSize(void);
 
 /* in heap/vacuumlazy.c */
 struct VacuumParams;
-extern void heap_vacuum_rel(Relation onerel, int options,
+extern void heap_vacuum_rel(Relation onerel,
                                struct VacuumParams *params, BufferAccessStrategy bstrategy);
 
 /* in heap/heapam_visibility.c */

diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h
index 0a051ec06e2badcc157663da7564c96a4b848af2..c0df9c9054b08bc472ad9f0b4b5f7633702f937d 100644 (file)
--- a/src/include/commands/vacuum.h
+++ b/src/include/commands/vacuum.h
@@ -141,6 +141,7 @@ typedef struct VacAttrStats
  */
 typedef struct VacuumParams
 {
+       int                     options;                /* bitmask of VacuumOption */
        int                     freeze_min_age; /* min freeze age, -1 to use default */
        int                     freeze_table_age;       /* age at which to scan whole table */
        int                     multixact_freeze_min_age;       /* min multixact freeze age, -1 to
@@ -163,7 +164,7 @@ extern int  vacuum_multixact_freeze_table_age;
 
 /* in commands/vacuum.c */
 extern void ExecVacuum(VacuumStmt *vacstmt, bool isTopLevel);
-extern void vacuum(int options, List *relations, VacuumParams *params,
+extern void vacuum(List *relations, VacuumParams *params,
           BufferAccessStrategy bstrategy, bool isTopLevel);
 extern void vac_open_indexes(Relation relation, LOCKMODE lockmode,
                                 int *nindexes, Relation **Irel);
@@ -194,10 +195,10 @@ extern void vacuum_delay_point(void);
 extern bool vacuum_is_relation_owner(Oid relid, Form_pg_class reltuple,
                                                 int options);
 extern Relation vacuum_open_relation(Oid relid, RangeVar *relation,
-                                        VacuumParams *params, int options, LOCKMODE lmode);
+                                        int options, bool verbose, LOCKMODE lmode);
 
 /* in commands/analyze.c */
-extern void analyze_rel(Oid relid, RangeVar *relation, int options,
+extern void analyze_rel(Oid relid, RangeVar *relation,
                        VacuumParams *params, List *va_cols, bool in_outer_xact,
                        BufferAccessStrategy bstrategy);
 extern bool std_typanalyze(VacAttrStats *stats);