Revise pgstat's tracking of tuple changes to improve the reliability of

[postgresql] / src / backend / commands / vacuum.c

/*-------------------------------------------------------------------------
 *
 * vacuum.c
 *        The postgres vacuum cleaner.
 *
 * This file includes the "full" version of VACUUM, as well as control code
 * used by all three of full VACUUM, lazy VACUUM, and ANALYZE.  See
 * vacuumlazy.c and analyze.c for the rest of the code for the latter two.
 *
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *        $PostgreSQL: pgsql/src/backend/commands/vacuum.c,v 1.401 2009/12/30 20:32:14 tgl Exp $
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include <sys/time.h>
#include <unistd.h>

#include "access/clog.h"
#include "access/genam.h"
#include "access/heapam.h"
#include "access/transam.h"
#include "access/visibilitymap.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/namespace.h"
#include "catalog/pg_database.h"
#include "catalog/pg_namespace.h"
#include "catalog/storage.h"
#include "commands/dbcommands.h"
#include "commands/vacuum.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
#include "storage/lmgr.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/guc.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/pg_rusage.h"
#include "utils/relcache.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/tqual.h"


/*
 * GUC parameters
 */
int                     vacuum_freeze_min_age;
int                     vacuum_freeze_table_age;

/*
 * VacPage structures keep track of each page on which we find useful
 * amounts of free space.
 */
typedef struct VacPageData
{
        BlockNumber blkno;                      /* BlockNumber of this Page */
        Size            free;                   /* FreeSpace on this Page */
        uint16          offsets_used;   /* Number of OffNums used by vacuum */
        uint16          offsets_free;   /* Number of OffNums free or to be free */
        OffsetNumber offsets[1];        /* Array of free OffNums */
} VacPageData;

typedef VacPageData *VacPage;

typedef struct VacPageListData
{
        BlockNumber empty_end_pages;    /* Number of "empty" end-pages */
        int                     num_pages;              /* Number of pages in pagedesc */
        int                     num_allocated_pages;    /* Number of allocated pages in
                                                                                 * pagedesc */
        VacPage    *pagedesc;           /* Descriptions of pages */
} VacPageListData;

typedef VacPageListData *VacPageList;

/*
 * The "vtlinks" array keeps information about each recently-updated tuple
 * ("recent" meaning its XMAX is too new to let us recycle the tuple).
 * We store the tuple's own TID as well as its t_ctid (its link to the next
 * newer tuple version).  Searching in this array allows us to follow update
 * chains backwards from newer to older tuples.  When we move a member of an
 * update chain, we must move *all* the live members of the chain, so that we
 * can maintain their t_ctid link relationships (we must not just overwrite
 * t_ctid in an existing tuple).
 *
 * Note: because t_ctid links can be stale (this would only occur if a prior
 * VACUUM crashed partway through), it is possible that new_tid points to an
 * empty slot or unrelated tuple.  We have to check the linkage as we follow
 * it, just as is done in EvalPlanQualFetch.
 */
typedef struct VTupleLinkData
{
        ItemPointerData new_tid;        /* t_ctid of an updated tuple */
        ItemPointerData this_tid;       /* t_self of the tuple */
} VTupleLinkData;

typedef VTupleLinkData *VTupleLink;

/*
 * We use an array of VTupleMoveData to plan a chain tuple move fully
 * before we do it.
 */
typedef struct VTupleMoveData
{
        ItemPointerData tid;            /* tuple ID */
        VacPage         vacpage;                /* where to move it to */
        bool            cleanVpd;               /* clean vacpage before using? */
} VTupleMoveData;

typedef VTupleMoveData *VTupleMove;

/*
 * VRelStats contains the data acquired by scan_heap for use later
 */
typedef struct VRelStats
{
        /* miscellaneous statistics */
        BlockNumber rel_pages;          /* pages in relation */
        double          rel_tuples;             /* tuples that remain after vacuuming */
        double          rel_indexed_tuples;             /* indexed tuples that remain */
        Size            min_tlen;               /* min surviving tuple size */
        Size            max_tlen;               /* max surviving tuple size */
        bool            hasindex;
        /* vtlinks array for tuple chain following - sorted by new_tid */
        int                     num_vtlinks;
        VTupleLink      vtlinks;
        TransactionId   latestRemovedXid;
} VRelStats;

/*----------------------------------------------------------------------
 * ExecContext:
 *
 * As these variables always appear together, we put them into one struct
 * and pull initialization and cleanup into separate routines.
 * ExecContext is used by repair_frag() and move_xxx_tuple().  More
 * accurately:  It is *used* only in move_xxx_tuple(), but because this
 * routine is called many times, we initialize the struct just once in
 * repair_frag() and pass it on to move_xxx_tuple().
 */
typedef struct ExecContextData
{
        ResultRelInfo *resultRelInfo;
        EState     *estate;
        TupleTableSlot *slot;
} ExecContextData;

typedef ExecContextData *ExecContext;

static void
ExecContext_Init(ExecContext ec, Relation rel)
{
        TupleDesc       tupdesc = RelationGetDescr(rel);

        /*
         * We need a ResultRelInfo and an EState so we can use the regular
         * executor's index-entry-making machinery.
         */
        ec->estate = CreateExecutorState();

        ec->resultRelInfo = makeNode(ResultRelInfo);
        ec->resultRelInfo->ri_RangeTableIndex = 1;      /* dummy */
        ec->resultRelInfo->ri_RelationDesc = rel;
        ec->resultRelInfo->ri_TrigDesc = NULL;          /* we don't fire triggers */

        ExecOpenIndices(ec->resultRelInfo);

        ec->estate->es_result_relations = ec->resultRelInfo;
        ec->estate->es_num_result_relations = 1;
        ec->estate->es_result_relation_info = ec->resultRelInfo;

        /* Set up a tuple slot too */
        ec->slot = MakeSingleTupleTableSlot(tupdesc);
}

static void
ExecContext_Finish(ExecContext ec)
{
        ExecDropSingleTupleTableSlot(ec->slot);
        ExecCloseIndices(ec->resultRelInfo);
        FreeExecutorState(ec->estate);
}

/*
 * End of ExecContext Implementation
 *----------------------------------------------------------------------
 */

/* A few variables that don't seem worth passing around as parameters */
static MemoryContext vac_context = NULL;

static int      elevel = -1;

static TransactionId OldestXmin;
static TransactionId FreezeLimit;

static BufferAccessStrategy vac_strategy;


/* non-export function prototypes */
static List *get_rel_oids(Oid relid, const RangeVar *vacrel,
                         const char *stmttype);
static void vac_truncate_clog(TransactionId frozenXID);
static void vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast,
                   bool for_wraparound, bool *scanned_all);
static bool full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
static void scan_heap(VRelStats *vacrelstats, Relation onerel,
                  VacPageList vacuum_pages, VacPageList fraged_pages);
static bool repair_frag(VRelStats *vacrelstats, Relation onerel,
                        VacPageList vacuum_pages, VacPageList fraged_pages,
                        int nindexes, Relation *Irel);
static void move_chain_tuple(VRelStats *vacrelstats, Relation rel,
                                 Buffer old_buf, Page old_page, HeapTuple old_tup,
                                 Buffer dst_buf, Page dst_page, VacPage dst_vacpage,
                                 ExecContext ec, ItemPointer ctid, bool cleanVpd);
static void move_plain_tuple(Relation rel,
                                 Buffer old_buf, Page old_page, HeapTuple old_tup,
                                 Buffer dst_buf, Page dst_page, VacPage dst_vacpage,
                                 ExecContext ec);
static void update_hint_bits(Relation rel, VacPageList fraged_pages,
                                 int num_fraged_pages, BlockNumber last_move_dest_block,
                                 int num_moved);
static void vacuum_heap(VRelStats *vacrelstats, Relation onerel,
                        VacPageList vacpagelist);
static void vacuum_page(VRelStats *vacrelstats, Relation onerel, Buffer buffer, VacPage vacpage);
static void vacuum_index(VacPageList vacpagelist, Relation indrel,
                         double num_tuples, int keep_tuples);
static void scan_index(Relation indrel, double num_tuples);
static bool tid_reaped(ItemPointer itemptr, void *state);
static void vac_update_fsm(Relation onerel, VacPageList fraged_pages,
                           BlockNumber rel_pages);
static VacPage copy_vac_page(VacPage vacpage);
static void vpage_insert(VacPageList vacpagelist, VacPage vpnew);
static void *vac_bsearch(const void *key, const void *base,
                        size_t nelem, size_t size,
                        int (*compar) (const void *, const void *));
static int      vac_cmp_blk(const void *left, const void *right);
static int      vac_cmp_offno(const void *left, const void *right);
static int      vac_cmp_vtlinks(const void *left, const void *right);
static bool enough_space(VacPage vacpage, Size len);
static Size PageGetFreeSpaceWithFillFactor(Relation relation, Page page);


/****************************************************************************
 *                                                                                                                                                      *
 *                      Code common to all flavors of VACUUM and ANALYZE                                *
 *                                                                                                                                                      *
 ****************************************************************************
 */


/*
 * Primary entry point for VACUUM and ANALYZE commands.
 *
 * 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.)
 *
 * 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-cancelled.
 *
 * 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.
 */
void
vacuum(VacuumStmt *vacstmt, Oid relid, bool do_toast,
           BufferAccessStrategy bstrategy, bool for_wraparound, bool isTopLevel)
{
        const char *stmttype;
        volatile bool all_rels,
                                in_outer_xact,
                                use_own_xacts;
        List       *relations;

        /* 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);

        stmttype = (vacstmt->options & VACOPT_VACUUM) ? "VACUUM" : "ANALYZE";

        if (vacstmt->options & VACOPT_VERBOSE)
                elevel = INFO;
        else
                elevel = DEBUG2;

        /*
         * 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! Furthermore, the forced commit that
         * occurs before truncating the relation's file would have the effect of
         * committing the rest of the user's transaction too, which would
         * certainly not be the desired behavior.  (This only applies to VACUUM
         * FULL, though.  We could in theory run lazy VACUUM inside a transaction
         * block, but we choose to disallow that case because we'd rather commit
         * as soon as possible after finishing the vacuum.      This is mainly so that
         * we can let go the AccessExclusiveLock that we may be holding.)
         *
         * ANALYZE (without VACUUM) can run either way.
         */
        if (vacstmt->options & VACOPT_VACUUM)
        {
                PreventTransactionChain(isTopLevel, stmttype);
                in_outer_xact = false;
        }
        else
                in_outer_xact = IsInTransactionChain(isTopLevel);

        /*
         * 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())
                pgstat_vacuum_stat();

        /*
         * 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_MINSIZE,
                                                                                ALLOCSET_DEFAULT_INITSIZE,
                                                                                ALLOCSET_DEFAULT_MAXSIZE);

        /*
         * If caller didn't give us a buffer strategy object, make one in the
         * cross-transaction memory context.
         */
        if (bstrategy == NULL)
        {
                MemoryContext old_context = MemoryContextSwitchTo(vac_context);

                bstrategy = GetAccessStrategy(BAS_VACUUM);
                MemoryContextSwitchTo(old_context);
        }
        vac_strategy = bstrategy;

        /* Remember whether we are processing everything in the DB */
        all_rels = (!OidIsValid(relid) && vacstmt->relation == NULL);

        /*
         * 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, stmttype);

        /*
         * 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 (vacstmt->options & VACOPT_VACUUM)
                use_own_xacts = true;
        else
        {
                Assert(vacstmt->options & VACOPT_ANALYZE);
                if (IsAutoVacuumWorkerProcess())
                        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)
        {
                /* ActiveSnapshot is not set by autovacuum */
                if (ActiveSnapshotSet())
                        PopActiveSnapshot();

                /* matches the StartTransaction in PostgresMain() */
                CommitTransactionCommand();
        }

        /* Turn vacuum cost accounting on or off */
        PG_TRY();
        {
                ListCell   *cur;

                VacuumCostActive = (VacuumCostDelay > 0);
                VacuumCostBalance = 0;

                /*
                 * Loop to process each selected relation.
                 */
                foreach(cur, relations)
                {
                        Oid                     relid = lfirst_oid(cur);
                        bool            scanned_all = false;

                        if (vacstmt->options & VACOPT_VACUUM)
                                vacuum_rel(relid, vacstmt, do_toast, for_wraparound,
                                                   &scanned_all);

                        if (vacstmt->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(relid, vacstmt, vac_strategy, !scanned_all);

                                if (use_own_xacts)
                                {
                                        PopActiveSnapshot();
                                        CommitTransactionCommand();
                                }
                        }
                }
        }
        PG_CATCH();
        {
                /* Make sure cost accounting is turned off after error */
                VacuumCostActive = false;
                PG_RE_THROW();
        }
        PG_END_TRY();

        /* Turn off vacuum cost accounting */
        VacuumCostActive = false;

        /*
         * 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 ((vacstmt->options & VACOPT_VACUUM) && !IsAutoVacuumWorkerProcess())
        {
                /*
                 * Update pg_database.datfrozenxid, and truncate pg_clog if possible.
                 * (autovacuum.c does this for itself.)
                 */
                vac_update_datfrozenxid();
        }

        /*
         * Clean up working storage --- note we must do this after
         * StartTransactionCommand, else we might be trying to delete the active
         * context!
         */
        MemoryContextDelete(vac_context);
        vac_context = NULL;
}

/*
 * Build a list of Oids for each relation to be processed
 *
 * The list is built in vac_context so that it will survive across our
 * per-relation transactions.
 */
static List *
get_rel_oids(Oid relid, const RangeVar *vacrel, const char *stmttype)
{
        List       *oid_list = NIL;
        MemoryContext oldcontext;

        /* OID supplied by VACUUM's caller? */
        if (OidIsValid(relid))
        {
                oldcontext = MemoryContextSwitchTo(vac_context);
                oid_list = lappend_oid(oid_list, relid);
                MemoryContextSwitchTo(oldcontext);
        }
        else if (vacrel)
        {
                /* Process a specific relation */
                Oid                     relid;

                relid = RangeVarGetRelid(vacrel, false);

                /* Make a relation list entry for this guy */
                oldcontext = MemoryContextSwitchTo(vac_context);
                oid_list = lappend_oid(oid_list, relid);
                MemoryContextSwitchTo(oldcontext);
        }
        else
        {
                /* Process all plain relations listed in pg_class */
                Relation        pgclass;
                HeapScanDesc scan;
                HeapTuple       tuple;
                ScanKeyData key;

                ScanKeyInit(&key,
                                        Anum_pg_class_relkind,
                                        BTEqualStrategyNumber, F_CHAREQ,
                                        CharGetDatum(RELKIND_RELATION));

                pgclass = heap_open(RelationRelationId, AccessShareLock);

                scan = heap_beginscan(pgclass, SnapshotNow, 1, &key);

                while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
                {
                        /* Make a relation list entry for this guy */
                        oldcontext = MemoryContextSwitchTo(vac_context);
                        oid_list = lappend_oid(oid_list, HeapTupleGetOid(tuple));
                        MemoryContextSwitchTo(oldcontext);
                }

                heap_endscan(scan);
                heap_close(pgclass, AccessShareLock);
        }

        return oid_list;
}

/*
 * vacuum_set_xid_limits() -- compute oldest-Xmin and freeze cutoff points
 */
void
vacuum_set_xid_limits(int freeze_min_age,
                                          int freeze_table_age,
                                          bool sharedRel,
                                          TransactionId *oldestXmin,
                                          TransactionId *freezeLimit,
                                          TransactionId *freezeTableLimit)
{
        int                     freezemin;
        TransactionId limit;
        TransactionId safeLimit;

        /*
         * 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, it's safe to
         * ignore it.  In theory it could be problematic to ignore lazy vacuums on
         * 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.
         */
        *oldestXmin = GetOldestXmin(sharedRel, true);

        Assert(TransactionIdIsNormal(*oldestXmin));

        /*
         * 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.
         */
        freezemin = freeze_min_age;
        if (freezemin < 0)
                freezemin = vacuum_freeze_min_age;
        freezemin = Min(freezemin, autovacuum_freeze_max_age / 2);
        Assert(freezemin >= 0);

        /*
         * Compute the cutoff XID, being careful not to generate a "permanent" XID
         */
        limit = *oldestXmin - freezemin;
        if (!TransactionIdIsNormal(limit))
                limit = FirstNormalTransactionId;

        /*
         * If oldestXmin is very far back (in practice, more than
         * autovacuum_freeze_max_age / 2 XIDs old), complain and force a minimum
         * freeze age of zero.
         */
        safeLimit = ReadNewTransactionId() - autovacuum_freeze_max_age;
        if (!TransactionIdIsNormal(safeLimit))
                safeLimit = FirstNormalTransactionId;

        if (TransactionIdPrecedes(limit, safeLimit))
        {
                ereport(WARNING,
                                (errmsg("oldest xmin is far in the past"),
                                 errhint("Close open transactions soon to avoid wraparound problems.")));
                limit = *oldestXmin;
        }

        *freezeLimit = limit;

        if (freezeTableLimit != NULL)
        {
                int                     freezetable;

                /*
                 * Determine the table freeze age to use: as specified by the caller,
                 * or vacuum_freeze_table_age, 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 tuples
                 * before anti-wraparound autovacuum is launched.
                 */
                freezetable = freeze_min_age;
                if (freezetable < 0)
                        freezetable = vacuum_freeze_table_age;
                freezetable = Min(freezetable, autovacuum_freeze_max_age * 0.95);
                Assert(freezetable >= 0);

                /*
                 * Compute the cutoff XID, being careful not to generate a "permanent"
                 * XID.
                 */
                limit = ReadNewTransactionId() - freezetable;
                if (!TransactionIdIsNormal(limit))
                        limit = FirstNormalTransactionId;

                *freezeTableLimit = limit;
        }
}


/*
 *      vac_update_relstats() -- update statistics for one relation
 *
 *              Update the whole-relation statistics that are kept in its pg_class
 *              row.  There are additional stats that will be updated if we are
 *              doing ANALYZE, but we always update these stats.  This routine works
 *              for both index and heap relation entries in pg_class.
 *
 *              We violate transaction semantics here by overwriting the rel's
 *              existing pg_class tuple with the new values.  This is reasonably
 *              safe since the new values are correct whether or not this transaction
 *              commits.  The reason for this is that if we updated these tuples in
 *              the usual way, vacuuming pg_class itself wouldn't work very well ---
 *              by the time we got done with a vacuum cycle, most of the tuples in
 *              pg_class would've been obsoleted.  Of course, this only works for
 *              fixed-size never-null columns, but these are.
 *
 *              Note another assumption: that two VACUUMs/ANALYZEs on a table can't
 *              run in parallel, nor can VACUUM/ANALYZE run in parallel with a
 *              schema alteration such as adding an index, rule, or trigger.  Otherwise
 *              our updates of relhasindex etc might overwrite uncommitted updates.
 *
 *              Another reason for doing it this way is that when we are in a lazy
 *              VACUUM and have PROC_IN_VACUUM set, we mustn't do any updates ---
 *              somebody vacuuming pg_class might think they could delete a tuple
 *              marked with xmin = our xid.
 *
 *              This routine is shared by full VACUUM, lazy VACUUM, and stand-alone
 *              ANALYZE.
 */
void
vac_update_relstats(Relation relation,
                                        BlockNumber num_pages, double num_tuples,
                                        bool hasindex, TransactionId frozenxid)
{
        Oid                     relid = RelationGetRelid(relation);
        Relation        rd;
        HeapTuple       ctup;
        Form_pg_class pgcform;
        bool            dirty;

        rd = heap_open(RelationRelationId, RowExclusiveLock);

        /* Fetch a copy of the tuple to scribble on */
        ctup = SearchSysCacheCopy(RELOID,
                                                          ObjectIdGetDatum(relid),
                                                          0, 0, 0);
        if (!HeapTupleIsValid(ctup))
                elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
                         relid);
        pgcform = (Form_pg_class) GETSTRUCT(ctup);

        /* Apply required 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->relhasindex != hasindex)
        {
                pgcform->relhasindex = hasindex;
                dirty = true;
        }

        /*
         * If we have discovered that there are no indexes, then there's no
         * primary key either, nor any exclusion constraints.  This could be done
         * more thoroughly...
         */
        if (!hasindex)
        {
                if (pgcform->relhaspkey)
                {
                        pgcform->relhaspkey = false;
                        dirty = true;
                }
                if (pgcform->relhasexclusion && pgcform->relkind != RELKIND_INDEX)
                {
                        pgcform->relhasexclusion = 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;
        }

        /*
         * relfrozenxid should never go backward.  Caller can pass
         * InvalidTransactionId if it has no new data.
         */
        if (TransactionIdIsNormal(frozenxid) &&
                TransactionIdPrecedes(pgcform->relfrozenxid, frozenxid))
        {
                pgcform->relfrozenxid = frozenxid;
                dirty = true;
        }

        /* If anything changed, write out the tuple. */
        if (dirty)
                heap_inplace_update(rd, ctup);

        heap_close(rd, RowExclusiveLock);
}


/*
 *      vac_update_datfrozenxid() -- update pg_database.datfrozenxid for our DB
 *
 *              Update pg_database's datfrozenxid entry for our database to be the
 *              minimum of the pg_class.relfrozenxid values.  If we are able to
 *              advance pg_database.datfrozenxid, also try to truncate pg_clog.
 *
 *              We violate transaction semantics here by overwriting the database's
 *              existing pg_database tuple with the new value.  This is reasonably
 *              safe since the new value is correct whether or not this transaction
 *              commits.  As with vac_update_relstats, this avoids leaving dead tuples
 *              behind after a VACUUM.
 *
 *              This routine is shared by full and lazy VACUUM.
 */
void
vac_update_datfrozenxid(void)
{
        HeapTuple       tuple;
        Form_pg_database dbform;
        Relation        relation;
        SysScanDesc scan;
        HeapTuple       classTup;
        TransactionId newFrozenXid;
        bool            dirty = false;

        /*
         * Initialize the "min" calculation with GetOldestXmin, which is a
         * reasonable approximation to the minimum relfrozenxid for not-yet-
         * committed pg_class entries for new tables; see AddNewRelationTuple().
         * Se we cannot produce a wrong minimum by starting with this.
         */
        newFrozenXid = GetOldestXmin(true, true);

        /*
         * We must seqscan pg_class to find the minimum Xid, because there is no
         * index that can help us here.
         */
        relation = heap_open(RelationRelationId, AccessShareLock);

        scan = systable_beginscan(relation, InvalidOid, false,
                                                          SnapshotNow, 0, NULL);

        while ((classTup = systable_getnext(scan)) != NULL)
        {
                Form_pg_class classForm = (Form_pg_class) GETSTRUCT(classTup);

                /*
                 * Only consider heap and TOAST tables (anything else should have
                 * InvalidTransactionId in relfrozenxid anyway.)
                 */
                if (classForm->relkind != RELKIND_RELATION &&
                        classForm->relkind != RELKIND_TOASTVALUE)
                        continue;

                Assert(TransactionIdIsNormal(classForm->relfrozenxid));

                if (TransactionIdPrecedes(classForm->relfrozenxid, newFrozenXid))
                        newFrozenXid = classForm->relfrozenxid;
        }

        /* we're done with pg_class */
        systable_endscan(scan);
        heap_close(relation, AccessShareLock);

        Assert(TransactionIdIsNormal(newFrozenXid));

        /* Now fetch the pg_database tuple we need to update. */
        relation = heap_open(DatabaseRelationId, RowExclusiveLock);

        /* Fetch a copy of the tuple to scribble on */
        tuple = SearchSysCacheCopy(DATABASEOID,
                                                           ObjectIdGetDatum(MyDatabaseId),
                                                           0, 0, 0);
        if (!HeapTupleIsValid(tuple))
                elog(ERROR, "could not find tuple for database %u", MyDatabaseId);
        dbform = (Form_pg_database) GETSTRUCT(tuple);

        /*
         * Don't allow datfrozenxid to go backward (probably can't happen anyway);
         * and detect the common case where it doesn't go forward either.
         */
        if (TransactionIdPrecedes(dbform->datfrozenxid, newFrozenXid))
        {
                dbform->datfrozenxid = newFrozenXid;
                dirty = true;
        }

        if (dirty)
                heap_inplace_update(relation, tuple);

        heap_freetuple(tuple);
        heap_close(relation, RowExclusiveLock);

        /*
         * If we were able to advance datfrozenxid, see if we can truncate pg_clog.
         * 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);
}


/*
 *      vac_truncate_clog() -- attempt to truncate the commit log
 *
 *              Scan pg_database to determine the system-wide oldest datfrozenxid,
 *              and use it to truncate the transaction commit log (pg_clog).
 *              Also update the XID wrap limit info maintained by varsup.c.
 *
 *              The passed XID is simply the one I just wrote into my pg_database
 *              entry.  It's used to initialize the "min" calculation.
 *
 *              This routine is shared by full and lazy VACUUM.  Note that it's
 *              only invoked when we've managed to change our DB's datfrozenxid
 *              entry, or we found that the shared XID-wrap-limit info is stale.
 */
static void
vac_truncate_clog(TransactionId frozenXID)
{
        TransactionId myXID = GetCurrentTransactionId();
        Relation        relation;
        HeapScanDesc scan;
        HeapTuple       tuple;
        Oid                     oldest_datoid;
        bool            frozenAlreadyWrapped = false;

        /* init oldest_datoid to sync with my frozenXID */
        oldest_datoid = MyDatabaseId;

        /*
         * Scan pg_database to compute the minimum datfrozenxid
         *
         * Note: we need not worry about a race condition with new entries being
         * inserted by CREATE DATABASE.  Any such entry will have a copy of some
         * existing DB's datfrozenxid, and that source DB cannot be ours because
         * of the interlock against copying a DB containing an active backend.
         * Hence the new entry will not reduce the minimum.  Also, if two VACUUMs
         * concurrently modify the datfrozenxid's of different databases, the
         * worst possible outcome is that pg_clog is not truncated as aggressively
         * as it could be.
         */
        relation = heap_open(DatabaseRelationId, AccessShareLock);

        scan = heap_beginscan(relation, SnapshotNow, 0, NULL);

        while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
        {
                Form_pg_database dbform = (Form_pg_database) GETSTRUCT(tuple);

                Assert(TransactionIdIsNormal(dbform->datfrozenxid));

                if (TransactionIdPrecedes(myXID, dbform->datfrozenxid))
                        frozenAlreadyWrapped = true;
                else if (TransactionIdPrecedes(dbform->datfrozenxid, frozenXID))
                {
                        frozenXID = dbform->datfrozenxid;
                        oldest_datoid = HeapTupleGetOid(tuple);
                }
        }

        heap_endscan(scan);

        heap_close(relation, AccessShareLock);

        /*
         * Do not truncate CLOG if we seem to have suffered wraparound already;
         * the computed minimum XID might be bogus.  This case should now be
         * impossible due to the defenses in GetNewTransactionId, but we keep the
         * test anyway.
         */
        if (frozenAlreadyWrapped)
        {
                ereport(WARNING,
                                (errmsg("some databases have not been vacuumed in over 2 billion transactions"),
                                 errdetail("You might have already suffered transaction-wraparound data loss.")));
                return;
        }

        /* Truncate CLOG to the oldest frozenxid */
        TruncateCLOG(frozenXID);

        /*
         * Update the wrap limit for GetNewTransactionId.  Note: this function
         * will also signal the postmaster for an(other) autovac cycle if needed.
         */
        SetTransactionIdLimit(frozenXID, oldest_datoid);
}


/****************************************************************************
 *                                                                                                                                                      *
 *                      Code common to both flavors of VACUUM                                                   *
 *                                                                                                                                                      *
 ****************************************************************************
 */


/*
 *      vacuum_rel() -- vacuum one heap relation
 *
 *              Doing one heap at a time incurs extra overhead, since we need to
 *              check that the heap exists again just before we vacuum it.      The
 *              reason that we do this is so that vacuuming can be spread across
 *              many small transactions.  Otherwise, two-phase locking would require
 *              us to lock the entire database during one pass of the vacuum cleaner.
 *
 *              We'll return true in *scanned_all if the vacuum scanned all heap
 *              pages, and updated pg_class.
 *
 *              At entry and exit, we are not inside a transaction.
 */
static void
vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast, bool for_wraparound,
                   bool *scanned_all)
{
        LOCKMODE        lmode;
        Relation        onerel;
        LockRelId       onerelid;
        Oid                     toast_relid;
        Oid                     save_userid;
        int                     save_sec_context;
        int                     save_nestlevel;
        bool            heldoff;

        if (scanned_all)
                *scanned_all = false;

        /* Begin a transaction for vacuuming this relation */
        StartTransactionCommand();

        /*
         * Functions in indexes may want a snapshot set.  Also, setting a snapshot
         * ensures that RecentGlobalXmin is kept truly recent.
         */
        PushActiveSnapshot(GetTransactionSnapshot());

        if (!(vacstmt->options & VACOPT_FULL))
        {
                /*
                 * In lazy vacuum, we can set the PROC_IN_VACUUM flag, which lets
                 * other concurrent VACUUMs know that they can ignore this one while
                 * determining their OldestXmin.  (The reason we don't set it during a
                 * full VACUUM is exactly that we may have to run user- defined
                 * functions for functional indexes, and we want to make sure that if
                 * they use the snapshot set above, any tuples it requires can't get
                 * removed from other tables.  An index function that depends on the
                 * contents of other tables is arguably broken, but we won't break it
                 * here by violating transaction semantics.)
                 *
                 * We also set the VACUUM_FOR_WRAPAROUND flag, which is passed down by
                 * autovacuum; it's used to avoid cancelling a vacuum that was invoked
                 * in an emergency.
                 *
                 * Note: these flags remain set until CommitTransaction or
                 * AbortTransaction.  We don't want to clear them until we reset
                 * MyProc->xid/xmin, else OldestXmin might appear to go backwards,
                 * which is probably Not Good.
                 */
                LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
                MyProc->vacuumFlags |= PROC_IN_VACUUM;
                if (for_wraparound)
                        MyProc->vacuumFlags |= PROC_VACUUM_FOR_WRAPAROUND;
                LWLockRelease(ProcArrayLock);
        }

        /*
         * Check for user-requested abort.      Note we want this to be inside a
         * transaction, so xact.c doesn't issue useless WARNING.
         */
        CHECK_FOR_INTERRUPTS();

        /*
         * Determine the type of lock we want --- hard exclusive lock for a FULL
         * 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;

        /*
         * Open the relation and get the appropriate lock on it.
         *
         * There's a race condition here: the rel may have gone away since the
         * last time we saw it.  If so, we don't need to vacuum it.
         */
        onerel = try_relation_open(relid, lmode);

        if (!onerel)
        {
                PopActiveSnapshot();
                CommitTransactionCommand();
                return;
        }

        /*
         * Check permissions.
         *
         * We allow the user to vacuum a table if he is superuser, the table
         * owner, or the database owner (but in the latter case, only if it's not
         * a shared relation).  pg_class_ownercheck includes the superuser case.
         *
         * Note we choose to treat permissions failure as a WARNING and keep
         * trying to vacuum the rest of the DB --- is this appropriate?
         */
        if (!(pg_class_ownercheck(RelationGetRelid(onerel), GetUserId()) ||
                  (pg_database_ownercheck(MyDatabaseId, GetUserId()) && !onerel->rd_rel->relisshared)))
        {
                if (onerel->rd_rel->relisshared)
                        ereport(WARNING,
                                  (errmsg("skipping \"%s\" --- only superuser can vacuum it",
                                                  RelationGetRelationName(onerel))));
                else if (onerel->rd_rel->relnamespace == PG_CATALOG_NAMESPACE)
                        ereport(WARNING,
                                        (errmsg("skipping \"%s\" --- only superuser or database owner can vacuum it",
                                                        RelationGetRelationName(onerel))));
                else
                        ereport(WARNING,
                                        (errmsg("skipping \"%s\" --- only table or database owner can vacuum it",
                                                        RelationGetRelationName(onerel))));
                relation_close(onerel, lmode);
                PopActiveSnapshot();
                CommitTransactionCommand();
                return;
        }

        /*
         * Check that it's a vacuumable table; we used to do this in
         * get_rel_oids() but seems safer to check after we've locked the
         * relation.
         */
        if (onerel->rd_rel->relkind != RELKIND_RELATION &&
                onerel->rd_rel->relkind != RELKIND_TOASTVALUE)
        {
                ereport(WARNING,
                                (errmsg("skipping \"%s\" --- cannot vacuum indexes, views, or special system tables",
                                                RelationGetRelationName(onerel))));
                relation_close(onerel, lmode);
                PopActiveSnapshot();
                CommitTransactionCommand();
                return;
        }

        /*
         * Silently ignore tables that are temp tables of other backends ---
         * trying to vacuum these will lead to great unhappiness, 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
         * VACUUM.)
         */
        if (RELATION_IS_OTHER_TEMP(onerel))
        {
                relation_close(onerel, lmode);
                PopActiveSnapshot();
                CommitTransactionCommand();
                return;
        }

        /*
         * Get a session-level lock too. This will protect our access to the
         * relation across multiple transactions, so that we can vacuum the
         * relation's TOAST table (if any) secure in the knowledge that no one is
         * deleting the parent relation.
         *
         * NOTE: this cannot block, even if someone else is waiting for access,
         * because the lock manager knows that both lock requests are from the
         * same process.
         */
        onerelid = onerel->rd_lockInfo.lockRelId;
        LockRelationIdForSession(&onerelid, lmode);

        /*
         * Remember the relation's TOAST relation for later, if the caller asked
         * us to process it.
         */
        if (do_toast)
                toast_relid = onerel->rd_rel->reltoastrelid;
        else
                toast_relid = InvalidOid;

        /*
         * Switch to the table owner's userid, so that any index functions are run
         * as that user.  Also lock down security-restricted operations and
         * arrange to make GUC variable changes local to this command.
         * (This is unnecessary, but harmless, for lazy VACUUM.)
         */
        GetUserIdAndSecContext(&save_userid, &save_sec_context);
        SetUserIdAndSecContext(onerel->rd_rel->relowner,
                                                   save_sec_context | SECURITY_RESTRICTED_OPERATION);
        save_nestlevel = NewGUCNestLevel();

        /*
         * Do the actual work --- either FULL or "lazy" vacuum
         */
        if (vacstmt->options & VACOPT_FULL)
                heldoff = full_vacuum_rel(onerel, vacstmt);
        else
                heldoff = lazy_vacuum_rel(onerel, vacstmt, vac_strategy, scanned_all);

        /* Roll back any GUC changes executed by index functions */
        AtEOXact_GUC(false, save_nestlevel);

        /* Restore userid and security context */
        SetUserIdAndSecContext(save_userid, save_sec_context);

        /* all done with this class, but hold lock until commit */
        relation_close(onerel, NoLock);

        /*
         * Complete the transaction and free all temporary memory used.
         */
        PopActiveSnapshot();
        CommitTransactionCommand();

        /* now we can allow interrupts again, if disabled */
        if (heldoff)
                RESUME_INTERRUPTS();

        /*
         * If the relation has a secondary toast rel, vacuum that too while we
         * still hold the session lock on the master table.  Note however that
         * "analyze" will not get done on the toast table.      This is good, because
         * the toaster always uses hardcoded index access and statistics are
         * totally unimportant for toast relations.
         */
        if (toast_relid != InvalidOid)
                vacuum_rel(toast_relid, vacstmt, false, for_wraparound, NULL);

        /*
         * Now release the session-level lock on the master table.
         */
        UnlockRelationIdForSession(&onerelid, lmode);
}


/****************************************************************************
 *                                                                                                                                                      *
 *                      Code for VACUUM FULL (only)                                                                             *
 *                                                                                                                                                      *
 ****************************************************************************
 */


/*
 *      full_vacuum_rel() -- perform FULL VACUUM for one heap relation
 *
 *              This routine vacuums a single heap, cleans out its indexes, and
 *              updates its num_pages and num_tuples statistics.
 *
 *              At entry, we have already established a transaction and opened
 *              and locked the relation.
 *
 *              The return value indicates whether this function has held off
 *              interrupts -- caller must RESUME_INTERRUPTS() after commit if true.
 */
static bool
full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt)
{
        VacPageListData vacuum_pages;           /* List of pages to vacuum and/or
                                                                                 * clean indexes */
        VacPageListData fraged_pages;           /* List of pages with space enough for
                                                                                 * re-using */
        Relation   *Irel;
        int                     nindexes,
                                i;
        VRelStats  *vacrelstats;
        bool            heldoff = false;

        vacuum_set_xid_limits(vacstmt->freeze_min_age, vacstmt->freeze_table_age,
                                                  onerel->rd_rel->relisshared,
                                                  &OldestXmin, &FreezeLimit, NULL);

        /*
         * Flush any previous async-commit transactions.  This does not guarantee
         * that we will be able to set hint bits for tuples they inserted, but it
         * improves the probability, especially in simple sequential-commands
         * cases.  See scan_heap() and repair_frag() for more about this.
         */
        XLogAsyncCommitFlush();

        /*
         * Set up statistics-gathering machinery.
         */
        vacrelstats = (VRelStats *) palloc(sizeof(VRelStats));
        vacrelstats->rel_pages = 0;
        vacrelstats->rel_tuples = 0;
        vacrelstats->rel_indexed_tuples = 0;
        vacrelstats->hasindex = false;
        vacrelstats->latestRemovedXid = InvalidTransactionId;

        /* scan the heap */
        vacuum_pages.num_pages = fraged_pages.num_pages = 0;
        scan_heap(vacrelstats, onerel, &vacuum_pages, &fraged_pages);

        /* Now open all indexes of the relation */
        vac_open_indexes(onerel, AccessExclusiveLock, &nindexes, &Irel);
        if (nindexes > 0)
                vacrelstats->hasindex = true;

        /* Clean/scan index relation(s) */
        if (Irel != NULL)
        {
                if (vacuum_pages.num_pages > 0)
                {
                        for (i = 0; i < nindexes; i++)
                                vacuum_index(&vacuum_pages, Irel[i],
                                                         vacrelstats->rel_indexed_tuples, 0);
                }
                else
                {
                        /* just scan indexes to update statistic */
                        for (i = 0; i < nindexes; i++)
                                scan_index(Irel[i], vacrelstats->rel_indexed_tuples);
                }
        }

        if (fraged_pages.num_pages > 0)
        {
                /* Try to shrink heap */
                heldoff = repair_frag(vacrelstats, onerel, &vacuum_pages, &fraged_pages,
                                        nindexes, Irel);
                vac_close_indexes(nindexes, Irel, NoLock);
        }
        else
        {
                vac_close_indexes(nindexes, Irel, NoLock);
                if (vacuum_pages.num_pages > 0)
                {
                        /* Clean pages from vacuum_pages list */
                        vacuum_heap(vacrelstats, onerel, &vacuum_pages);
                }
        }

        /* update thefree space map with final free space info, and vacuum it */
        vac_update_fsm(onerel, &fraged_pages, vacrelstats->rel_pages);
        FreeSpaceMapVacuum(onerel);

        /* update statistics in pg_class */
        vac_update_relstats(onerel,
                                                vacrelstats->rel_pages, vacrelstats->rel_tuples,
                                                vacrelstats->hasindex, FreezeLimit);

        /* report results to the stats collector, too */
        pgstat_report_vacuum(RelationGetRelid(onerel),
                                                 onerel->rd_rel->relisshared,
                                                 true,
                                                 vacrelstats->rel_tuples);

        return heldoff;
}


/*
 *      scan_heap() -- scan an open heap relation
 *
 *              This routine sets commit status bits, constructs vacuum_pages (list
 *              of pages we need to compact free space on and/or clean indexes of
 *              deleted tuples), constructs fraged_pages (list of pages with free
 *              space that tuples could be moved into), and calculates statistics
 *              on the number of live tuples in the heap.
 */
static void
scan_heap(VRelStats *vacrelstats, Relation onerel,
                  VacPageList vacuum_pages, VacPageList fraged_pages)
{
        BlockNumber nblocks,
                                blkno;
        char       *relname;
        VacPage         vacpage;
        BlockNumber empty_pages,
                                empty_end_pages;
        double          num_tuples,
                                num_indexed_tuples,
                                tups_vacuumed,
                                nkeep,
                                nunused;
        double          free_space,
                                usable_free_space;
        Size            min_tlen = MaxHeapTupleSize;
        Size            max_tlen = 0;
        bool            do_shrinking = true;
        VTupleLink      vtlinks = (VTupleLink) palloc(100 * sizeof(VTupleLinkData));
        int                     num_vtlinks = 0;
        int                     free_vtlinks = 100;
        PGRUsage        ru0;

        pg_rusage_init(&ru0);

        relname = RelationGetRelationName(onerel);
        ereport(elevel,
                        (errmsg("vacuuming \"%s.%s\"",
                                        get_namespace_name(RelationGetNamespace(onerel)),
                                        relname)));

        empty_pages = empty_end_pages = 0;
        num_tuples = num_indexed_tuples = tups_vacuumed = nkeep = nunused = 0;
        free_space = 0;

        nblocks = RelationGetNumberOfBlocks(onerel);

        /*
         * We initially create each VacPage item in a maximal-sized workspace,
         * then copy the workspace into a just-large-enough copy.
         */
        vacpage = (VacPage) palloc(sizeof(VacPageData) + MaxOffsetNumber * sizeof(OffsetNumber));

        for (blkno = 0; blkno < nblocks; blkno++)
        {
                Page            page,
                                        tempPage = NULL;
                bool            do_reap,
                                        do_frag;
                Buffer          buf;
                OffsetNumber offnum,
                                        maxoff;
                bool            notup;
                OffsetNumber frozen[MaxOffsetNumber];
                int                     nfrozen;

                vacuum_delay_point();

                buf = ReadBufferExtended(onerel, MAIN_FORKNUM, blkno, RBM_NORMAL,
                                                                 vac_strategy);
                page = BufferGetPage(buf);

                /*
                 * Since we are holding exclusive lock on the relation, no other
                 * backend can be accessing the page; however it is possible that the
                 * background writer will try to write the page if it's already marked
                 * dirty.  To ensure that invalid data doesn't get written to disk, we
                 * must take exclusive buffer lock wherever we potentially modify
                 * pages.  In fact, we insist on cleanup lock so that we can safely
                 * call heap_page_prune().      (This might be overkill, since the
                 * bgwriter pays no attention to individual tuples, but on the other
                 * hand it's unlikely that the bgwriter has this particular page
                 * pinned at this instant.      So violating the coding rule would buy us
                 * little anyway.)
                 */
                LockBufferForCleanup(buf);

                vacpage->blkno = blkno;
                vacpage->offsets_used = 0;
                vacpage->offsets_free = 0;

                if (PageIsNew(page))
                {
                        VacPage         vacpagecopy;

                        ereport(WARNING,
                           (errmsg("relation \"%s\" page %u is uninitialized --- fixing",
                                           relname, blkno)));
                        PageInit(page, BufferGetPageSize(buf), 0);
                        MarkBufferDirty(buf);
                        vacpage->free = PageGetFreeSpaceWithFillFactor(onerel, page);
                        free_space += vacpage->free;
                        empty_pages++;
                        empty_end_pages++;
                        vacpagecopy = copy_vac_page(vacpage);
                        vpage_insert(vacuum_pages, vacpagecopy);
                        vpage_insert(fraged_pages, vacpagecopy);
                        UnlockReleaseBuffer(buf);
                        continue;
                }

                if (PageIsEmpty(page))
                {
                        VacPage         vacpagecopy;

                        vacpage->free = PageGetFreeSpaceWithFillFactor(onerel, page);
                        free_space += vacpage->free;
                        empty_pages++;
                        empty_end_pages++;
                        vacpagecopy = copy_vac_page(vacpage);
                        vpage_insert(vacuum_pages, vacpagecopy);
                        vpage_insert(fraged_pages, vacpagecopy);
                        UnlockReleaseBuffer(buf);
                        continue;
                }

                /*
                 * Prune all HOT-update chains in this page.
                 *
                 * We use the redirect_move option so that redirecting line pointers
                 * get collapsed out; this allows us to not worry about them below.
                 *
                 * We count tuples removed by the pruning step as removed by VACUUM.
                 */
                tups_vacuumed += heap_page_prune(onerel, buf, OldestXmin,
                                                                                 true, false);

                /*
                 * Now scan the page to collect vacuumable items and check for tuples
                 * requiring freezing.
                 */
                nfrozen = 0;
                notup = true;
                maxoff = PageGetMaxOffsetNumber(page);
                for (offnum = FirstOffsetNumber;
                         offnum <= maxoff;
                         offnum = OffsetNumberNext(offnum))
                {
                        ItemId          itemid = PageGetItemId(page, offnum);
                        bool            tupgone = false;
                        HeapTupleData tuple;

                        /*
                         * Collect un-used items too - it's possible to have indexes
                         * pointing here after crash.  (That's an ancient comment and is
                         * likely obsolete with WAL, but we might as well continue to
                         * check for such problems.)
                         */
                        if (!ItemIdIsUsed(itemid))
                        {
                                vacpage->offsets[vacpage->offsets_free++] = offnum;
                                nunused += 1;
                                continue;
                        }

                        /*
                         * DEAD item pointers are to be vacuumed normally; but we don't
                         * count them in tups_vacuumed, else we'd be double-counting (at
                         * least in the common case where heap_page_prune() just freed up
                         * a non-HOT tuple).
                         */
                        if (ItemIdIsDead(itemid))
                        {
                                vacpage->offsets[vacpage->offsets_free++] = offnum;
                                continue;
                        }

                        /* Shouldn't have any redirected items anymore */
                        if (!ItemIdIsNormal(itemid))
                                elog(ERROR, "relation \"%s\" TID %u/%u: unexpected redirect item",
                                         relname, blkno, offnum);

                        tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
                        tuple.t_len = ItemIdGetLength(itemid);
                        ItemPointerSet(&(tuple.t_self), blkno, offnum);

                        switch (HeapTupleSatisfiesVacuum(tuple.t_data, OldestXmin, buf))
                        {
                                case HEAPTUPLE_LIVE:
                                        /* Tuple is good --- but let's do some validity checks */
                                        if (onerel->rd_rel->relhasoids &&
                                                !OidIsValid(HeapTupleGetOid(&tuple)))
                                                elog(WARNING, "relation \"%s\" TID %u/%u: OID is invalid",
                                                         relname, blkno, offnum);

                                        /*
                                         * The shrinkage phase of VACUUM FULL requires that all
                                         * live tuples have XMIN_COMMITTED set --- see comments in
                                         * repair_frag()'s walk-along-page loop.  Use of async
                                         * commit may prevent HeapTupleSatisfiesVacuum from
                                         * setting the bit for a recently committed tuple.      Rather
                                         * than trying to handle this corner case, we just give up
                                         * and don't shrink.
                                         */
                                        if (do_shrinking &&
                                                !(tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED))
                                        {
                                                ereport(LOG,
                                                                (errmsg("relation \"%s\" TID %u/%u: XMIN_COMMITTED not set for transaction %u --- cannot shrink relation",
                                                                                relname, blkno, offnum,
                                                                         HeapTupleHeaderGetXmin(tuple.t_data))));
                                                do_shrinking = false;
                                        }
                                        break;
                                case HEAPTUPLE_DEAD:

                                        /*
                                         * Ordinarily, DEAD tuples would have been removed by
                                         * heap_page_prune(), but it's possible that the tuple
                                         * state changed since heap_page_prune() looked.  In
                                         * particular an INSERT_IN_PROGRESS tuple could have
                                         * changed to DEAD if the inserter aborted.  So this
                                         * cannot be considered an error condition, though it does
                                         * suggest that someone released a lock early.
                                         *
                                         * If the tuple is HOT-updated then it must only be
                                         * removed by a prune operation; so we keep it as if it
                                         * were RECENTLY_DEAD, and abandon shrinking. (XXX is it
                                         * worth trying to make the shrinking code smart enough to
                                         * handle this?  It's an unusual corner case.)
                                         *
                                         * DEAD heap-only tuples can safely be removed if they
                                         * aren't themselves HOT-updated, although this is a bit
                                         * inefficient since we'll uselessly try to remove index
                                         * entries for them.
                                         */
                                        if (HeapTupleIsHotUpdated(&tuple))
                                        {
                                                nkeep += 1;
                                                if (do_shrinking)
                                                        ereport(LOG,
                                                                        (errmsg("relation \"%s\" TID %u/%u: dead HOT-updated tuple --- cannot shrink relation",
                                                                                        relname, blkno, offnum)));
                                                do_shrinking = false;
                                        }
                                        else
                                        {
                                                tupgone = true; /* we can delete the tuple */

                                                /*
                                                 * We need not require XMIN_COMMITTED or
                                                 * XMAX_COMMITTED to be set, since we will remove the
                                                 * tuple without any further examination of its hint
                                                 * bits.
                                                 */
                                        }
                                        break;
                                case HEAPTUPLE_RECENTLY_DEAD:

                                        /*
                                         * If tuple is recently deleted then we must not remove it
                                         * from relation.
                                         */
                                        nkeep += 1;

                                        /*
                                         * As with the LIVE case, shrinkage requires
                                         * XMIN_COMMITTED to be set.
                                         */
                                        if (do_shrinking &&
                                                !(tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED))
                                        {
                                                ereport(LOG,
                                                                (errmsg("relation \"%s\" TID %u/%u: XMIN_COMMITTED not set for transaction %u --- cannot shrink relation",
                                                                                relname, blkno, offnum,
                                                                         HeapTupleHeaderGetXmin(tuple.t_data))));
                                                do_shrinking = false;
                                        }

                                        /*
                                         * If we do shrinking and this tuple is updated one then
                                         * remember it to construct updated tuple dependencies.
                                         */
                                        if (do_shrinking &&
                                                !(ItemPointerEquals(&(tuple.t_self),
                                                                                        &(tuple.t_data->t_ctid))))
                                        {
                                                if (free_vtlinks == 0)
                                                {
                                                        free_vtlinks = 1000;
                                                        vtlinks = (VTupleLink) repalloc(vtlinks,
                                                                                           (free_vtlinks + num_vtlinks) *
                                                                                                         sizeof(VTupleLinkData));
                                                }
                                                vtlinks[num_vtlinks].new_tid = tuple.t_data->t_ctid;
                                                vtlinks[num_vtlinks].this_tid = tuple.t_self;
                                                free_vtlinks--;
                                                num_vtlinks++;
                                        }
                                        break;
                                case HEAPTUPLE_INSERT_IN_PROGRESS:

                                        /*
                                         * This should not happen, since we hold exclusive lock on
                                         * the relation; shouldn't we raise an error?  (Actually,
                                         * it can happen in system catalogs, since we tend to
                                         * release write lock before commit there.)  As above, we
                                         * can't apply repair_frag() if the tuple state is
                                         * uncertain.
                                         */
                                        if (do_shrinking)
                                                ereport(LOG,
                                                                (errmsg("relation \"%s\" TID %u/%u: InsertTransactionInProgress %u --- cannot shrink relation",
                                                                                relname, blkno, offnum,
                                                                         HeapTupleHeaderGetXmin(tuple.t_data))));
                                        do_shrinking = false;
                                        break;
                                case HEAPTUPLE_DELETE_IN_PROGRESS:

                                        /*
                                         * This should not happen, since we hold exclusive lock on
                                         * the relation; shouldn't we raise an error?  (Actually,
                                         * it can happen in system catalogs, since we tend to
                                         * release write lock before commit there.)  As above, we
                                         * can't apply repair_frag() if the tuple state is
                                         * uncertain.
                                         */
                                        if (do_shrinking)
                                                ereport(LOG,
                                                                (errmsg("relation \"%s\" TID %u/%u: DeleteTransactionInProgress %u --- cannot shrink relation",
                                                                                relname, blkno, offnum,
                                                                         HeapTupleHeaderGetXmax(tuple.t_data))));
                                        do_shrinking = false;
                                        break;
                                default:
                                        elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
                                        break;
                        }

                        if (tupgone)
                        {
                                ItemId          lpp;

                                HeapTupleHeaderAdvanceLatestRemovedXid(tuple.t_data,
                                                                                        &vacrelstats->latestRemovedXid);

                                /*
                                 * Here we are building a temporary copy of the page with dead
                                 * tuples removed.      Below we will apply
                                 * PageRepairFragmentation to the copy, so that we can
                                 * determine how much space will be available after removal of
                                 * dead tuples.  But note we are NOT changing the real page
                                 * yet...
                                 */
                                if (tempPage == NULL)
                                {
                                        Size            pageSize;

                                        pageSize = PageGetPageSize(page);
                                        tempPage = (Page) palloc(pageSize);
                                        memcpy(tempPage, page, pageSize);
                                }

                                /* mark it unused on the temp page */
                                lpp = PageGetItemId(tempPage, offnum);
                                ItemIdSetUnused(lpp);

                                vacpage->offsets[vacpage->offsets_free++] = offnum;
                                tups_vacuumed += 1;
                        }
                        else
                        {
                                num_tuples += 1;
                                if (!HeapTupleIsHeapOnly(&tuple))
                                        num_indexed_tuples += 1;
                                notup = false;
                                if (tuple.t_len < min_tlen)
                                        min_tlen = tuple.t_len;
                                if (tuple.t_len > max_tlen)
                                        max_tlen = tuple.t_len;

                                /*
                                 * Each non-removable tuple must be checked to see if it needs
                                 * freezing.
                                 */
                                if (heap_freeze_tuple(tuple.t_data, FreezeLimit,
                                                                          InvalidBuffer))
                                        frozen[nfrozen++] = offnum;
                        }
                }                                               /* scan along page */

                if (tempPage != NULL)
                {
                        /* Some tuples are removable; figure free space after removal */
                        PageRepairFragmentation(tempPage);
                        vacpage->free = PageGetFreeSpaceWithFillFactor(onerel, tempPage);
                        pfree(tempPage);
                        do_reap = true;
                }
                else
                {
                        /* Just use current available space */
                        vacpage->free = PageGetFreeSpaceWithFillFactor(onerel, page);
                        /* Need to reap the page if it has UNUSED or DEAD line pointers */
                        do_reap = (vacpage->offsets_free > 0);
                }

                free_space += vacpage->free;

                /*
                 * Add the page to vacuum_pages if it requires reaping, and add it to
                 * fraged_pages if it has a useful amount of free space.  "Useful"
                 * means enough for a minimal-sized tuple.      But we don't know that
                 * accurately near the start of the relation, so add pages
                 * unconditionally if they have >= BLCKSZ/10 free space.  Also
                 * forcibly add pages with no live tuples, to avoid confusing the
                 * empty_end_pages logic.  (In the presence of unreasonably small
                 * fillfactor, it seems possible that such pages might not pass the
                 * free-space test, but they had better be in the list anyway.)
                 */
                do_frag = (vacpage->free >= min_tlen || vacpage->free >= BLCKSZ / 10 ||
                                   notup);

                if (do_reap || do_frag)
                {
                        VacPage         vacpagecopy = copy_vac_page(vacpage);

                        if (do_reap)
                                vpage_insert(vacuum_pages, vacpagecopy);
                        if (do_frag)
                                vpage_insert(fraged_pages, vacpagecopy);
                }

                /*
                 * Include the page in empty_end_pages if it will be empty after
                 * vacuuming; this is to keep us from using it as a move destination.
                 * Note that such pages are guaranteed to be in fraged_pages.
                 */
                if (notup)
                {
                        empty_pages++;
                        empty_end_pages++;
                }
                else
                        empty_end_pages = 0;

                /*
                 * If we froze any tuples, mark the buffer dirty, and write a WAL
                 * record recording the changes.  We must log the changes to be
                 * crash-safe against future truncation of CLOG.
                 */
                if (nfrozen > 0)
                {
                        MarkBufferDirty(buf);
                        /* no XLOG for temp tables, though */
                        if (!onerel->rd_istemp)
                        {
                                XLogRecPtr      recptr;

                                recptr = log_heap_freeze(onerel, buf, FreezeLimit,
                                                                                 frozen, nfrozen);
                                PageSetLSN(page, recptr);
                                PageSetTLI(page, ThisTimeLineID);
                        }
                }

                UnlockReleaseBuffer(buf);
        }

        pfree(vacpage);

        /* save stats in the rel list for use later */
        vacrelstats->rel_tuples = num_tuples;
        vacrelstats->rel_indexed_tuples = num_indexed_tuples;
        vacrelstats->rel_pages = nblocks;
        if (num_tuples == 0)
                min_tlen = max_tlen = 0;
        vacrelstats->min_tlen = min_tlen;
        vacrelstats->max_tlen = max_tlen;

        vacuum_pages->empty_end_pages = empty_end_pages;
        fraged_pages->empty_end_pages = empty_end_pages;

        /*
         * Clear the fraged_pages list if we found we couldn't shrink. Else,
         * remove any "empty" end-pages from the list, and compute usable free
         * space = free space in remaining pages.
         */
        if (do_shrinking)
        {
                int                     i;

                Assert((BlockNumber) fraged_pages->num_pages >= empty_end_pages);
                fraged_pages->num_pages -= empty_end_pages;
                usable_free_space = 0;
                for (i = 0; i < fraged_pages->num_pages; i++)
                        usable_free_space += fraged_pages->pagedesc[i]->free;
        }
        else
        {
                fraged_pages->num_pages = 0;
                usable_free_space = 0;
        }

        /* don't bother to save vtlinks if we will not call repair_frag */
        if (fraged_pages->num_pages > 0 && num_vtlinks > 0)
        {
                qsort((char *) vtlinks, num_vtlinks, sizeof(VTupleLinkData),
                          vac_cmp_vtlinks);
                vacrelstats->vtlinks = vtlinks;
                vacrelstats->num_vtlinks = num_vtlinks;
        }
        else
        {
                vacrelstats->vtlinks = NULL;
                vacrelstats->num_vtlinks = 0;
                pfree(vtlinks);
        }

        ereport(elevel,
                        (errmsg("\"%s\": found %.0f removable, %.0f nonremovable row versions in %u pages",
                                        RelationGetRelationName(onerel),
                                        tups_vacuumed, num_tuples, nblocks),
                         errdetail("%.0f dead row versions cannot be removed yet.\n"
                          "Nonremovable row versions range from %lu to %lu bytes long.\n"
                                           "There were %.0f unused item pointers.\n"
           "Total free space (including removable row versions) is %.0f bytes.\n"
                                           "%u pages are or will become empty, including %u at the end of the table.\n"
         "%u pages containing %.0f free bytes are potential move destinations.\n"
                                           "%s.",
                                           nkeep,
                                           (unsigned long) min_tlen, (unsigned long) max_tlen,
                                           nunused,
                                           free_space,
                                           empty_pages, empty_end_pages,
                                           fraged_pages->num_pages, usable_free_space,
                                           pg_rusage_show(&ru0))));
}


/*
 *      repair_frag() -- try to repair relation's fragmentation
 *
 *              This routine marks dead tuples as unused and tries re-use dead space
 *              by moving tuples (and inserting indexes if needed). It constructs
 *              Nvacpagelist list of free-ed pages (moved tuples) and clean indexes
 *              for them after committing (in hack-manner - without losing locks
 *              and freeing memory!) current transaction. It truncates relation
 *              if some end-blocks are gone away.
 *
 *              The return value indicates whether this function has held off
 *              interrupts -- caller must RESUME_INTERRUPTS() after commit if true.
 */
static bool
repair_frag(VRelStats *vacrelstats, Relation onerel,
                        VacPageList vacuum_pages, VacPageList fraged_pages,
                        int nindexes, Relation *Irel)
{
        TransactionId myXID = GetCurrentTransactionId();
        Buffer          dst_buffer = InvalidBuffer;
        BlockNumber nblocks,
                                blkno;
        BlockNumber last_move_dest_block = 0,
                                last_vacuum_block;
        Page            dst_page = NULL;
        ExecContextData ec;
        VacPageListData Nvacpagelist;
        VacPage         dst_vacpage = NULL,
                                last_vacuum_page,
                                vacpage,
                           *curpage;
        int                     i;
        int                     num_moved = 0,
                                num_fraged_pages,
                                vacuumed_pages;
        int                     keep_tuples = 0;
        int                     keep_indexed_tuples = 0;
        PGRUsage        ru0;
        bool            heldoff = false;

        pg_rusage_init(&ru0);

        ExecContext_Init(&ec, onerel);

        Nvacpagelist.num_pages = 0;
        num_fraged_pages = fraged_pages->num_pages;
        Assert((BlockNumber) vacuum_pages->num_pages >= vacuum_pages->empty_end_pages);
        vacuumed_pages = vacuum_pages->num_pages - vacuum_pages->empty_end_pages;
        if (vacuumed_pages > 0)
        {
                /* get last reaped page from vacuum_pages */
                last_vacuum_page = vacuum_pages->pagedesc[vacuumed_pages - 1];
                last_vacuum_block = last_vacuum_page->blkno;
        }
        else
        {
                last_vacuum_page = NULL;
                last_vacuum_block = InvalidBlockNumber;
        }

        vacpage = (VacPage) palloc(sizeof(VacPageData) + MaxOffsetNumber * sizeof(OffsetNumber));
        vacpage->offsets_used = vacpage->offsets_free = 0;

        /*
         * Scan pages backwards from the last nonempty page, trying to move tuples
         * down to lower pages.  Quit when we reach a page that we have moved any
         * tuples onto, or the first page if we haven't moved anything, or when we
         * find a page we cannot completely empty (this last condition is handled
         * by "break" statements within the loop).
         *
         * NB: this code depends on the vacuum_pages and fraged_pages lists being
         * in order by blkno.
         */
        nblocks = vacrelstats->rel_pages;
        for (blkno = nblocks - vacuum_pages->empty_end_pages - 1;
                 blkno > last_move_dest_block;
                 blkno--)
        {
                Buffer          buf;
                Page            page;
                OffsetNumber offnum,
                                        maxoff;
                bool            isempty,
                                        chain_tuple_moved;

                vacuum_delay_point();

                /*
                 * Forget fraged_pages pages at or after this one; they're no longer
                 * useful as move targets, since we only want to move down. Note that
                 * since we stop the outer loop at last_move_dest_block, pages removed
                 * here cannot have had anything moved onto them already.
                 *
                 * Also note that we don't change the stored fraged_pages list, only
                 * our local variable num_fraged_pages; so the forgotten pages are
                 * still available to be loaded into the free space map later.
                 */
                while (num_fraged_pages > 0 &&
                           fraged_pages->pagedesc[num_fraged_pages - 1]->blkno >= blkno)
                {
                        Assert(fraged_pages->pagedesc[num_fraged_pages - 1]->offsets_used == 0);
                        --num_fraged_pages;
                }

                /*
                 * Process this page of relation.
                 */
                buf = ReadBufferExtended(onerel, MAIN_FORKNUM, blkno, RBM_NORMAL,
                                                                 vac_strategy);
                page = BufferGetPage(buf);

                vacpage->offsets_free = 0;

                isempty = PageIsEmpty(page);

                /* Is the page in the vacuum_pages list? */
                if (blkno == last_vacuum_block)
                {
                        if (last_vacuum_page->offsets_free > 0)
                        {
                                /* there are dead tuples on this page - clean them */
                                Assert(!isempty);
                                LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
                                vacuum_page(vacrelstats, onerel, buf, last_vacuum_page);
                                LockBuffer(buf, BUFFER_LOCK_UNLOCK);
                        }
                        else
                                Assert(isempty);
                        --vacuumed_pages;
                        if (vacuumed_pages > 0)
                        {
                                /* get prev reaped page from vacuum_pages */
                                last_vacuum_page = vacuum_pages->pagedesc[vacuumed_pages - 1];
                                last_vacuum_block = last_vacuum_page->blkno;
                        }
                        else
                        {
                                last_vacuum_page = NULL;
                                last_vacuum_block = InvalidBlockNumber;
                        }
                        if (isempty)
                        {
                                ReleaseBuffer(buf);
                                continue;
                        }
                }
                else
                        Assert(!isempty);

                chain_tuple_moved = false;              /* no one chain-tuple was moved off
                                                                                 * this page, yet */
                vacpage->blkno = blkno;
                maxoff = PageGetMaxOffsetNumber(page);
                for (offnum = FirstOffsetNumber;
                         offnum <= maxoff;
                         offnum = OffsetNumberNext(offnum))
                {
                        Size            tuple_len;
                        HeapTupleData tuple;
                        ItemId          itemid = PageGetItemId(page, offnum);

                        if (!ItemIdIsUsed(itemid))
                                continue;

                        if (ItemIdIsDead(itemid))
                        {
                                /* just remember it for vacuum_page() */
                                vacpage->offsets[vacpage->offsets_free++] = offnum;
                                continue;
                        }

                        /* Shouldn't have any redirected items now */
                        Assert(ItemIdIsNormal(itemid));

                        tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
                        tuple_len = tuple.t_len = ItemIdGetLength(itemid);
                        ItemPointerSet(&(tuple.t_self), blkno, offnum);

                        /* ---
                         * VACUUM FULL has an exclusive lock on the relation.  So
                         * normally no other transaction can have pending INSERTs or
                         * DELETEs in this relation.  A tuple is either:
                         *              (a) live (XMIN_COMMITTED)
                         *              (b) known dead (XMIN_INVALID, or XMAX_COMMITTED and xmax
                         *                      is visible to all active transactions)
                         *              (c) inserted and deleted (XMIN_COMMITTED+XMAX_COMMITTED)
                         *                      but at least one active transaction does not see the
                         *                      deleting transaction (ie, it's RECENTLY_DEAD)
                         *              (d) moved by the currently running VACUUM
                         *              (e) inserted or deleted by a not yet committed transaction,
                         *                      or by a transaction we couldn't set XMIN_COMMITTED for.
                         * In case (e) we wouldn't be in repair_frag() at all, because
                         * scan_heap() detects those cases and shuts off shrinking.
                         * We can't see case (b) here either, because such tuples were
                         * already removed by vacuum_page().  Cases (a) and (c) are
                         * normal and will have XMIN_COMMITTED set.  Case (d) is only
                         * possible if a whole tuple chain has been moved while
                         * processing this or a higher numbered block.
                         * ---
                         */
                        if (!(tuple.t_data->t_infomask & HEAP_XMIN_COMMITTED))
                        {
                                if (tuple.t_data->t_infomask & HEAP_MOVED_IN)
                                        elog(ERROR, "HEAP_MOVED_IN was not expected");
                                if (!(tuple.t_data->t_infomask & HEAP_MOVED_OFF))
                                        elog(ERROR, "HEAP_MOVED_OFF was expected");

                                /*
                                 * MOVED_OFF by another VACUUM would have caused the
                                 * visibility check to set XMIN_COMMITTED or XMIN_INVALID.
                                 */
                                if (HeapTupleHeaderGetXvac(tuple.t_data) != myXID)
                                        elog(ERROR, "invalid XVAC in tuple header");

                                /*
                                 * If this (chain) tuple is moved by me already then I have to
                                 * check is it in vacpage or not - i.e. is it moved while
                                 * cleaning this page or some previous one.
                                 */

                                /* Can't we Assert(keep_tuples > 0) here? */
                                if (keep_tuples == 0)
                                        continue;
                                if (chain_tuple_moved)
                                {
                                        /* some chains were moved while cleaning this page */
                                        Assert(vacpage->offsets_free > 0);
                                        for (i = 0; i < vacpage->offsets_free; i++)
                                        {
                                                if (vacpage->offsets[i] == offnum)
                                                        break;
                                        }
                                        if (i >= vacpage->offsets_free)         /* not found */
                                        {
                                                vacpage->offsets[vacpage->offsets_free++] = offnum;

                                                /*
                                                 * If this is not a heap-only tuple, there must be an
                                                 * index entry for this item which will be removed in
                                                 * the index cleanup. Decrement the
                                                 * keep_indexed_tuples count to remember this.
                                                 */
                                                if (!HeapTupleHeaderIsHeapOnly(tuple.t_data))
                                                        keep_indexed_tuples--;
                                                keep_tuples--;
                                        }
                                }
                                else
                                {
                                        vacpage->offsets[vacpage->offsets_free++] = offnum;

                                        /*
                                         * If this is not a heap-only tuple, there must be an
                                         * index entry for this item which will be removed in the
                                         * index cleanup. Decrement the keep_indexed_tuples count
                                         * to remember this.
                                         */
                                        if (!HeapTupleHeaderIsHeapOnly(tuple.t_data))
                                                keep_indexed_tuples--;
                                        keep_tuples--;
                                }
                                continue;
                        }

                        /*
                         * If this tuple is in a chain of tuples created in updates by
                         * "recent" transactions then we have to move the whole chain of
                         * tuples to other places, so that we can write new t_ctid links
                         * that preserve the chain relationship.
                         *
                         * This test is complicated.  Read it as "if tuple is a recently
                         * created updated version, OR if it is an obsoleted version". (In
                         * the second half of the test, we needn't make any check on XMAX
                         * --- it must be recently obsoleted, else scan_heap would have
                         * deemed it removable.)
                         *
                         * NOTE: this test is not 100% accurate: it is possible for a
                         * tuple to be an updated one with recent xmin, and yet not match
                         * any new_tid entry in the vtlinks list.  Presumably there was
                         * once a parent tuple with xmax matching the xmin, but it's
                         * possible that that tuple has been removed --- for example, if
                         * it had xmin = xmax and wasn't itself an updated version, then
                         * HeapTupleSatisfiesVacuum would deem it removable as soon as the
                         * xmin xact completes.
                         *
                         * To be on the safe side, we abandon the repair_frag process if
                         * we cannot find the parent tuple in vtlinks.  This may be overly
                         * conservative; AFAICS it would be safe to move the chain.
                         *
                         * Also, because we distinguish DEAD and RECENTLY_DEAD tuples
                         * using OldestXmin, which is a rather coarse test, it is quite
                         * possible to have an update chain in which a tuple we think is
                         * RECENTLY_DEAD links forward to one that is definitely DEAD. In
                         * such a case the RECENTLY_DEAD tuple must actually be dead, but
                         * it seems too complicated to try to make VACUUM remove it. We
                         * treat each contiguous set of RECENTLY_DEAD tuples as a
                         * separately movable chain, ignoring any intervening DEAD ones.
                         */
                        if (((tuple.t_data->t_infomask & HEAP_UPDATED) &&
                                 !TransactionIdPrecedes(HeapTupleHeaderGetXmin(tuple.t_data),
                                                                                OldestXmin)) ||
                                (!(tuple.t_data->t_infomask & (HEAP_XMAX_INVALID |
                                                                                           HEAP_IS_LOCKED)) &&
                                 !(ItemPointerEquals(&(tuple.t_self),
                                                                         &(tuple.t_data->t_ctid)))))
                        {
                                Buffer          Cbuf = buf;
                                bool            freeCbuf = false;
                                bool            chain_move_failed = false;
                                bool            moved_target = false;
                                ItemPointerData Ctid;
                                HeapTupleData tp = tuple;
                                Size            tlen = tuple_len;
                                VTupleMove      vtmove;
                                int                     num_vtmove;
                                int                     free_vtmove;
                                VacPage         to_vacpage = NULL;
                                int                     to_item = 0;
                                int                     ti;

                                if (dst_buffer != InvalidBuffer)
                                {
                                        ReleaseBuffer(dst_buffer);
                                        dst_buffer = InvalidBuffer;
                                }

                                /* Quick exit if we have no vtlinks to search in */
                                if (vacrelstats->vtlinks == NULL)
                                {
                                        elog(DEBUG2, "parent item in update-chain not found --- cannot continue repair_frag");
                                        break;          /* out of walk-along-page loop */
                                }

                                /*
                                 * If this tuple is in the begin/middle of the chain then we
                                 * have to move to the end of chain.  As with any t_ctid
                                 * chase, we have to verify that each new tuple is really the
                                 * descendant of the tuple we came from; however, here we need
                                 * even more than the normal amount of paranoia. If t_ctid
                                 * links forward to a tuple determined to be DEAD, then
                                 * depending on where that tuple is, it might already have
                                 * been removed, and perhaps even replaced by a MOVED_IN
                                 * tuple.  We don't want to include any DEAD tuples in the
                                 * chain, so we have to recheck HeapTupleSatisfiesVacuum.
                                 */
                                while (!(tp.t_data->t_infomask & (HEAP_XMAX_INVALID |
                                                                                                  HEAP_IS_LOCKED)) &&
                                           !(ItemPointerEquals(&(tp.t_self),
                                                                                   &(tp.t_data->t_ctid))))
                                {
                                        ItemPointerData nextTid;
                                        TransactionId priorXmax;
                                        Buffer          nextBuf;
                                        Page            nextPage;
                                        OffsetNumber nextOffnum;
                                        ItemId          nextItemid;
                                        HeapTupleHeader nextTdata;
                                        HTSV_Result nextTstatus;

                                        nextTid = tp.t_data->t_ctid;
                                        priorXmax = HeapTupleHeaderGetXmax(tp.t_data);
                                        /* assume block# is OK (see heap_fetch comments) */
                                        nextBuf = ReadBufferExtended(onerel, MAIN_FORKNUM,
                                                                                 ItemPointerGetBlockNumber(&nextTid),
                                                                                                 RBM_NORMAL, vac_strategy);
                                        nextPage = BufferGetPage(nextBuf);
                                        /* If bogus or unused slot, assume tp is end of chain */
                                        nextOffnum = ItemPointerGetOffsetNumber(&nextTid);
                                        if (nextOffnum < FirstOffsetNumber ||
                                                nextOffnum > PageGetMaxOffsetNumber(nextPage))
                                        {
                                                ReleaseBuffer(nextBuf);
                                                break;
                                        }
                                        nextItemid = PageGetItemId(nextPage, nextOffnum);
                                        if (!ItemIdIsNormal(nextItemid))
                                        {
                                                ReleaseBuffer(nextBuf);
                                                break;
                                        }
                                        /* if not matching XMIN, assume tp is end of chain */
                                        nextTdata = (HeapTupleHeader) PageGetItem(nextPage,
                                                                                                                          nextItemid);
                                        if (!TransactionIdEquals(HeapTupleHeaderGetXmin(nextTdata),
                                                                                         priorXmax))
                                        {
                                                ReleaseBuffer(nextBuf);
                                                break;
                                        }

                                        /*
                                         * Must check for DEAD or MOVED_IN tuple, too.  This could
                                         * potentially update hint bits, so we'd better hold the
                                         * buffer content lock.
                                         */
                                        LockBuffer(nextBuf, BUFFER_LOCK_SHARE);
                                        nextTstatus = HeapTupleSatisfiesVacuum(nextTdata,
                                                                                                                   OldestXmin,
                                                                                                                   nextBuf);
                                        if (nextTstatus == HEAPTUPLE_DEAD ||
                                                nextTstatus == HEAPTUPLE_INSERT_IN_PROGRESS)
                                        {
                                                UnlockReleaseBuffer(nextBuf);
                                                break;
                                        }
                                        LockBuffer(nextBuf, BUFFER_LOCK_UNLOCK);
                                        /* if it's MOVED_OFF we shoulda moved this one with it */
                                        if (nextTstatus == HEAPTUPLE_DELETE_IN_PROGRESS)
                                                elog(ERROR, "updated tuple is already HEAP_MOVED_OFF");
                                        /* OK, switch our attention to the next tuple in chain */
                                        tp.t_data = nextTdata;
                                        tp.t_self = nextTid;
                                        tlen = tp.t_len = ItemIdGetLength(nextItemid);
                                        if (freeCbuf)
                                                ReleaseBuffer(Cbuf);
                                        Cbuf = nextBuf;
                                        freeCbuf = true;
                                }

                                /* Set up workspace for planning the chain move */
                                vtmove = (VTupleMove) palloc(100 * sizeof(VTupleMoveData));
                                num_vtmove = 0;
                                free_vtmove = 100;

                                /*
                                 * Now, walk backwards up the chain (towards older tuples) and
                                 * check if all items in chain can be moved.  We record all
                                 * the moves that need to be made in the vtmove array.
                                 */
                                for (;;)
                                {
                                        Buffer          Pbuf;
                                        Page            Ppage;
                                        ItemId          Pitemid;
                                        HeapTupleHeader PTdata;
                                        VTupleLinkData vtld,
                                                           *vtlp;

                                        /* Identify a target page to move this tuple to */
                                        if (to_vacpage == NULL ||
                                                !enough_space(to_vacpage, tlen))
                                        {
                                                for (i = 0; i < num_fraged_pages; i++)
                                                {
                                                        if (enough_space(fraged_pages->pagedesc[i], tlen))
                                                                break;
                                                }

                                                if (i == num_fraged_pages)
                                                {
                                                        /* can't move item anywhere */
                                                        chain_move_failed = true;
                                                        break;          /* out of check-all-items loop */
                                                }
                                                to_item = i;
                                                to_vacpage = fraged_pages->pagedesc[to_item];
                                        }
                                        to_vacpage->free -= MAXALIGN(tlen);
                                        if (to_vacpage->offsets_used >= to_vacpage->offsets_free)
                                                to_vacpage->free -= sizeof(ItemIdData);
                                        (to_vacpage->offsets_used)++;

                                        /* Add an entry to vtmove list */
                                        if (free_vtmove == 0)
                                        {
                                                free_vtmove = 1000;
                                                vtmove = (VTupleMove)
                                                        repalloc(vtmove,
                                                                         (free_vtmove + num_vtmove) *
                                                                         sizeof(VTupleMoveData));
                                        }
                                        vtmove[num_vtmove].tid = tp.t_self;
                                        vtmove[num_vtmove].vacpage = to_vacpage;
                                        if (to_vacpage->offsets_used == 1)
                                                vtmove[num_vtmove].cleanVpd = true;
                                        else
                                                vtmove[num_vtmove].cleanVpd = false;
                                        free_vtmove--;
                                        num_vtmove++;

                                        /* Remember if we reached the original target tuple */
                                        if (ItemPointerGetBlockNumber(&tp.t_self) == blkno &&
                                                ItemPointerGetOffsetNumber(&tp.t_self) == offnum)
                                                moved_target = true;

                                        /* Done if at beginning of chain */
                                        if (!(tp.t_data->t_infomask & HEAP_UPDATED) ||
                                         TransactionIdPrecedes(HeapTupleHeaderGetXmin(tp.t_data),
                                                                                   OldestXmin))
                                                break;  /* out of check-all-items loop */

                                        /* Move to tuple with prior row version */
                                        vtld.new_tid = tp.t_self;
                                        vtlp = (VTupleLink)
                                                vac_bsearch((void *) &vtld,
                                                                        (void *) (vacrelstats->vtlinks),
                                                                        vacrelstats->num_vtlinks,
                                                                        sizeof(VTupleLinkData),
                                                                        vac_cmp_vtlinks);
                                        if (vtlp == NULL)
                                        {
                                                /* see discussion above */
                                                elog(DEBUG2, "parent item in update-chain not found --- cannot continue repair_frag");
                                                chain_move_failed = true;
                                                break;  /* out of check-all-items loop */
                                        }
                                        tp.t_self = vtlp->this_tid;
                                        Pbuf = ReadBufferExtended(onerel, MAIN_FORKNUM,
                                                                         ItemPointerGetBlockNumber(&(tp.t_self)),
                                                                                          RBM_NORMAL, vac_strategy);
                                        Ppage = BufferGetPage(Pbuf);
                                        Pitemid = PageGetItemId(Ppage,
                                                                   ItemPointerGetOffsetNumber(&(tp.t_self)));
                                        /* this can't happen since we saw tuple earlier: */
                                        if (!ItemIdIsNormal(Pitemid))
                                                elog(ERROR, "parent itemid marked as unused");
                                        PTdata = (HeapTupleHeader) PageGetItem(Ppage, Pitemid);

                                        /* ctid should not have changed since we saved it */
                                        Assert(ItemPointerEquals(&(vtld.new_tid),
                                                                                         &(PTdata->t_ctid)));

                                        /*
                                         * Read above about cases when !ItemIdIsUsed(nextItemid)
                                         * (child item is removed)... Due to the fact that at the
                                         * moment we don't remove unuseful part of update-chain,
                                         * it's possible to get non-matching parent row here. Like
                                         * as in the case which caused this problem, we stop
                                         * shrinking here. I could try to find real parent row but
                                         * want not to do it because of real solution will be
                                         * implemented anyway, later, and we are too close to 6.5
                                         * release. - vadim 06/11/99
                                         */
                                        if ((PTdata->t_infomask & HEAP_XMAX_IS_MULTI) ||
                                                !(TransactionIdEquals(HeapTupleHeaderGetXmax(PTdata),
                                                                                 HeapTupleHeaderGetXmin(tp.t_data))))
                                        {
                                                ReleaseBuffer(Pbuf);
                                                elog(DEBUG2, "too old parent tuple found --- cannot continue repair_frag");
                                                chain_move_failed = true;
                                                break;  /* out of check-all-items loop */
                                        }
                                        tp.t_data = PTdata;
                                        tlen = tp.t_len = ItemIdGetLength(Pitemid);
                                        if (freeCbuf)
                                                ReleaseBuffer(Cbuf);
                                        Cbuf = Pbuf;
                                        freeCbuf = true;
                                }                               /* end of check-all-items loop */

                                if (freeCbuf)
                                        ReleaseBuffer(Cbuf);
                                freeCbuf = false;

                                /* Double-check that we will move the current target tuple */
                                if (!moved_target && !chain_move_failed)
                                {
                                        elog(DEBUG2, "failed to chain back to target --- cannot continue repair_frag");
                                        chain_move_failed = true;
                                }

                                if (chain_move_failed)
                                {
                                        /*
                                         * Undo changes to offsets_used state.  We don't bother
                                         * cleaning up the amount-free state, since we're not
                                         * going to do any further tuple motion.
                                         */
                                        for (i = 0; i < num_vtmove; i++)
                                        {
                                                Assert(vtmove[i].vacpage->offsets_used > 0);
                                                (vtmove[i].vacpage->offsets_used)--;
                                        }
                                        pfree(vtmove);
                                        break;          /* out of walk-along-page loop */
                                }

                                /*
                                 * Okay, move the whole tuple chain in reverse order.
                                 *
                                 * Ctid tracks the new location of the previously-moved tuple.
                                 */
                                ItemPointerSetInvalid(&Ctid);
                                for (ti = 0; ti < num_vtmove; ti++)
                                {
                                        VacPage         destvacpage = vtmove[ti].vacpage;
                                        Page            Cpage;
                                        ItemId          Citemid;

                                        /* Get page to move from */
                                        tuple.t_self = vtmove[ti].tid;
                                        Cbuf = ReadBufferExtended(onerel, MAIN_FORKNUM,
                                                                  ItemPointerGetBlockNumber(&(tuple.t_self)),
                                                                                          RBM_NORMAL, vac_strategy);

                                        /* Get page to move to */
                                        dst_buffer = ReadBufferExtended(onerel, MAIN_FORKNUM,
                                                                                                        destvacpage->blkno,
                                                                                                        RBM_NORMAL, vac_strategy);

                                        LockBuffer(dst_buffer, BUFFER_LOCK_EXCLUSIVE);
                                        if (dst_buffer != Cbuf)
                                                LockBuffer(Cbuf, BUFFER_LOCK_EXCLUSIVE);

                                        dst_page = BufferGetPage(dst_buffer);
                                        Cpage = BufferGetPage(Cbuf);

                                        Citemid = PageGetItemId(Cpage,
                                                                ItemPointerGetOffsetNumber(&(tuple.t_self)));
                                        tuple.t_data = (HeapTupleHeader) PageGetItem(Cpage, Citemid);
                                        tuple_len = tuple.t_len = ItemIdGetLength(Citemid);

                                        move_chain_tuple(vacrelstats, onerel, Cbuf, Cpage, &tuple,
                                                                         dst_buffer, dst_page, destvacpage,
                                                                         &ec, &Ctid, vtmove[ti].cleanVpd);

                                        /*
                                         * If the tuple we are moving is a heap-only tuple, this
                                         * move will generate an additional index entry, so
                                         * increment the rel_indexed_tuples count.
                                         */
                                        if (HeapTupleHeaderIsHeapOnly(tuple.t_data))
                                                vacrelstats->rel_indexed_tuples++;

                                        num_moved++;
                                        if (destvacpage->blkno > last_move_dest_block)
                                                last_move_dest_block = destvacpage->blkno;

                                        /*
                                         * Remember that we moved tuple from the current page
                                         * (corresponding index tuple will be cleaned).
                                         */
                                        if (Cbuf == buf)
                                                vacpage->offsets[vacpage->offsets_free++] =
                                                        ItemPointerGetOffsetNumber(&(tuple.t_self));
                                        else
                                        {
                                                /*
                                                 * When we move tuple chains, we may need to move
                                                 * tuples from a block that we haven't yet scanned in
                                                 * the outer walk-along-the-relation loop. Note that
                                                 * we can't be moving a tuple from a block that we
                                                 * have already scanned because if such a tuple
                                                 * exists, then we must have moved the chain along
                                                 * with that tuple when we scanned that block. IOW the
                                                 * test of (Cbuf != buf) guarantees that the tuple we
                                                 * are looking at right now is in a block which is yet
                                                 * to be scanned.
                                                 *
                                                 * We maintain two counters to correctly count the
                                                 * moved-off tuples from blocks that are not yet
                                                 * scanned (keep_tuples) and how many of them have
                                                 * index pointers (keep_indexed_tuples).  The main
                                                 * reason to track the latter is to help verify that
                                                 * indexes have the expected number of entries when
                                                 * all the dust settles.
                                                 */
                                                if (!HeapTupleHeaderIsHeapOnly(tuple.t_data))
                                                        keep_indexed_tuples++;
                                                keep_tuples++;
                                        }

                                        ReleaseBuffer(dst_buffer);
                                        ReleaseBuffer(Cbuf);
                                }                               /* end of move-the-tuple-chain loop */

                                dst_buffer = InvalidBuffer;
                                pfree(vtmove);
                                chain_tuple_moved = true;

                                /* advance to next tuple in walk-along-page loop */
                                continue;
                        }                                       /* end of is-tuple-in-chain test */

                        /* try to find new page for this tuple */
                        if (dst_buffer == InvalidBuffer ||
                                !enough_space(dst_vacpage, tuple_len))
                        {
                                if (dst_buffer != InvalidBuffer)
                                {
                                        ReleaseBuffer(dst_buffer);
                                        dst_buffer = InvalidBuffer;
                                }
                                for (i = 0; i < num_fraged_pages; i++)
                                {
                                        if (enough_space(fraged_pages->pagedesc[i], tuple_len))
                                                break;
                                }
                                if (i == num_fraged_pages)
                                        break;          /* can't move item anywhere */
                                dst_vacpage = fraged_pages->pagedesc[i];
                                dst_buffer = ReadBufferExtended(onerel, MAIN_FORKNUM,
                                                                                                dst_vacpage->blkno,
                                                                                                RBM_NORMAL, vac_strategy);
                                LockBuffer(dst_buffer, BUFFER_LOCK_EXCLUSIVE);
                                dst_page = BufferGetPage(dst_buffer);
                                /* if this page was not used before - clean it */
                                if (!PageIsEmpty(dst_page) && dst_vacpage->offsets_used == 0)
                                        vacuum_page(vacrelstats, onerel, dst_buffer, dst_vacpage);
                        }
                        else
                                LockBuffer(dst_buffer, BUFFER_LOCK_EXCLUSIVE);

                        LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);

                        move_plain_tuple(onerel, buf, page, &tuple,
                                                         dst_buffer, dst_page, dst_vacpage, &ec);

                        /*
                         * If the tuple we are moving is a heap-only tuple, this move will
                         * generate an additional index entry, so increment the
                         * rel_indexed_tuples count.
                         */
                        if (HeapTupleHeaderIsHeapOnly(tuple.t_data))
                                vacrelstats->rel_indexed_tuples++;

                        num_moved++;
                        if (dst_vacpage->blkno > last_move_dest_block)
                                last_move_dest_block = dst_vacpage->blkno;

                        /*
                         * Remember that we moved tuple from the current page
                         * (corresponding index tuple will be cleaned).
                         */
                        vacpage->offsets[vacpage->offsets_free++] = offnum;
                }                                               /* walk along page */

                /*
                 * If we broke out of the walk-along-page loop early (ie, still have
                 * offnum <= maxoff), then we failed to move some tuple off this page.
                 * No point in shrinking any more, so clean up and exit the per-page
                 * loop.
                 */
                if (offnum < maxoff && keep_tuples > 0)
                {
                        OffsetNumber off;

                        /*
                         * Fix vacpage state for any unvisited tuples remaining on page
                         */
                        for (off = OffsetNumberNext(offnum);
                                 off <= maxoff;
                                 off = OffsetNumberNext(off))
                        {
                                ItemId          itemid = PageGetItemId(page, off);
                                HeapTupleHeader htup;

                                if (!ItemIdIsUsed(itemid))
                                        continue;
                                /* Shouldn't be any DEAD or REDIRECT items anymore */
                                Assert(ItemIdIsNormal(itemid));

                                htup = (HeapTupleHeader) PageGetItem(page, itemid);
                                if (htup->t_infomask & HEAP_XMIN_COMMITTED)
                                        continue;

                                /*
                                 * See comments in the walk-along-page loop above about why
                                 * only MOVED_OFF tuples should be found here.
                                 */
                                if (htup->t_infomask & HEAP_MOVED_IN)
                                        elog(ERROR, "HEAP_MOVED_IN was not expected");
                                if (!(htup->t_infomask & HEAP_MOVED_OFF))
                                        elog(ERROR, "HEAP_MOVED_OFF was expected");
                                if (HeapTupleHeaderGetXvac(htup) != myXID)
                                        elog(ERROR, "invalid XVAC in tuple header");

                                if (chain_tuple_moved)
                                {
                                        /* some chains were moved while cleaning this page */
                                        Assert(vacpage->offsets_free > 0);
                                        for (i = 0; i < vacpage->offsets_free; i++)
                                        {
                                                if (vacpage->offsets[i] == off)
                                                        break;
                                        }
                                        if (i >= vacpage->offsets_free)         /* not found */
                                        {
                                                vacpage->offsets[vacpage->offsets_free++] = off;
                                                Assert(keep_tuples > 0);

                                                /*
                                                 * If this is not a heap-only tuple, there must be an
                                                 * index entry for this item which will be removed in
                                                 * the index cleanup. Decrement the
                                                 * keep_indexed_tuples count to remember this.
                                                 */
                                                if (!HeapTupleHeaderIsHeapOnly(htup))
                                                        keep_indexed_tuples--;
                                                keep_tuples--;
                                        }
                                }
                                else
                                {
                                        vacpage->offsets[vacpage->offsets_free++] = off;
                                        Assert(keep_tuples > 0);
                                        if (!HeapTupleHeaderIsHeapOnly(htup))
                                                keep_indexed_tuples--;
                                        keep_tuples--;
                                }
                        }
                }

                if (vacpage->offsets_free > 0)  /* some tuples were moved */
                {
                        if (chain_tuple_moved)          /* else - they are ordered */
                        {
                                qsort((char *) (vacpage->offsets), vacpage->offsets_free,
                                          sizeof(OffsetNumber), vac_cmp_offno);
                        }
                        vpage_insert(&Nvacpagelist, copy_vac_page(vacpage));
                }

                ReleaseBuffer(buf);

                if (offnum <= maxoff)
                        break;                          /* had to quit early, see above note */

        }                                                       /* walk along relation */

        blkno++;                                        /* new number of blocks */

        if (dst_buffer != InvalidBuffer)
        {
                Assert(num_moved > 0);
                ReleaseBuffer(dst_buffer);
        }

        if (num_moved > 0)
        {
                /*
                 * We have to commit our tuple movings before we truncate the
                 * relation.  Ideally we should do Commit/StartTransactionCommand
                 * here, relying on the session-level table lock to protect our
                 * exclusive access to the relation.  However, that would require a
                 * lot of extra code to close and re-open the relation, indexes, etc.
                 * For now, a quick hack: record status of current transaction as
                 * committed, and continue.  We force the commit to be synchronous so
                 * that it's down to disk before we truncate.  (Note: tqual.c knows
                 * that VACUUM FULL always uses sync commit, too.)      The transaction
                 * continues to be shown as running in the ProcArray.
                 *
                 * XXX This desperately needs to be revisited.  Any failure after this
                 * point will result in a PANIC "cannot abort transaction nnn, it was
                 * already committed"!  As a precaution, we prevent cancel interrupts
                 * after this point to mitigate this problem; caller is responsible for
                 * re-enabling them after committing the transaction.
                 */
                HOLD_INTERRUPTS();
                heldoff = true;
                ForceSyncCommit();
                (void) RecordTransactionCommit(true);
        }

        /*
         * We are not going to move any more tuples across pages, but we still
         * need to apply vacuum_page to compact free space in the remaining pages
         * in vacuum_pages list.  Note that some of these pages may also be in the
         * fraged_pages list, and may have had tuples moved onto them; if so, we
         * already did vacuum_page and needn't do it again.
         */
        for (i = 0, curpage = vacuum_pages->pagedesc;
                 i < vacuumed_pages;
                 i++, curpage++)
        {
                vacuum_delay_point();

                Assert((*curpage)->blkno < blkno);
                if ((*curpage)->offsets_used == 0)
                {
                        Buffer          buf;
                        Page            page;

                        /* this page was not used as a move target, so must clean it */
                        buf = ReadBufferExtended(onerel, MAIN_FORKNUM, (*curpage)->blkno,
                                                                         RBM_NORMAL, vac_strategy);
                        LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
                        page = BufferGetPage(buf);
                        if (!PageIsEmpty(page))
                                vacuum_page(vacrelstats, onerel, buf, *curpage);
                        UnlockReleaseBuffer(buf);
                }
        }

        /*
         * Now scan all the pages that we moved tuples onto and update tuple
         * status bits.  This is not really necessary, but will save time for
         * future transactions examining these tuples.
         */
        update_hint_bits(onerel, fraged_pages, num_fraged_pages,
                                         last_move_dest_block, num_moved);

        /*
         * It'd be cleaner to make this report at the bottom of this routine, but
         * then the rusage would double-count the second pass of index vacuuming.
         * So do it here and ignore the relatively small amount of processing that
         * occurs below.
         */
        ereport(elevel,
                        (errmsg("\"%s\": moved %u row versions, truncated %u to %u pages",
                                        RelationGetRelationName(onerel),
                                        num_moved, nblocks, blkno),
                         errdetail("%s.",
                                           pg_rusage_show(&ru0))));

        /*
         * Reflect the motion of system tuples to catalog cache here.
         */
        CommandCounterIncrement();

        if (Nvacpagelist.num_pages > 0)
        {
                /* vacuum indexes again if needed */
                if (Irel != NULL)
                {
                        VacPage    *vpleft,
                                           *vpright,
                                                vpsave;

                        /* re-sort Nvacpagelist.pagedesc */
                        for (vpleft = Nvacpagelist.pagedesc,
                                 vpright = Nvacpagelist.pagedesc + Nvacpagelist.num_pages - 1;
                                 vpleft < vpright; vpleft++, vpright--)
                        {
                                vpsave = *vpleft;
                                *vpleft = *vpright;
                                *vpright = vpsave;
                        }

                        /*
                         * keep_tuples is the number of tuples that have been moved off a
                         * page during chain moves but not been scanned over subsequently.
                         * The tuple ids of these tuples are not recorded as free offsets
                         * for any VacPage, so they will not be cleared from the indexes.
                         * keep_indexed_tuples is the portion of these that are expected
                         * to have index entries.
                         */
                        Assert(keep_tuples >= 0);
                        for (i = 0; i < nindexes; i++)
                                vacuum_index(&Nvacpagelist, Irel[i],
                                                         vacrelstats->rel_indexed_tuples,
                                                         keep_indexed_tuples);
                }

                /*
                 * Clean moved-off tuples from last page in Nvacpagelist list.
                 *
                 * We need only do this in this one page, because higher-numbered
                 * pages are going to be truncated from the relation entirely. But see
                 * comments for update_hint_bits().
                 */
                if (vacpage->blkno == (blkno - 1) &&
                        vacpage->offsets_free > 0)
                {
                        Buffer          buf;
                        Page            page;
                        OffsetNumber unused[MaxOffsetNumber];
                        OffsetNumber offnum,
                                                maxoff;
                        int                     uncnt = 0;
                        int                     num_tuples = 0;

                        buf = ReadBufferExtended(onerel, MAIN_FORKNUM, vacpage->blkno,
                                                                         RBM_NORMAL, vac_strategy);
                        LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
                        page = BufferGetPage(buf);
                        maxoff = PageGetMaxOffsetNumber(page);
                        for (offnum = FirstOffsetNumber;
                                 offnum <= maxoff;
                                 offnum = OffsetNumberNext(offnum))
                        {
                                ItemId          itemid = PageGetItemId(page, offnum);
                                HeapTupleHeader htup;

                                if (!ItemIdIsUsed(itemid))
                                        continue;
                                /* Shouldn't be any DEAD or REDIRECT items anymore */
                                Assert(ItemIdIsNormal(itemid));

                                htup = (HeapTupleHeader) PageGetItem(page, itemid);
                                if (htup->t_infomask & HEAP_XMIN_COMMITTED)
                                        continue;

                                /*
                                 * See comments in the walk-along-page loop above about why
                                 * only MOVED_OFF tuples should be found here.
                                 */
                                if (htup->t_infomask & HEAP_MOVED_IN)
                                        elog(ERROR, "HEAP_MOVED_IN was not expected");
                                if (!(htup->t_infomask & HEAP_MOVED_OFF))
                                        elog(ERROR, "HEAP_MOVED_OFF was expected");
                                if (HeapTupleHeaderGetXvac(htup) != myXID)
                                        elog(ERROR, "invalid XVAC in tuple header");

                                ItemIdSetUnused(itemid);
                                num_tuples++;

                                unused[uncnt++] = offnum;
                        }
                        Assert(vacpage->offsets_free == num_tuples);

                        START_CRIT_SECTION();

                        PageRepairFragmentation(page);

                        MarkBufferDirty(buf);

                        /* XLOG stuff */
                        if (!onerel->rd_istemp)
                        {
                                XLogRecPtr      recptr;

                                recptr = log_heap_clean(onerel, buf,
                                                                                NULL, 0, NULL, 0,
                                                                                unused, uncnt,
                                                                                vacrelstats->latestRemovedXid, false);
                                PageSetLSN(page, recptr);
                                PageSetTLI(page, ThisTimeLineID);
                        }

                        END_CRIT_SECTION();

                        UnlockReleaseBuffer(buf);
                }

                /* now - free new list of reaped pages */
                curpage = Nvacpagelist.pagedesc;
                for (i = 0; i < Nvacpagelist.num_pages; i++, curpage++)
                        pfree(*curpage);
                pfree(Nvacpagelist.pagedesc);
        }

        /* Truncate relation, if needed */
        if (blkno < nblocks)
        {
                RelationTruncate(onerel, blkno);

                /* force relcache inval so all backends reset their rd_targblock */
                CacheInvalidateRelcache(onerel);

                vacrelstats->rel_pages = blkno; /* set new number of blocks */
        }

        /* clean up */
        pfree(vacpage);
        if (vacrelstats->vtlinks != NULL)
                pfree(vacrelstats->vtlinks);

        ExecContext_Finish(&ec);

        return heldoff;
}

/*
 *      move_chain_tuple() -- move one tuple that is part of a tuple chain
 *
 *              This routine moves old_tup from old_page to dst_page.
 *              old_page and dst_page might be the same page.
 *              On entry old_buf and dst_buf are locked exclusively, both locks (or
 *              the single lock, if this is a intra-page-move) are released before
 *              exit.
 *
 *              Yes, a routine with ten parameters is ugly, but it's still better
 *              than having these 120 lines of code in repair_frag() which is
 *              already too long and almost unreadable.
 */
static void
move_chain_tuple(VRelStats *vacrelstats, Relation rel,
                                 Buffer old_buf, Page old_page, HeapTuple old_tup,
                                 Buffer dst_buf, Page dst_page, VacPage dst_vacpage,
                                 ExecContext ec, ItemPointer ctid, bool cleanVpd)
{
        TransactionId myXID = GetCurrentTransactionId();
        HeapTupleData newtup;
        OffsetNumber newoff;
        ItemId          newitemid;
        Size            tuple_len = old_tup->t_len;
        bool            all_visible_cleared = false;
        bool            all_visible_cleared_new = false;

        /*
         * make a modifiable copy of the source tuple.
         */
        heap_copytuple_with_tuple(old_tup, &newtup);

        /*
         * register invalidation of source tuple in catcaches.
         */
        CacheInvalidateHeapTuple(rel, old_tup);

        /* NO EREPORT(ERROR) TILL CHANGES ARE LOGGED */
        START_CRIT_SECTION();

        /*
         * mark the source tuple MOVED_OFF.
         */
        old_tup->t_data->t_infomask &= ~(HEAP_XMIN_COMMITTED |
                                                                         HEAP_XMIN_INVALID |
                                                                         HEAP_MOVED_IN);
        old_tup->t_data->t_infomask |= HEAP_MOVED_OFF;
        HeapTupleHeaderSetXvac(old_tup->t_data, myXID);

        /*
         * If this page was not used before - clean it.
         *
         * NOTE: a nasty bug used to lurk here.  It is possible for the source and
         * destination pages to be the same (since this tuple-chain member can be
         * on a page lower than the one we're currently processing in the outer
         * loop).  If that's true, then after vacuum_page() the source tuple will
         * have been moved, and tuple.t_data will be pointing at garbage.
         * Therefore we must do everything that uses old_tup->t_data BEFORE this
         * step!!
         *
         * This path is different from the other callers of vacuum_page, because
         * we have already incremented the vacpage's offsets_used field to account
         * for the tuple(s) we expect to move onto the page. Therefore
         * vacuum_page's check for offsets_used == 0 is wrong. But since that's a
         * good debugging check for all other callers, we work around it here
         * rather than remove it.
         */
        if (!PageIsEmpty(dst_page) && cleanVpd)
        {
                int                     sv_offsets_used = dst_vacpage->offsets_used;

                dst_vacpage->offsets_used = 0;
                vacuum_page(vacrelstats, rel, dst_buf, dst_vacpage);
                dst_vacpage->offsets_used = sv_offsets_used;
        }

        /*
         * Update the state of the copied tuple, and store it on the destination
         * page.  The copied tuple is never part of a HOT chain.
         */
        newtup.t_data->t_infomask &= ~(HEAP_XMIN_COMMITTED |
                                                                   HEAP_XMIN_INVALID |
                                                                   HEAP_MOVED_OFF);
        newtup.t_data->t_infomask |= HEAP_MOVED_IN;
        HeapTupleHeaderClearHotUpdated(newtup.t_data);
        HeapTupleHeaderClearHeapOnly(newtup.t_data);
        HeapTupleHeaderSetXvac(newtup.t_data, myXID);
        newoff = PageAddItem(dst_page, (Item) newtup.t_data, tuple_len,
                                                 InvalidOffsetNumber, false, true);
        if (newoff == InvalidOffsetNumber)
                elog(PANIC, "failed to add item with len = %lu to page %u while moving tuple chain",
                         (unsigned long) tuple_len, dst_vacpage->blkno);
        newitemid = PageGetItemId(dst_page, newoff);
        /* drop temporary copy, and point to the version on the dest page */
        pfree(newtup.t_data);
        newtup.t_data = (HeapTupleHeader) PageGetItem(dst_page, newitemid);

        ItemPointerSet(&(newtup.t_self), dst_vacpage->blkno, newoff);

        /*
         * Set new tuple's t_ctid pointing to itself if last tuple in chain, and
         * to next tuple in chain otherwise.  (Since we move the chain in reverse
         * order, this is actually the previously processed tuple.)
         */
        if (!ItemPointerIsValid(ctid))
                newtup.t_data->t_ctid = newtup.t_self;
        else
                newtup.t_data->t_ctid = *ctid;
        *ctid = newtup.t_self;

        /* clear PD_ALL_VISIBLE flags */
        if (PageIsAllVisible(old_page))
        {
                all_visible_cleared = true;
                PageClearAllVisible(old_page);
        }
        if (dst_buf != old_buf && PageIsAllVisible(dst_page))
        {
                all_visible_cleared_new = true;
                PageClearAllVisible(dst_page);
        }

        MarkBufferDirty(dst_buf);
        if (dst_buf != old_buf)
                MarkBufferDirty(old_buf);

        /* XLOG stuff */
        if (!rel->rd_istemp)
        {
                XLogRecPtr      recptr = log_heap_move(rel, old_buf, old_tup->t_self,
                                                                                   dst_buf, &newtup,
                                                                                   all_visible_cleared,
                                                                                   all_visible_cleared_new);

                if (old_buf != dst_buf)
                {
                        PageSetLSN(old_page, recptr);
                        PageSetTLI(old_page, ThisTimeLineID);
                }
                PageSetLSN(dst_page, recptr);
                PageSetTLI(dst_page, ThisTimeLineID);
        }

        END_CRIT_SECTION();

        LockBuffer(dst_buf, BUFFER_LOCK_UNLOCK);
        if (dst_buf != old_buf)
                LockBuffer(old_buf, BUFFER_LOCK_UNLOCK);

        /* Clear bits in visibility map */
        if (all_visible_cleared)
                visibilitymap_clear(rel, BufferGetBlockNumber(old_buf));
        if (all_visible_cleared_new)
                visibilitymap_clear(rel, BufferGetBlockNumber(dst_buf));

        /* Create index entries for the moved tuple */
        if (ec->resultRelInfo->ri_NumIndices > 0)
        {
                ExecStoreTuple(&newtup, ec->slot, InvalidBuffer, false);
                ExecInsertIndexTuples(ec->slot, &(newtup.t_self), ec->estate, true);
                ResetPerTupleExprContext(ec->estate);
        }
}

/*
 *      move_plain_tuple() -- move one tuple that is not part of a chain
 *
 *              This routine moves old_tup from old_page to dst_page.
 *              On entry old_buf and dst_buf are locked exclusively, both locks are
 *              released before exit.
 *
 *              Yes, a routine with eight parameters is ugly, but it's still better
 *              than having these 90 lines of code in repair_frag() which is already
 *              too long and almost unreadable.
 */
static void
move_plain_tuple(Relation rel,
                                 Buffer old_buf, Page old_page, HeapTuple old_tup,
                                 Buffer dst_buf, Page dst_page, VacPage dst_vacpage,
                                 ExecContext ec)
{
        TransactionId myXID = GetCurrentTransactionId();
        HeapTupleData newtup;
        OffsetNumber newoff;
        ItemId          newitemid;
        Size            tuple_len = old_tup->t_len;
        bool            all_visible_cleared = false;
        bool            all_visible_cleared_new = false;

        /* copy tuple */
        heap_copytuple_with_tuple(old_tup, &newtup);

        /*
         * register invalidation of source tuple in catcaches.
         *
         * (Note: we do not need to register the copied tuple, because we are not
         * changing the tuple contents and so there cannot be any need to flush
         * negative catcache entries.)
         */
        CacheInvalidateHeapTuple(rel, old_tup);

        /* NO EREPORT(ERROR) TILL CHANGES ARE LOGGED */
        START_CRIT_SECTION();

        /*
         * Mark new tuple as MOVED_IN by me; also mark it not HOT.
         */
        newtup.t_data->t_infomask &= ~(HEAP_XMIN_COMMITTED |
                                                                   HEAP_XMIN_INVALID |
                                                                   HEAP_MOVED_OFF);
        newtup.t_data->t_infomask |= HEAP_MOVED_IN;
        HeapTupleHeaderClearHotUpdated(newtup.t_data);
        HeapTupleHeaderClearHeapOnly(newtup.t_data);
        HeapTupleHeaderSetXvac(newtup.t_data, myXID);

        /* add tuple to the page */
        newoff = PageAddItem(dst_page, (Item) newtup.t_data, tuple_len,
                                                 InvalidOffsetNumber, false, true);
        if (newoff == InvalidOffsetNumber)
                elog(PANIC, "failed to add item with len = %lu to page %u (free space %lu, nusd %u, noff %u)",
                         (unsigned long) tuple_len,
                         dst_vacpage->blkno, (unsigned long) dst_vacpage->free,
                         dst_vacpage->offsets_used, dst_vacpage->offsets_free);
        newitemid = PageGetItemId(dst_page, newoff);
        pfree(newtup.t_data);
        newtup.t_data = (HeapTupleHeader) PageGetItem(dst_page, newitemid);
        ItemPointerSet(&(newtup.t_data->t_ctid), dst_vacpage->blkno, newoff);
        newtup.t_self = newtup.t_data->t_ctid;

        /*
         * Mark old tuple as MOVED_OFF by me.
         */
        old_tup->t_data->t_infomask &= ~(HEAP_XMIN_COMMITTED |
                                                                         HEAP_XMIN_INVALID |
                                                                         HEAP_MOVED_IN);
        old_tup->t_data->t_infomask |= HEAP_MOVED_OFF;
        HeapTupleHeaderSetXvac(old_tup->t_data, myXID);

        /* clear PD_ALL_VISIBLE flags */
        if (PageIsAllVisible(old_page))
        {
                all_visible_cleared = true;
                PageClearAllVisible(old_page);
        }
        if (PageIsAllVisible(dst_page))
        {
                all_visible_cleared_new = true;
                PageClearAllVisible(dst_page);
        }

        MarkBufferDirty(dst_buf);
        MarkBufferDirty(old_buf);

        /* XLOG stuff */
        if (!rel->rd_istemp)
        {
                XLogRecPtr      recptr = log_heap_move(rel, old_buf, old_tup->t_self,
                                                                                   dst_buf, &newtup,
                                                                                   all_visible_cleared,
                                                                                   all_visible_cleared_new);

                PageSetLSN(old_page, recptr);
                PageSetTLI(old_page, ThisTimeLineID);
                PageSetLSN(dst_page, recptr);
                PageSetTLI(dst_page, ThisTimeLineID);
        }

        END_CRIT_SECTION();

        dst_vacpage->free = PageGetFreeSpaceWithFillFactor(rel, dst_page);
        LockBuffer(dst_buf, BUFFER_LOCK_UNLOCK);
        LockBuffer(old_buf, BUFFER_LOCK_UNLOCK);

        dst_vacpage->offsets_used++;

        /* Clear bits in visibility map */
        if (all_visible_cleared)
                visibilitymap_clear(rel, BufferGetBlockNumber(old_buf));
        if (all_visible_cleared_new)
                visibilitymap_clear(rel, BufferGetBlockNumber(dst_buf));

        /* insert index' tuples if needed */
        if (ec->resultRelInfo->ri_NumIndices > 0)
        {
                ExecStoreTuple(&newtup, ec->slot, InvalidBuffer, false);
                ExecInsertIndexTuples(ec->slot, &(newtup.t_self), ec->estate, true);
                ResetPerTupleExprContext(ec->estate);
        }
}

/*
 *      update_hint_bits() -- update hint bits in destination pages
 *
 * Scan all the pages that we moved tuples onto and update tuple status bits.
 * This is not really necessary, but it will save time for future transactions
 * examining these tuples.
 *
 * This pass guarantees that all HEAP_MOVED_IN tuples are marked as
 * XMIN_COMMITTED, so that future tqual tests won't need to check their XVAC.
 *
 * BUT NOTICE that this code fails to clear HEAP_MOVED_OFF tuples from
 * pages that were move source pages but not move dest pages.  The bulk
 * of the move source pages will be physically truncated from the relation,
 * and the last page remaining in the rel will be fixed separately in
 * repair_frag(), so the only cases where a MOVED_OFF tuple won't get its
 * hint bits updated are tuples that are moved as part of a chain and were
 * on pages that were not either move destinations nor at the end of the rel.
 * To completely ensure that no MOVED_OFF tuples remain unmarked, we'd have
 * to remember and revisit those pages too.
 *
 * One wonders whether it wouldn't be better to skip this work entirely,
 * and let the tuple status updates happen someplace that's not holding an
 * exclusive lock on the relation.
 */
static void
update_hint_bits(Relation rel, VacPageList fraged_pages, int num_fraged_pages,
                                 BlockNumber last_move_dest_block, int num_moved)
{
        TransactionId myXID = GetCurrentTransactionId();
        int                     checked_moved = 0;
        int                     i;
        VacPage    *curpage;

        for (i = 0, curpage = fraged_pages->pagedesc;
                 i < num_fraged_pages;
                 i++, curpage++)
        {
                Buffer          buf;
                Page            page;
                OffsetNumber max_offset;
                OffsetNumber off;
                int                     num_tuples = 0;

                vacuum_delay_point();

                if ((*curpage)->blkno > last_move_dest_block)
                        break;                          /* no need to scan any further */
                if ((*curpage)->offsets_used == 0)
                        continue;                       /* this page was never used as a move dest */
                buf = ReadBufferExtended(rel, MAIN_FORKNUM, (*curpage)->blkno,
                                                                 RBM_NORMAL, vac_strategy);
                LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
                page = BufferGetPage(buf);
                max_offset = PageGetMaxOffsetNumber(page);
                for (off = FirstOffsetNumber;
                         off <= max_offset;
                         off = OffsetNumberNext(off))
                {
                        ItemId          itemid = PageGetItemId(page, off);
                        HeapTupleHeader htup;

                        if (!ItemIdIsUsed(itemid))
                                continue;
                        /* Shouldn't be any DEAD or REDIRECT items anymore */
                        Assert(ItemIdIsNormal(itemid));

                        htup = (HeapTupleHeader) PageGetItem(page, itemid);
                        if (htup->t_infomask & HEAP_XMIN_COMMITTED)
                                continue;

                        /*
                         * Here we may see either MOVED_OFF or MOVED_IN tuples.
                         */
                        if (!(htup->t_infomask & HEAP_MOVED))
                                elog(ERROR, "HEAP_MOVED_OFF/HEAP_MOVED_IN was expected");
                        if (HeapTupleHeaderGetXvac(htup) != myXID)
                                elog(ERROR, "invalid XVAC in tuple header");

                        if (htup->t_infomask & HEAP_MOVED_IN)
                        {
                                htup->t_infomask |= HEAP_XMIN_COMMITTED;
                                htup->t_infomask &= ~HEAP_MOVED;
                                num_tuples++;
                        }
                        else
                                htup->t_infomask |= HEAP_XMIN_INVALID;
                }
                MarkBufferDirty(buf);
                UnlockReleaseBuffer(buf);
                Assert((*curpage)->offsets_used == num_tuples);
                checked_moved += num_tuples;
        }
        Assert(num_moved == checked_moved);
}

/*
 *      vacuum_heap() -- free dead tuples
 *
 *              This routine marks dead tuples as unused and truncates relation
 *              if there are "empty" end-blocks.
 */
static void
vacuum_heap(VRelStats *vacrelstats, Relation onerel, VacPageList vacuum_pages)
{
        Buffer          buf;
        VacPage    *vacpage;
        BlockNumber relblocks;
        int                     nblocks;
        int                     i;

        nblocks = vacuum_pages->num_pages;
        nblocks -= vacuum_pages->empty_end_pages;       /* nothing to do with them */

        for (i = 0, vacpage = vacuum_pages->pagedesc; i < nblocks; i++, vacpage++)
        {
                vacuum_delay_point();

                if ((*vacpage)->offsets_free > 0)
                {
                        buf = ReadBufferExtended(onerel, MAIN_FORKNUM, (*vacpage)->blkno,
                                                                         RBM_NORMAL, vac_strategy);
                        LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
                        vacuum_page(vacrelstats, onerel, buf, *vacpage);
                        UnlockReleaseBuffer(buf);
                }
        }

        /* Truncate relation if there are some empty end-pages */
        Assert(vacrelstats->rel_pages >= vacuum_pages->empty_end_pages);
        if (vacuum_pages->empty_end_pages > 0)
        {
                relblocks = vacrelstats->rel_pages - vacuum_pages->empty_end_pages;
                ereport(elevel,
                                (errmsg("\"%s\": truncated %u to %u pages",
                                                RelationGetRelationName(onerel),
                                                vacrelstats->rel_pages, relblocks)));
                RelationTruncate(onerel, relblocks);

                /* force relcache inval so all backends reset their rd_targblock */
                CacheInvalidateRelcache(onerel);

                vacrelstats->rel_pages = relblocks;             /* set new number of blocks */
        }
}

/*
 *      vacuum_page() -- free dead tuples on a page
 *                                       and repair its fragmentation.
 *
 * Caller must hold pin and lock on buffer.
 */
static void
vacuum_page(VRelStats *vacrelstats, Relation onerel, Buffer buffer, VacPage vacpage)
{
        Page            page = BufferGetPage(buffer);
        int                     i;

        /* There shouldn't be any tuples moved onto the page yet! */
        Assert(vacpage->offsets_used == 0);

        START_CRIT_SECTION();

        for (i = 0; i < vacpage->offsets_free; i++)
        {
                ItemId          itemid = PageGetItemId(page, vacpage->offsets[i]);

                ItemIdSetUnused(itemid);
        }

        PageRepairFragmentation(page);

        MarkBufferDirty(buffer);

        /* XLOG stuff */
        if (!onerel->rd_istemp)
        {
                XLogRecPtr      recptr;

                recptr = log_heap_clean(onerel, buffer,
                                                                NULL, 0, NULL, 0,
                                                                vacpage->offsets, vacpage->offsets_free,
                                                                vacrelstats->latestRemovedXid, false);
                PageSetLSN(page, recptr);
                PageSetTLI(page, ThisTimeLineID);
        }

        END_CRIT_SECTION();
}

/*
 *      scan_index() -- scan one index relation to update pg_class statistics.
 *
 * We use this when we have no deletions to do.
 */
static void
scan_index(Relation indrel, double num_tuples)
{
        IndexBulkDeleteResult *stats;
        IndexVacuumInfo ivinfo;
        PGRUsage        ru0;

        pg_rusage_init(&ru0);

        ivinfo.index = indrel;
        ivinfo.vacuum_full = true;
        ivinfo.analyze_only = false;
        ivinfo.estimated_count = false;
        ivinfo.message_level = elevel;
        ivinfo.num_heap_tuples = num_tuples;
        ivinfo.strategy = vac_strategy;

        stats = index_vacuum_cleanup(&ivinfo, NULL);

        if (!stats)
                return;

        /*
         * Now update statistics in pg_class, but only if the index says the count
         * is accurate.
         */
        if (!stats->estimated_count)
                vac_update_relstats(indrel,
                                                        stats->num_pages, stats->num_index_tuples,
                                                        false, InvalidTransactionId);

        ereport(elevel,
                        (errmsg("index \"%s\" now contains %.0f row versions in %u pages",
                                        RelationGetRelationName(indrel),
                                        stats->num_index_tuples,
                                        stats->num_pages),
        errdetail("%u index pages have been deleted, %u are currently reusable.\n"
                          "%s.",
                          stats->pages_deleted, stats->pages_free,
                          pg_rusage_show(&ru0))));

        /*
         * Check for tuple count mismatch.      If the index is partial, then it's OK
         * for it to have fewer tuples than the heap; else we got trouble.
         */
        if (!stats->estimated_count &&
                stats->num_index_tuples != num_tuples)
        {
                if (stats->num_index_tuples > num_tuples ||
                        !vac_is_partial_index(indrel))
                        ereport(WARNING,
                                        (errmsg("index \"%s\" contains %.0f row versions, but table contains %.0f row versions",
                                                        RelationGetRelationName(indrel),
                                                        stats->num_index_tuples, num_tuples),
                                         errhint("Rebuild the index with REINDEX.")));
        }

        pfree(stats);
}

/*
 *      vacuum_index() -- vacuum one index relation.
 *
 *              Vpl is the VacPageList of the heap we're currently vacuuming.
 *              It's locked. Indrel is an index relation on the vacuumed heap.
 *
 *              We don't bother to set locks on the index relation here, since
 *              the parent table is exclusive-locked already.
 *
 *              Finally, we arrange to update the index relation's statistics in
 *              pg_class.
 */
static void
vacuum_index(VacPageList vacpagelist, Relation indrel,
                         double num_tuples, int keep_tuples)
{
        IndexBulkDeleteResult *stats;
        IndexVacuumInfo ivinfo;
        PGRUsage        ru0;

        pg_rusage_init(&ru0);

        ivinfo.index = indrel;
        ivinfo.vacuum_full = true;
        ivinfo.analyze_only = false;
        ivinfo.estimated_count = false;
        ivinfo.message_level = elevel;
        ivinfo.num_heap_tuples = num_tuples + keep_tuples;
        ivinfo.strategy = vac_strategy;

        /* Do bulk deletion */
        stats = index_bulk_delete(&ivinfo, NULL, tid_reaped, (void *) vacpagelist);

        /* Do post-VACUUM cleanup */
        stats = index_vacuum_cleanup(&ivinfo, stats);

        if (!stats)
                return;

        /*
         * Now update statistics in pg_class, but only if the index says the count
         * is accurate.
         */
        if (!stats->estimated_count)
                vac_update_relstats(indrel,
                                                        stats->num_pages, stats->num_index_tuples,
                                                        false, InvalidTransactionId);

        ereport(elevel,
                        (errmsg("index \"%s\" now contains %.0f row versions in %u pages",
                                        RelationGetRelationName(indrel),
                                        stats->num_index_tuples,
                                        stats->num_pages),
                         errdetail("%.0f index row versions were removed.\n"
                         "%u index pages have been deleted, %u are currently reusable.\n"
                                           "%s.",
                                           stats->tuples_removed,
                                           stats->pages_deleted, stats->pages_free,
                                           pg_rusage_show(&ru0))));

        /*
         * Check for tuple count mismatch.      If the index is partial, then it's OK
         * for it to have fewer tuples than the heap; else we got trouble.
         */
        if (!stats->estimated_count &&
                stats->num_index_tuples != num_tuples + keep_tuples)
        {
                if (stats->num_index_tuples > num_tuples + keep_tuples ||
                        !vac_is_partial_index(indrel))
                        ereport(WARNING,
                                        (errmsg("index \"%s\" contains %.0f row versions, but table contains %.0f row versions",
                                                        RelationGetRelationName(indrel),
                                                  stats->num_index_tuples, num_tuples + keep_tuples),
                                         errhint("Rebuild the index with REINDEX.")));
        }

        pfree(stats);
}

/*
 *      tid_reaped() -- is a particular tid reaped?
 *
 *              This has the right signature to be an IndexBulkDeleteCallback.
 *
 *              vacpagelist->VacPage_array is sorted in right order.
 */
static bool
tid_reaped(ItemPointer itemptr, void *state)
{
        VacPageList vacpagelist = (VacPageList) state;
        OffsetNumber ioffno;
        OffsetNumber *voff;
        VacPage         vp,
                           *vpp;
        VacPageData vacpage;

        vacpage.blkno = ItemPointerGetBlockNumber(itemptr);
        ioffno = ItemPointerGetOffsetNumber(itemptr);

        vp = &vacpage;
        vpp = (VacPage *) vac_bsearch((void *) &vp,
                                                                  (void *) (vacpagelist->pagedesc),
                                                                  vacpagelist->num_pages,
                                                                  sizeof(VacPage),
                                                                  vac_cmp_blk);

        if (vpp == NULL)
                return false;

        /* ok - we are on a partially or fully reaped page */
        vp = *vpp;

        if (vp->offsets_free == 0)
        {
                /* this is EmptyPage, so claim all tuples on it are reaped!!! */
                return true;
        }

        voff = (OffsetNumber *) vac_bsearch((void *) &ioffno,
                                                                                (void *) (vp->offsets),
                                                                                vp->offsets_free,
                                                                                sizeof(OffsetNumber),
                                                                                vac_cmp_offno);

        if (voff == NULL)
                return false;

        /* tid is reaped */
        return true;
}

/*
 * Update the Free Space Map with the info we now have about free space in
 * the relation.
 */
static void
vac_update_fsm(Relation onerel, VacPageList fraged_pages,
                           BlockNumber rel_pages)
{
        int                     nPages = fraged_pages->num_pages;
        VacPage    *pagedesc = fraged_pages->pagedesc;
        int                     i;

        for (i = 0; i < nPages; i++)
        {
                /*
                 * fraged_pages may contain entries for pages that we later decided to
                 * truncate from the relation; don't enter them into the free space
                 * map!
                 */
                if (pagedesc[i]->blkno >= rel_pages)
                        break;

                RecordPageWithFreeSpace(onerel, pagedesc[i]->blkno, pagedesc[i]->free);
        }

}

/* Copy a VacPage structure */
static VacPage
copy_vac_page(VacPage vacpage)
{
        VacPage         newvacpage;

        /* allocate a VacPageData entry */
        newvacpage = (VacPage) palloc(sizeof(VacPageData) +
                                                           vacpage->offsets_free * sizeof(OffsetNumber));

        /* fill it in */
        if (vacpage->offsets_free > 0)
                memcpy(newvacpage->offsets, vacpage->offsets,
                           vacpage->offsets_free * sizeof(OffsetNumber));
        newvacpage->blkno = vacpage->blkno;
        newvacpage->free = vacpage->free;
        newvacpage->offsets_used = vacpage->offsets_used;
        newvacpage->offsets_free = vacpage->offsets_free;

        return newvacpage;
}

/*
 * Add a VacPage pointer to a VacPageList.
 *
 *              As a side effect of the way that scan_heap works,
 *              higher pages come after lower pages in the array
 *              (and highest tid on a page is last).
 */
static void
vpage_insert(VacPageList vacpagelist, VacPage vpnew)
{
#define PG_NPAGEDESC 1024

        /* allocate a VacPage entry if needed */
        if (vacpagelist->num_pages == 0)
        {
                vacpagelist->pagedesc = (VacPage *) palloc(PG_NPAGEDESC * sizeof(VacPage));
                vacpagelist->num_allocated_pages = PG_NPAGEDESC;
        }
        else if (vacpagelist->num_pages >= vacpagelist->num_allocated_pages)
        {
                vacpagelist->num_allocated_pages *= 2;
                vacpagelist->pagedesc = (VacPage *) repalloc(vacpagelist->pagedesc, vacpagelist->num_allocated_pages * sizeof(VacPage));
        }
        vacpagelist->pagedesc[vacpagelist->num_pages] = vpnew;
        (vacpagelist->num_pages)++;
}

/*
 * vac_bsearch: just like standard C library routine bsearch(),
 * except that we first test to see whether the target key is outside
 * the range of the table entries.      This case is handled relatively slowly
 * by the normal binary search algorithm (ie, no faster than any other key)
 * but it occurs often enough in VACUUM to be worth optimizing.
 */
static void *
vac_bsearch(const void *key, const void *base,
                        size_t nelem, size_t size,
                        int (*compar) (const void *, const void *))
{
        int                     res;
        const void *last;

        if (nelem == 0)
                return NULL;
        res = compar(key, base);
        if (res < 0)
                return NULL;
        if (res == 0)
                return (void *) base;
        if (nelem > 1)
        {
                last = (const void *) ((const char *) base + (nelem - 1) * size);
                res = compar(key, last);
                if (res > 0)
                        return NULL;
                if (res == 0)
                        return (void *) last;
        }
        if (nelem <= 2)
                return NULL;                    /* already checked 'em all */
        return bsearch(key, base, nelem, size, compar);
}

/*
 * Comparator routines for use with qsort() and bsearch().
 */
static int
vac_cmp_blk(const void *left, const void *right)
{
        BlockNumber lblk,
                                rblk;

        lblk = (*((VacPage *) left))->blkno;
        rblk = (*((VacPage *) right))->blkno;

        if (lblk < rblk)
                return -1;
        if (lblk == rblk)
                return 0;
        return 1;
}

static int
vac_cmp_offno(const void *left, const void *right)
{
        if (*(OffsetNumber *) left < *(OffsetNumber *) right)
                return -1;
        if (*(OffsetNumber *) left == *(OffsetNumber *) right)
                return 0;
        return 1;
}

static int
vac_cmp_vtlinks(const void *left, const void *right)
{
        if (((VTupleLink) left)->new_tid.ip_blkid.bi_hi <
                ((VTupleLink) right)->new_tid.ip_blkid.bi_hi)
                return -1;
        if (((VTupleLink) left)->new_tid.ip_blkid.bi_hi >
                ((VTupleLink) right)->new_tid.ip_blkid.bi_hi)
                return 1;
        /* bi_hi-es are equal */
        if (((VTupleLink) left)->new_tid.ip_blkid.bi_lo <
                ((VTupleLink) right)->new_tid.ip_blkid.bi_lo)
                return -1;
        if (((VTupleLink) left)->new_tid.ip_blkid.bi_lo >
                ((VTupleLink) right)->new_tid.ip_blkid.bi_lo)
                return 1;
        /* bi_lo-es are equal */
        if (((VTupleLink) left)->new_tid.ip_posid <
                ((VTupleLink) right)->new_tid.ip_posid)
                return -1;
        if (((VTupleLink) left)->new_tid.ip_posid >
                ((VTupleLink) right)->new_tid.ip_posid)
                return 1;
        return 0;
}


/*
 * Open all the indexes of the given relation, obtaining the specified kind
 * of lock on each.  Return an array of Relation pointers for the indexes
 * into *Irel, and the number of indexes into *nindexes.
 */
void
vac_open_indexes(Relation relation, LOCKMODE lockmode,
                                 int *nindexes, Relation **Irel)
{
        List       *indexoidlist;
        ListCell   *indexoidscan;
        int                     i;

        Assert(lockmode != NoLock);

        indexoidlist = RelationGetIndexList(relation);

        *nindexes = list_length(indexoidlist);

        if (*nindexes > 0)
                *Irel = (Relation *) palloc(*nindexes * sizeof(Relation));
        else
                *Irel = NULL;

        i = 0;
        foreach(indexoidscan, indexoidlist)
        {
                Oid                     indexoid = lfirst_oid(indexoidscan);

                (*Irel)[i++] = index_open(indexoid, lockmode);
        }

        list_free(indexoidlist);
}

/*
 * Release the resources acquired by vac_open_indexes.  Optionally release
 * the locks (say NoLock to keep 'em).
 */
void
vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode)
{
        if (Irel == NULL)
                return;

        while (nindexes--)
        {
                Relation        ind = Irel[nindexes];

                index_close(ind, lockmode);
        }
        pfree(Irel);
}


/*
 * Is an index partial (ie, could it contain fewer tuples than the heap?)
 */
bool
vac_is_partial_index(Relation indrel)
{
        /*
         * If the index's AM doesn't support nulls, it's partial for our purposes
         */
        if (!indrel->rd_am->amindexnulls)
                return true;

        /* Otherwise, look to see if there's a partial-index predicate */
        if (!heap_attisnull(indrel->rd_indextuple, Anum_pg_index_indpred))
                return true;

        return false;
}


static bool
enough_space(VacPage vacpage, Size len)
{
        len = MAXALIGN(len);

        if (len > vacpage->free)
                return false;

        /* if there are free itemid(s) and len <= free_space... */
        if (vacpage->offsets_used < vacpage->offsets_free)
                return true;

        /* noff_used >= noff_free and so we'll have to allocate new itemid */
        if (len + sizeof(ItemIdData) <= vacpage->free)
                return true;

        return false;
}

static Size
PageGetFreeSpaceWithFillFactor(Relation relation, Page page)
{
        /*
         * It is correct to use PageGetExactFreeSpace() here, *not*
         * PageGetHeapFreeSpace().      This is because (a) we do our own, exact
         * accounting for whether line pointers must be added, and (b) we will
         * recycle any LP_DEAD line pointers before starting to add rows to a
         * page, but that may not have happened yet at the time this function is
         * applied to a page, which means PageGetHeapFreeSpace()'s protection
         * against too many line pointers on a page could fire incorrectly.  We do
         * not need that protection here: since VACUUM FULL always recycles all
         * dead line pointers first, it'd be physically impossible to insert more
         * than MaxHeapTuplesPerPage tuples anyway.
         */
        Size            freespace = PageGetExactFreeSpace(page);
        Size            targetfree;

        targetfree = RelationGetTargetPageFreeSpace(relation,
                                                                                                HEAP_DEFAULT_FILLFACTOR);
        if (freespace > targetfree)
                return freespace - targetfree;
        else
                return 0;
}

/*
 * vacuum_delay_point --- check for interrupts and cost-based delay.
 *
 * This should be called in each major loop of VACUUM processing,
 * typically once per page processed.
 */
void
vacuum_delay_point(void)
{
        /* Always check for interrupts */
        CHECK_FOR_INTERRUPTS();

        /* Nap if appropriate */
        if (VacuumCostActive && !InterruptPending &&
                VacuumCostBalance >= VacuumCostLimit)
        {
                int                     msec;

                msec = VacuumCostDelay * VacuumCostBalance / VacuumCostLimit;
                if (msec > VacuumCostDelay * 4)
                        msec = VacuumCostDelay * 4;

                pg_usleep(msec * 1000L);

                VacuumCostBalance = 0;

                /* update balance values for workers */
                AutoVacuumUpdateDelay();

                /* Might have gotten an interrupt while sleeping */
                CHECK_FOR_INTERRUPTS();
        }
}