heap_surgery.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "access/visibilitymap.h"
#include "access/xloginsert.h"
#include "catalog/pg_am_d.h"
#include "catalog/pg_control.h"
#include "miscadmin.h"
#include "storage/bufmgr.h"
#include "utils/acl.h"
#include "utils/array.h"
#include "utils/rel.h"

Include dependency graph for heap_surgery.c:

Go to the source code of this file.

Typedefs
typedef enum HeapTupleForceOption	HeapTupleForceOption

Enumerations
enum	HeapTupleForceOption { HEAP_FORCE_KILL , HEAP_FORCE_FREEZE }

Functions
	PG_MODULE_MAGIC_EXT (.name="pg_surgery",.version=PG_VERSION)
	PG_FUNCTION_INFO_V1 (heap_force_kill)
	PG_FUNCTION_INFO_V1 (heap_force_freeze)
static int32	tidcmp (const void *a, const void *b)
static Datum	heap_force_common (FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
static void	sanity_check_tid_array (ArrayType *ta, int *ntids)
static BlockNumber	find_tids_one_page (ItemPointer tids, int ntids, OffsetNumber *next_start_ptr)
Datum	heap_force_kill (PG_FUNCTION_ARGS)
Datum	heap_force_freeze (PG_FUNCTION_ARGS)

Typedef Documentation

HeapTupleForceOption

typedef enum HeapTupleForceOption HeapTupleForceOption

Enumeration Type Documentation

HeapTupleForceOption

enum HeapTupleForceOption

Enumerator
HEAP_FORCE_KILL
HEAP_FORCE_FREEZE

Definition at line 33 of file heap_surgery.c.

{
    HEAP_FORCE_KILL,
    HEAP_FORCE_FREEZE,
} HeapTupleForceOption;

Function Documentation

find_tids_one_page()

static BlockNumber find_tids_one_page ( ItemPointer  tids, int  ntids, OffsetNumber *  next_start_ptr  )

static

Definition at line 416 of file heap_surgery.c.

{
    int         i;
    BlockNumber prev_blkno,
                blkno;
 
    prev_blkno = blkno = InvalidBlockNumber;
 
    for (i = *next_start_ptr; i < ntids; i++)
    {
        ItemPointerData tid = tids[i];
 
        blkno = ItemPointerGetBlockNumberNoCheck(&tid);
 
        if (i == *next_start_ptr)
            prev_blkno = blkno;
 
        if (prev_blkno != blkno)
            break;
    }
 
    *next_start_ptr = i;
    return prev_blkno;
}

References fb(), i, InvalidBlockNumber, and ItemPointerGetBlockNumberNoCheck().

Referenced by heap_force_common().

heap_force_common()

static Datum heap_force_common ( FunctionCallInfo  fcinfo, HeapTupleForceOption  heap_force_opt  )

static

Definition at line 86 of file heap_surgery.c.

{
    Oid         relid = PG_GETARG_OID(0);
    ArrayType  *ta = PG_GETARG_ARRAYTYPE_P_COPY(1);
    ItemPointer tids;
    int         ntids,
                nblocks;
    Relation    rel;
    OffsetNumber curr_start_ptr,
                next_start_ptr;
    bool        include_this_tid[MaxHeapTuplesPerPage];
 
    if (RecoveryInProgress())
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("recovery is in progress"),
                 errhint("Heap surgery functions cannot be executed during recovery.")));
 
    /* Check inputs. */
    sanity_check_tid_array(ta, &ntids);
 
    rel = relation_open(relid, RowExclusiveLock);
 
    /*
     * Check target relation.
     */
    if (!RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cannot operate on relation \"%s\"",
                        RelationGetRelationName(rel)),
                 errdetail_relkind_not_supported(rel->rd_rel->relkind)));
 
    if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("only heap AM is supported")));
 
    /* Must be owner of the table or superuser. */
    if (!object_ownercheck(RelationRelationId, RelationGetRelid(rel), GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER,
                       get_relkind_objtype(rel->rd_rel->relkind),
                       RelationGetRelationName(rel));
 
    tids = ((ItemPointer) ARR_DATA_PTR(ta));
 
    /*
     * If there is more than one TID in the array, sort them so that we can
     * easily fetch all the TIDs belonging to one particular page from the
     * array.
     */
    if (ntids > 1)
        qsort(tids, ntids, sizeof(ItemPointerData), tidcmp);
 
    curr_start_ptr = next_start_ptr = 0;
    nblocks = RelationGetNumberOfBlocks(rel);
 
    /*
     * Loop, performing the necessary actions for each block.
     */
    while (next_start_ptr != ntids)
    {
        Buffer      buf;
        Buffer      vmbuf = InvalidBuffer;
        bool        unlock_vmbuf = false;
        Page        page;
        BlockNumber blkno;
        OffsetNumber curoff;
        OffsetNumber maxoffset;
        int         i;
        bool        did_modify_page = false;
        bool        did_modify_vm = false;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * Find all the TIDs belonging to one particular page starting from
         * next_start_ptr and process them one by one.
         */
        blkno = find_tids_one_page(tids, ntids, &next_start_ptr);
 
        /* Check whether the block number is valid. */
        if (blkno >= nblocks)
        {
            /* Update the current_start_ptr before moving to the next page. */
            curr_start_ptr = next_start_ptr;
 
            ereport(NOTICE,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("skipping block %u for relation \"%s\" because the block number is out of range",
                            blkno, RelationGetRelationName(rel))));
            continue;
        }
 
        buf = ReadBuffer(rel, blkno);
        LockBufferForCleanup(buf);
 
        page = BufferGetPage(buf);
 
        maxoffset = PageGetMaxOffsetNumber(page);
 
        /*
         * Figure out which TIDs we are going to process and which ones we are
         * going to skip.
         */
        memset(include_this_tid, 0, sizeof(include_this_tid));
        for (i = curr_start_ptr; i < next_start_ptr; i++)
        {
            OffsetNumber offno = ItemPointerGetOffsetNumberNoCheck(&tids[i]);
            ItemId      itemid;
 
            /* Check whether the offset number is valid. */
            if (offno == InvalidOffsetNumber || offno > maxoffset)
            {
                ereport(NOTICE,
                        errmsg("skipping tid (%u, %u) for relation \"%s\" because the item number is out of range",
                               blkno, offno, RelationGetRelationName(rel)));
                continue;
            }
 
            itemid = PageGetItemId(page, offno);
 
            /* Only accept an item ID that is used. */
            if (ItemIdIsRedirected(itemid))
            {
                ereport(NOTICE,
                        errmsg("skipping tid (%u, %u) for relation \"%s\" because it redirects to item %u",
                               blkno, offno, RelationGetRelationName(rel),
                               ItemIdGetRedirect(itemid)));
                continue;
            }
            else if (ItemIdIsDead(itemid))
            {
                ereport(NOTICE,
                        (errmsg("skipping tid (%u, %u) for relation \"%s\" because it is marked dead",
                                blkno, offno, RelationGetRelationName(rel))));
                continue;
            }
            else if (!ItemIdIsUsed(itemid))
            {
                ereport(NOTICE,
                        (errmsg("skipping tid (%u, %u) for relation \"%s\" because it is marked unused",
                                blkno, offno, RelationGetRelationName(rel))));
                continue;
            }
 
            /* Mark it for processing. */
            Assert(offno <= MaxHeapTuplesPerPage);
            include_this_tid[offno - 1] = true;
        }
 
        /*
         * Before entering the critical section, pin and lock the visibility
         * map page if it appears to be necessary.
         */
        if (heap_force_opt == HEAP_FORCE_KILL && PageIsAllVisible(page))
        {
            visibilitymap_pin(rel, blkno, &vmbuf);
            LockBuffer(vmbuf, BUFFER_LOCK_EXCLUSIVE);
            unlock_vmbuf = true;
        }
 
        /* No ereport(ERROR) from here until all the changes are logged. */
        START_CRIT_SECTION();
 
        for (curoff = FirstOffsetNumber; curoff <= maxoffset;
             curoff = OffsetNumberNext(curoff))
        {
            ItemId      itemid;
 
            if (!include_this_tid[curoff - 1])
                continue;
 
            itemid = PageGetItemId(page, curoff);
            Assert(ItemIdIsNormal(itemid));
 
            did_modify_page = true;
 
            if (heap_force_opt == HEAP_FORCE_KILL)
            {
                ItemIdSetDead(itemid);
 
                /*
                 * If the page is marked all-visible, we must clear
                 * PD_ALL_VISIBLE flag on the page header and an all-visible
                 * bit on the visibility map corresponding to the page.
                 */
                if (PageIsAllVisible(page))
                {
                    if (visibilitymap_clear(rel->rd_locator, blkno, vmbuf,
                                            VISIBILITYMAP_VALID_BITS))
                        did_modify_vm = true;
 
                    PageClearAllVisible(page);
                }
            }
            else
            {
                HeapTupleHeader htup;
 
                Assert(heap_force_opt == HEAP_FORCE_FREEZE);
 
                htup = (HeapTupleHeader) PageGetItem(page, itemid);
 
                /*
                 * Reset all visibility-related fields of the tuple. This
                 * logic should mimic heap_execute_freeze_tuple(), but we
                 * choose to reset xmin and ctid just to be sure that no
                 * potentially-garbled data is left behind.
                 */
                ItemPointerSet(&htup->t_ctid, blkno, curoff);
                HeapTupleHeaderSetXmin(htup, FrozenTransactionId);
                HeapTupleHeaderSetXmax(htup, InvalidTransactionId);
                if (htup->t_infomask & HEAP_MOVED)
                {
                    if (htup->t_infomask & HEAP_MOVED_OFF)
                        HeapTupleHeaderSetXvac(htup, InvalidTransactionId);
                    else
                        HeapTupleHeaderSetXvac(htup, FrozenTransactionId);
                }
 
                /*
                 * Clear all the visibility-related bits of this tuple and
                 * mark it as frozen. Also, get rid of HOT_UPDATED and
                 * KEYS_UPDATES bits.
                 */
                htup->t_infomask &= ~HEAP_XACT_MASK;
                htup->t_infomask |= (HEAP_XMIN_FROZEN | HEAP_XMAX_INVALID);
                htup->t_infomask2 &= ~HEAP_HOT_UPDATED;
                htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
            }
        }
 
        /*
         * If the page was modified, only then, we mark the buffer dirty or do
         * the WAL logging.
         */
        if (did_modify_page)
        {
            /* Mark buffer dirty before we write WAL. */
            MarkBufferDirty(buf);
 
            /* XLOG stuff */
            if (RelationNeedsWAL(rel))
            {
                XLogRecPtr  recptr;
 
                XLogBeginInsert();
                XLogRegisterBuffer(0, buf, REGBUF_STANDARD | REGBUF_FORCE_IMAGE);
                /* Include the VM page if it was modified */
                if (did_modify_vm)
                    XLogRegisterBuffer(1, vmbuf, REGBUF_FORCE_IMAGE);
                recptr = XLogInsert(RM_XLOG_ID, XLOG_FPI);
                if (did_modify_vm)
                    PageSetLSN(BufferGetPage(vmbuf), recptr);
                PageSetLSN(BufferGetPage(buf), recptr);
            }
        }
 
        END_CRIT_SECTION();
 
        UnlockReleaseBuffer(buf);
 
        if (unlock_vmbuf)
            LockBuffer(vmbuf, BUFFER_LOCK_UNLOCK);
 
        if (BufferIsValid(vmbuf))
            ReleaseBuffer(vmbuf);
 
        /* Update the current_start_ptr before moving to the next page. */
        curr_start_ptr = next_start_ptr;
    }
 
    relation_close(rel, RowExclusiveLock);
 
    pfree(ta);
 
    PG_RETURN_VOID();
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, ARR_DATA_PTR, Assert, buf, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage(), BufferIsValid(), CHECK_FOR_INTERRUPTS, END_CRIT_SECTION, ereport, errcode(), errdetail_relkind_not_supported(), errhint(), errmsg, ERROR, fb(), find_tids_one_page(), FirstOffsetNumber, FrozenTransactionId, get_relkind_objtype(), GetUserId(), HEAP_FORCE_FREEZE, HEAP_FORCE_KILL, HEAP_MOVED, HEAP_MOVED_OFF, HEAP_XMAX_INVALID, HEAP_XMIN_FROZEN, HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), HeapTupleHeaderSetXvac(), i, InvalidBuffer, InvalidOffsetNumber, InvalidTransactionId, ItemIdGetRedirect, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemIdSetDead, ItemPointerGetOffsetNumberNoCheck(), ItemPointerSet(), LockBuffer(), LockBufferForCleanup(), MarkBufferDirty(), MaxHeapTuplesPerPage, NOTICE, object_ownercheck(), OffsetNumberNext, PageClearAllVisible(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageIsAllVisible(), PageSetLSN(), pfree(), PG_GETARG_ARRAYTYPE_P_COPY, PG_GETARG_OID, PG_RETURN_VOID, qsort, RelationData::rd_locator, RelationData::rd_rel, ReadBuffer(), RecoveryInProgress(), REGBUF_FORCE_IMAGE, REGBUF_STANDARD, relation_close(), relation_open(), RelationGetNumberOfBlocks, RelationGetRelationName, RelationGetRelid, RelationNeedsWAL, ReleaseBuffer(), RowExclusiveLock, sanity_check_tid_array(), START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, tidcmp(), UnlockReleaseBuffer(), visibilitymap_clear(), visibilitymap_pin(), VISIBILITYMAP_VALID_BITS, XLOG_FPI, XLogBeginInsert(), XLogInsert(), and XLogRegisterBuffer().

Referenced by heap_force_freeze(), and heap_force_kill().

heap_force_freeze()

Datum heap_force_freeze

(

PG_FUNCTION_ARGS

)

Definition at line 74 of file heap_surgery.c.

{
    PG_RETURN_DATUM(heap_force_common(fcinfo, HEAP_FORCE_FREEZE));
}

References heap_force_common(), HEAP_FORCE_FREEZE, and PG_RETURN_DATUM.

heap_force_kill()

Datum heap_force_kill

(

PG_FUNCTION_ARGS

)

Definition at line 59 of file heap_surgery.c.

{
    PG_RETURN_DATUM(heap_force_common(fcinfo, HEAP_FORCE_KILL));
}

References heap_force_common(), HEAP_FORCE_KILL, and PG_RETURN_DATUM.

PG_FUNCTION_INFO_V1() [1/2]

PG_FUNCTION_INFO_V1

(

heap_force_freeze

)

PG_FUNCTION_INFO_V1() [2/2]

PG_FUNCTION_INFO_V1

(

heap_force_kill

)

PG_MODULE_MAGIC_EXT()

PG_MODULE_MAGIC_EXT	(	.	name = "pg_surgery",
		.	version = PG_VERSION
	)

sanity_check_tid_array()

static void sanity_check_tid_array ( ArrayType *  ta, int *  ntids  )

static

Definition at line 391 of file heap_surgery.c.

{
    if (ARR_HASNULL(ta) && array_contains_nulls(ta))
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("array must not contain nulls")));
 
    if (ARR_NDIM(ta) > 1)
        ereport(ERROR,
                (errcode(ERRCODE_DATA_EXCEPTION),
                 errmsg("argument must be empty or one-dimensional array")));
 
    *ntids = ArrayGetNItems(ARR_NDIM(ta), ARR_DIMS(ta));
}

References ARR_DIMS, ARR_HASNULL, ARR_NDIM, array_contains_nulls(), ArrayGetNItems(), ereport, errcode(), errmsg, ERROR, and fb().

Referenced by heap_force_common().

tidcmp()

static int32 tidcmp ( const void *  a, const void *  b  )

static

Definition at line 375 of file heap_surgery.c.

{
    const ItemPointerData *iptr1 = a;
    const ItemPointerData *iptr2 = b;
 
    return ItemPointerCompare(iptr1, iptr2);
}

References a, b, fb(), and ItemPointerCompare().

Referenced by heap_force_common().