btreefuncs.c File Reference

#include "postgres.h"
#include "access/nbtree.h"
#include "access/relation.h"
#include "catalog/namespace.h"
#include "catalog/pg_am.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "pageinspect.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/rel.h"
#include "utils/varlena.h"

Include dependency graph for btreefuncs.c:

Go to the source code of this file.

Data Structures
struct	BTPageStat
struct	ua_page_stats
struct	ua_page_items

Macros
#define	IS_INDEX(r)   ((r)->rd_rel->relkind == RELKIND_INDEX)
#define	IS_BTREE(r)   ((r)->rd_rel->relam == BTREE_AM_OID)
#define	BT_METAP_COLS_V1_8   9

Typedefs
typedef struct BTPageStat	BTPageStat
typedef struct ua_page_stats	ua_page_stats
typedef struct ua_page_items	ua_page_items

Functions
	PG_FUNCTION_INFO_V1 (bt_metap)
	PG_FUNCTION_INFO_V1 (bt_page_items_1_9)
	PG_FUNCTION_INFO_V1 (bt_page_items)
	PG_FUNCTION_INFO_V1 (bt_page_items_bytea)
	PG_FUNCTION_INFO_V1 (bt_page_stats_1_9)
	PG_FUNCTION_INFO_V1 (bt_page_stats)
	PG_FUNCTION_INFO_V1 (bt_multi_page_stats)
static void	GetBTPageStatistics (BlockNumber blkno, Buffer buffer, BTPageStat *stat)
static void	check_relation_block_range (Relation rel, int64 blkno)
static void	bt_index_block_validate (Relation rel, int64 blkno)
static Datum	bt_page_stats_internal (PG_FUNCTION_ARGS, enum pageinspect_version ext_version)
Datum	bt_page_stats_1_9 (PG_FUNCTION_ARGS)
Datum	bt_page_stats (PG_FUNCTION_ARGS)
Datum	bt_multi_page_stats (PG_FUNCTION_ARGS)
static Datum	bt_page_print_tuples (ua_page_items *uargs)
static Datum	bt_page_items_internal (PG_FUNCTION_ARGS, enum pageinspect_version ext_version)
Datum	bt_page_items_1_9 (PG_FUNCTION_ARGS)
Datum	bt_page_items (PG_FUNCTION_ARGS)
Datum	bt_page_items_bytea (PG_FUNCTION_ARGS)
Datum	bt_metap (PG_FUNCTION_ARGS)

Macro Definition Documentation

BT_METAP_COLS_V1_8

#define BT_METAP_COLS_V1_8   9

Definition at line 827 of file btreefuncs.c.

IS_BTREE

#define IS_BTREE

(

r

)

((r)->rd_rel->relam == BTREE_AM_OID)

Definition at line 52 of file btreefuncs.c.

IS_INDEX

#define IS_INDEX

(

r

)

((r)->rd_rel->relkind == RELKIND_INDEX)

Definition at line 51 of file btreefuncs.c.

Typedef Documentation

BTPageStat

typedef struct BTPageStat BTPageStat

ua_page_items

typedef struct ua_page_items ua_page_items

ua_page_stats

typedef struct ua_page_stats ua_page_stats

Function Documentation

bt_index_block_validate()

static void bt_index_block_validate ( Relation  rel, int64  blkno  )

static

Definition at line 225 of file btreefuncs.c.

{
    if (!IS_INDEX(rel) || !IS_BTREE(rel))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a %s index",
                        RelationGetRelationName(rel), "btree")));
 
    /*
     * Reject attempts to read non-local temporary relations; we would be
     * likely to get wrong data since we have no visibility into the owning
     * session's local buffers.
     */
    if (RELATION_IS_OTHER_TEMP(rel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot access temporary tables of other sessions")));
 
    if (blkno == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("block 0 is a meta page")));
 
    check_relation_block_range(rel, blkno);
}

References check_relation_block_range(), ereport, errcode(), errmsg(), ERROR, IS_BTREE, IS_INDEX, RELATION_IS_OTHER_TEMP, and RelationGetRelationName.

Referenced by bt_multi_page_stats(), bt_page_items_internal(), and bt_page_stats_internal().

bt_metap()

Datum bt_metap

(

PG_FUNCTION_ARGS

)

Definition at line 838 of file btreefuncs.c.

{
    text       *relname = PG_GETARG_TEXT_PP(0);
    Datum       result;
    Relation    rel;
    RangeVar   *relrv;
    BTMetaPageData *metad;
    TupleDesc   tupleDesc;
    int         j;
    char       *values[9];
    Buffer      buffer;
    Page        page;
    HeapTuple   tuple;
 
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to use pageinspect functions")));
 
    relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
    rel = relation_openrv(relrv, AccessShareLock);
 
    if (!IS_INDEX(rel) || !IS_BTREE(rel))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is not a %s index",
                        RelationGetRelationName(rel), "btree")));
 
    /*
     * Reject attempts to read non-local temporary relations; we would be
     * likely to get wrong data since we have no visibility into the owning
     * session's local buffers.
     */
    if (RELATION_IS_OTHER_TEMP(rel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot access temporary tables of other sessions")));
 
    buffer = ReadBuffer(rel, 0);
    LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
    page = BufferGetPage(buffer);
    metad = BTPageGetMeta(page);
 
    /* Build a tuple descriptor for our result type */
    if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    /*
     * We need a kluge here to detect API versions prior to 1.8.  Earlier
     * versions incorrectly used int4 for certain columns.
     *
     * There is no way to reliably avoid the problems created by the old
     * function definition at this point, so insist that the user update the
     * extension.
     */
    if (tupleDesc->natts < BT_METAP_COLS_V1_8)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("function has wrong number of declared columns"),
                 errhint("To resolve the problem, update the \"pageinspect\" extension to the latest version.")));
 
    j = 0;
    values[j++] = psprintf("%d", metad->btm_magic);
    values[j++] = psprintf("%d", metad->btm_version);
    values[j++] = psprintf(INT64_FORMAT, (int64) metad->btm_root);
    values[j++] = psprintf(INT64_FORMAT, (int64) metad->btm_level);
    values[j++] = psprintf(INT64_FORMAT, (int64) metad->btm_fastroot);
    values[j++] = psprintf(INT64_FORMAT, (int64) metad->btm_fastlevel);
 
    /*
     * Get values of extended metadata if available, use default values
     * otherwise.  Note that we rely on the assumption that btm_allequalimage
     * is initialized to zero with indexes that were built on versions prior
     * to Postgres 13 (just like _bt_metaversion()).
     */
    if (metad->btm_version >= BTREE_NOVAC_VERSION)
    {
        values[j++] = psprintf(INT64_FORMAT,
                               (int64) metad->btm_last_cleanup_num_delpages);
        values[j++] = psprintf("%f", metad->btm_last_cleanup_num_heap_tuples);
        values[j++] = metad->btm_allequalimage ? "t" : "f";
    }
    else
    {
        values[j++] = "0";
        values[j++] = "-1";
        values[j++] = "f";
    }
 
    tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
                                   values);
 
    result = HeapTupleGetDatum(tuple);
 
    UnlockReleaseBuffer(buffer);
    relation_close(rel, AccessShareLock);
 
    PG_RETURN_DATUM(result);
}

References AccessShareLock, BT_METAP_COLS_V1_8, BTMetaPageData::btm_allequalimage, BTMetaPageData::btm_fastlevel, BTMetaPageData::btm_fastroot, BTMetaPageData::btm_last_cleanup_num_delpages, BTMetaPageData::btm_last_cleanup_num_heap_tuples, BTMetaPageData::btm_level, BTMetaPageData::btm_magic, BTMetaPageData::btm_root, BTMetaPageData::btm_version, BTPageGetMeta, BTREE_NOVAC_VERSION, BUFFER_LOCK_SHARE, BufferGetPage(), BuildTupleFromCStrings(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, get_call_result_type(), HeapTupleGetDatum(), INT64_FORMAT, IS_BTREE, IS_INDEX, j, LockBuffer(), makeRangeVarFromNameList(), TupleDescData::natts, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, psprintf(), ReadBuffer(), relation_close(), RELATION_IS_OTHER_TEMP, relation_openrv(), RelationGetRelationName, relname, superuser(), textToQualifiedNameList(), TupleDescGetAttInMetadata(), TYPEFUNC_COMPOSITE, UnlockReleaseBuffer(), and values.

bt_multi_page_stats()

Datum bt_multi_page_stats

(

PG_FUNCTION_ARGS

)

Definition at line 343 of file btreefuncs.c.

{
    Relation    rel;
    ua_page_stats *uargs;
    FuncCallContext *fctx;
    MemoryContext mctx;
 
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to use pageinspect functions")));
 
    if (SRF_IS_FIRSTCALL())
    {
        text       *relname = PG_GETARG_TEXT_PP(0);
        int64       blkno = PG_GETARG_INT64(1);
        int64       blk_count = PG_GETARG_INT64(2);
        RangeVar   *relrv;
 
        fctx = SRF_FIRSTCALL_INIT();
 
        relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
        rel = relation_openrv(relrv, AccessShareLock);
 
        /* Check that rel is a valid btree index and 1st block number is OK */
        bt_index_block_validate(rel, blkno);
 
        /*
         * Check if upper bound of the specified range is valid. If only one
         * page is requested, skip as we've already validated the page. (Also,
         * it's important to skip this if blk_count is negative.)
         */
        if (blk_count > 1)
            check_relation_block_range(rel, blkno + blk_count - 1);
 
        /* Save arguments for reuse */
        mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
 
        uargs = palloc(sizeof(ua_page_stats));
 
        uargs->relid = RelationGetRelid(rel);
        uargs->blkno = blkno;
        uargs->blk_count = blk_count;
        uargs->allpages = (blk_count < 0);
 
        fctx->user_fctx = uargs;
 
        MemoryContextSwitchTo(mctx);
 
        /*
         * To avoid possibly leaking a relcache reference if the SRF isn't run
         * to completion, we close and re-open the index rel each time
         * through, using the index's OID for re-opens to ensure we get the
         * same rel.  Keep the AccessShareLock though, to ensure it doesn't go
         * away underneath us.
         */
        relation_close(rel, NoLock);
    }
 
    fctx = SRF_PERCALL_SETUP();
    uargs = fctx->user_fctx;
 
    /* We should have lock already */
    rel = relation_open(uargs->relid, NoLock);
 
    /* In all-pages mode, recheck the index length each time */
    if (uargs->allpages)
        uargs->blk_count = RelationGetNumberOfBlocks(rel) - uargs->blkno;
 
    if (uargs->blk_count > 0)
    {
        /* We need to fetch next block statistics */
        Buffer      buffer;
        Datum       result;
        HeapTuple   tuple;
        int         j;
        char       *values[11];
        BTPageStat  stat;
        TupleDesc   tupleDesc;
 
        buffer = ReadBuffer(rel, uargs->blkno);
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
        /* keep compiler quiet */
        stat.btpo_prev = stat.btpo_next = InvalidBlockNumber;
        stat.btpo_flags = stat.free_size = stat.avg_item_size = 0;
 
        GetBTPageStatistics(uargs->blkno, buffer, &stat);
 
        UnlockReleaseBuffer(buffer);
        relation_close(rel, NoLock);
 
        /* Build a tuple descriptor for our result type */
        if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
            elog(ERROR, "return type must be a row type");
 
        j = 0;
        values[j++] = psprintf("%u", stat.blkno);
        values[j++] = psprintf("%c", stat.type);
        values[j++] = psprintf("%u", stat.live_items);
        values[j++] = psprintf("%u", stat.dead_items);
        values[j++] = psprintf("%u", stat.avg_item_size);
        values[j++] = psprintf("%u", stat.page_size);
        values[j++] = psprintf("%u", stat.free_size);
        values[j++] = psprintf("%u", stat.btpo_prev);
        values[j++] = psprintf("%u", stat.btpo_next);
        values[j++] = psprintf("%u", stat.btpo_level);
        values[j++] = psprintf("%d", stat.btpo_flags);
 
        /* Construct tuple to be returned */
        tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
                                       values);
 
        result = HeapTupleGetDatum(tuple);
 
        /*
         * Move to the next block number and decrement the number of blocks
         * still to be fetched
         */
        uargs->blkno++;
        uargs->blk_count--;
 
        SRF_RETURN_NEXT(fctx, result);
    }
 
    /* Done, so finally we can release the index lock */
    relation_close(rel, AccessShareLock);
    SRF_RETURN_DONE(fctx);
}

References AccessShareLock, ua_page_stats::allpages, ua_page_stats::blk_count, ua_page_stats::blkno, bt_index_block_validate(), BUFFER_LOCK_SHARE, BuildTupleFromCStrings(), check_relation_block_range(), elog, ereport, errcode(), errmsg(), ERROR, get_call_result_type(), GetBTPageStatistics(), HeapTupleGetDatum(), InvalidBlockNumber, j, LockBuffer(), makeRangeVarFromNameList(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, NoLock, palloc(), PG_GETARG_INT64, PG_GETARG_TEXT_PP, psprintf(), ReadBuffer(), relation_close(), relation_open(), relation_openrv(), RelationGetNumberOfBlocks, RelationGetRelid, ua_page_stats::relid, relname, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, stat, superuser(), textToQualifiedNameList(), TupleDescGetAttInMetadata(), TYPEFUNC_COMPOSITE, UnlockReleaseBuffer(), FuncCallContext::user_fctx, and values.

bt_page_items()

Datum bt_page_items

(

PG_FUNCTION_ARGS

)

Definition at line 718 of file btreefuncs.c.

{
    return bt_page_items_internal(fcinfo, PAGEINSPECT_V1_8);
}

References bt_page_items_internal(), and PAGEINSPECT_V1_8.

bt_page_items_1_9()

Datum bt_page_items_1_9

(

PG_FUNCTION_ARGS

)

Definition at line 711 of file btreefuncs.c.

{
    return bt_page_items_internal(fcinfo, PAGEINSPECT_V1_9);
}

References bt_page_items_internal(), and PAGEINSPECT_V1_9.

bt_page_items_bytea()

Datum bt_page_items_bytea

(

PG_FUNCTION_ARGS

)

Definition at line 733 of file btreefuncs.c.

{
    bytea      *raw_page = PG_GETARG_BYTEA_P(0);
    Datum       result;
    FuncCallContext *fctx;
    ua_page_items *uargs;
 
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to use raw page functions")));
 
    if (SRF_IS_FIRSTCALL())
    {
        BTPageOpaque opaque;
        MemoryContext mctx;
        TupleDesc   tupleDesc;
 
        fctx = SRF_FIRSTCALL_INIT();
        mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
 
        uargs = palloc(sizeof(ua_page_items));
 
        uargs->page = get_page_from_raw(raw_page);
 
        if (PageIsNew(uargs->page))
        {
            MemoryContextSwitchTo(mctx);
            PG_RETURN_NULL();
        }
 
        uargs->offset = FirstOffsetNumber;
 
        /* verify the special space has the expected size */
        if (PageGetSpecialSize(uargs->page) != MAXALIGN(sizeof(BTPageOpaqueData)))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("input page is not a valid %s page", "btree"),
                     errdetail("Expected special size %d, got %d.",
                               (int) MAXALIGN(sizeof(BTPageOpaqueData)),
                               (int) PageGetSpecialSize(uargs->page))));
 
        opaque = BTPageGetOpaque(uargs->page);
 
        if (P_ISMETA(opaque))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("block is a meta page")));
 
        if (P_ISLEAF(opaque) && opaque->btpo_level != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("block is not a valid btree leaf page")));
 
        if (P_ISDELETED(opaque))
            elog(NOTICE, "page is deleted");
 
        if (!P_ISDELETED(opaque))
            fctx->max_calls = PageGetMaxOffsetNumber(uargs->page);
        else
        {
            /* Don't interpret BTDeletedPageData as index tuples */
            elog(NOTICE, "page from block is deleted");
            fctx->max_calls = 0;
        }
        uargs->leafpage = P_ISLEAF(opaque);
        uargs->rightmost = P_RIGHTMOST(opaque);
 
        /* Build a tuple descriptor for our result type */
        if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
            elog(ERROR, "return type must be a row type");
        tupleDesc = BlessTupleDesc(tupleDesc);
 
        uargs->tupd = tupleDesc;
 
        fctx->user_fctx = uargs;
 
        MemoryContextSwitchTo(mctx);
    }
 
    fctx = SRF_PERCALL_SETUP();
    uargs = fctx->user_fctx;
 
    if (fctx->call_cntr < fctx->max_calls)
    {
        result = bt_page_print_tuples(uargs);
        uargs->offset++;
        SRF_RETURN_NEXT(fctx, result);
    }
 
    SRF_RETURN_DONE(fctx);
}

References BlessTupleDesc(), bt_page_print_tuples(), BTPageGetOpaque, BTPageOpaqueData::btpo_level, FuncCallContext::call_cntr, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, FirstOffsetNumber, get_call_result_type(), get_page_from_raw(), ua_page_items::leafpage, FuncCallContext::max_calls, MAXALIGN, MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, NOTICE, ua_page_items::offset, P_ISDELETED, P_ISLEAF, P_ISMETA, P_RIGHTMOST, ua_page_items::page, PageGetMaxOffsetNumber(), PageGetSpecialSize(), PageIsNew(), palloc(), PG_GETARG_BYTEA_P, PG_RETURN_NULL, ua_page_items::rightmost, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, superuser(), ua_page_items::tupd, TYPEFUNC_COMPOSITE, and FuncCallContext::user_fctx.

bt_page_items_internal()

static Datum bt_page_items_internal ( PG_FUNCTION_ARGS  , enum pageinspect_version  ext_version  )

static

Definition at line 623 of file btreefuncs.c.

{
    text       *relname = PG_GETARG_TEXT_PP(0);
    int64       blkno = (ext_version == PAGEINSPECT_V1_8 ? PG_GETARG_UINT32(1) : PG_GETARG_INT64(1));
    Datum       result;
    FuncCallContext *fctx;
    MemoryContext mctx;
    ua_page_items *uargs;
 
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to use pageinspect functions")));
 
    if (SRF_IS_FIRSTCALL())
    {
        RangeVar   *relrv;
        Relation    rel;
        Buffer      buffer;
        BTPageOpaque opaque;
        TupleDesc   tupleDesc;
 
        fctx = SRF_FIRSTCALL_INIT();
 
        relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
        rel = relation_openrv(relrv, AccessShareLock);
 
        bt_index_block_validate(rel, blkno);
 
        buffer = ReadBuffer(rel, blkno);
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
        /*
         * We copy the page into local storage to avoid holding pin on the
         * buffer longer than we must, and possibly failing to release it at
         * all if the calling query doesn't fetch all rows.
         */
        mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
 
        uargs = palloc(sizeof(ua_page_items));
 
        uargs->page = palloc(BLCKSZ);
        memcpy(uargs->page, BufferGetPage(buffer), BLCKSZ);
 
        UnlockReleaseBuffer(buffer);
        relation_close(rel, AccessShareLock);
 
        uargs->offset = FirstOffsetNumber;
 
        opaque = BTPageGetOpaque(uargs->page);
 
        if (!P_ISDELETED(opaque))
            fctx->max_calls = PageGetMaxOffsetNumber(uargs->page);
        else
        {
            /* Don't interpret BTDeletedPageData as index tuples */
            elog(NOTICE, "page from block " INT64_FORMAT " is deleted", blkno);
            fctx->max_calls = 0;
        }
        uargs->leafpage = P_ISLEAF(opaque);
        uargs->rightmost = P_RIGHTMOST(opaque);
 
        /* Build a tuple descriptor for our result type */
        if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
            elog(ERROR, "return type must be a row type");
        tupleDesc = BlessTupleDesc(tupleDesc);
 
        uargs->tupd = tupleDesc;
 
        fctx->user_fctx = uargs;
 
        MemoryContextSwitchTo(mctx);
    }
 
    fctx = SRF_PERCALL_SETUP();
    uargs = fctx->user_fctx;
 
    if (fctx->call_cntr < fctx->max_calls)
    {
        result = bt_page_print_tuples(uargs);
        uargs->offset++;
        SRF_RETURN_NEXT(fctx, result);
    }
 
    SRF_RETURN_DONE(fctx);
}

References AccessShareLock, BlessTupleDesc(), bt_index_block_validate(), bt_page_print_tuples(), BTPageGetOpaque, BUFFER_LOCK_SHARE, BufferGetPage(), FuncCallContext::call_cntr, elog, ereport, errcode(), errmsg(), ERROR, FirstOffsetNumber, get_call_result_type(), INT64_FORMAT, ua_page_items::leafpage, LockBuffer(), makeRangeVarFromNameList(), FuncCallContext::max_calls, MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, NOTICE, ua_page_items::offset, P_ISDELETED, P_ISLEAF, P_RIGHTMOST, ua_page_items::page, PageGetMaxOffsetNumber(), PAGEINSPECT_V1_8, palloc(), PG_GETARG_INT64, PG_GETARG_TEXT_PP, PG_GETARG_UINT32, ReadBuffer(), relation_close(), relation_openrv(), relname, ua_page_items::rightmost, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, superuser(), textToQualifiedNameList(), ua_page_items::tupd, TYPEFUNC_COMPOSITE, UnlockReleaseBuffer(), and FuncCallContext::user_fctx.

Referenced by bt_page_items(), and bt_page_items_1_9().

bt_page_print_tuples()

static Datum bt_page_print_tuples ( ua_page_items *  uargs )

static

Definition at line 480 of file btreefuncs.c.

{
    Page        page = uargs->page;
    OffsetNumber offset = uargs->offset;
    bool        leafpage = uargs->leafpage;
    bool        rightmost = uargs->rightmost;
    bool        ispivottuple;
    Datum       values[9];
    bool        nulls[9];
    HeapTuple   tuple;
    ItemId      id;
    IndexTuple  itup;
    int         j;
    int         off;
    int         dlen;
    char       *dump,
               *datacstring;
    char       *ptr;
    ItemPointer htid;
 
    id = PageGetItemId(page, offset);
 
    if (!ItemIdIsValid(id))
        elog(ERROR, "invalid ItemId");
 
    itup = (IndexTuple) PageGetItem(page, id);
 
    j = 0;
    memset(nulls, 0, sizeof(nulls));
    values[j++] = DatumGetInt16(offset);
    values[j++] = ItemPointerGetDatum(&itup->t_tid);
    values[j++] = Int32GetDatum((int) IndexTupleSize(itup));
    values[j++] = BoolGetDatum(IndexTupleHasNulls(itup));
    values[j++] = BoolGetDatum(IndexTupleHasVarwidths(itup));
 
    ptr = (char *) itup + IndexInfoFindDataOffset(itup->t_info);
    dlen = IndexTupleSize(itup) - IndexInfoFindDataOffset(itup->t_info);
 
    /*
     * Make sure that "data" column does not include posting list or pivot
     * tuple representation of heap TID(s).
     *
     * Note: BTreeTupleIsPivot() won't work reliably on !heapkeyspace indexes
     * (those built before BTREE_VERSION 4), but we have no way of determining
     * if this page came from a !heapkeyspace index.  We may only have a bytea
     * nbtree page image to go on, so in general there is no metapage that we
     * can check.
     *
     * That's okay here because BTreeTupleIsPivot() can only return false for
     * a !heapkeyspace pivot, never true for a !heapkeyspace non-pivot.  Since
     * heap TID isn't part of the keyspace in a !heapkeyspace index anyway,
     * there cannot possibly be a pivot tuple heap TID representation that we
     * fail to make an adjustment for.  A !heapkeyspace index can have
     * BTreeTupleIsPivot() return true (due to things like suffix truncation
     * for INCLUDE indexes in Postgres v11), but when that happens
     * BTreeTupleGetHeapTID() can be trusted to work reliably (i.e. return
     * NULL).
     *
     * Note: BTreeTupleIsPosting() always works reliably, even with
     * !heapkeyspace indexes.
     */
    if (BTreeTupleIsPosting(itup))
        dlen -= IndexTupleSize(itup) - BTreeTupleGetPostingOffset(itup);
    else if (BTreeTupleIsPivot(itup) && BTreeTupleGetHeapTID(itup) != NULL)
        dlen -= MAXALIGN(sizeof(ItemPointerData));
 
    if (dlen < 0 || dlen > INDEX_SIZE_MASK)
        elog(ERROR, "invalid tuple length %d for tuple at offset number %u",
             dlen, offset);
    dump = palloc0(dlen * 3 + 1);
    datacstring = dump;
    for (off = 0; off < dlen; off++)
    {
        if (off > 0)
            *dump++ = ' ';
        sprintf(dump, "%02x", *(ptr + off) & 0xff);
        dump += 2;
    }
    values[j++] = CStringGetTextDatum(datacstring);
    pfree(datacstring);
 
    /*
     * We need to work around the BTreeTupleIsPivot() !heapkeyspace limitation
     * again.  Deduce whether or not tuple must be a pivot tuple based on
     * whether or not the page is a leaf page, as well as the page offset
     * number of the tuple.
     */
    ispivottuple = (!leafpage || (!rightmost && offset == P_HIKEY));
 
    /* LP_DEAD bit can never be set for pivot tuples, so show a NULL there */
    if (!ispivottuple)
        values[j++] = BoolGetDatum(ItemIdIsDead(id));
    else
    {
        Assert(!ItemIdIsDead(id));
        nulls[j++] = true;
    }
 
    htid = BTreeTupleGetHeapTID(itup);
    if (ispivottuple && !BTreeTupleIsPivot(itup))
    {
        /* Don't show bogus heap TID in !heapkeyspace pivot tuple */
        htid = NULL;
    }
 
    if (htid)
        values[j++] = ItemPointerGetDatum(htid);
    else
        nulls[j++] = true;
 
    if (BTreeTupleIsPosting(itup))
    {
        /* Build an array of item pointers */
        ItemPointer tids;
        Datum      *tids_datum;
        int         nposting;
 
        tids = BTreeTupleGetPosting(itup);
        nposting = BTreeTupleGetNPosting(itup);
        tids_datum = (Datum *) palloc(nposting * sizeof(Datum));
        for (int i = 0; i < nposting; i++)
            tids_datum[i] = ItemPointerGetDatum(&tids[i]);
        values[j++] = PointerGetDatum(construct_array_builtin(tids_datum, nposting, TIDOID));
        pfree(tids_datum);
    }
    else
        nulls[j++] = true;
 
    /* Build and return the result tuple */
    tuple = heap_form_tuple(uargs->tupd, values, nulls);
 
    return HeapTupleGetDatum(tuple);
}

References Assert(), BoolGetDatum(), BTreeTupleGetHeapTID(), BTreeTupleGetNPosting(), BTreeTupleGetPosting(), BTreeTupleGetPostingOffset(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), construct_array_builtin(), CStringGetTextDatum, DatumGetInt16(), elog, ERROR, heap_form_tuple(), HeapTupleGetDatum(), i, INDEX_SIZE_MASK, IndexInfoFindDataOffset(), IndexTupleHasNulls(), IndexTupleHasVarwidths(), IndexTupleSize(), Int32GetDatum(), ItemIdIsDead, ItemIdIsValid, ItemPointerGetDatum(), j, ua_page_items::leafpage, MAXALIGN, ua_page_items::offset, P_HIKEY, ua_page_items::page, PageGetItem(), PageGetItemId(), palloc(), palloc0(), pfree(), PointerGetDatum(), ua_page_items::rightmost, sprintf, IndexTupleData::t_info, IndexTupleData::t_tid, ua_page_items::tupd, and values.

Referenced by bt_page_items_bytea(), and bt_page_items_internal().

bt_page_stats()

Datum bt_page_stats

(

PG_FUNCTION_ARGS

)

Definition at line 328 of file btreefuncs.c.

{
    return bt_page_stats_internal(fcinfo, PAGEINSPECT_V1_8);
}

References bt_page_stats_internal(), and PAGEINSPECT_V1_8.

bt_page_stats_1_9()

Datum bt_page_stats_1_9

(

PG_FUNCTION_ARGS

)

Definition at line 321 of file btreefuncs.c.

{
    return bt_page_stats_internal(fcinfo, PAGEINSPECT_V1_9);
}

References bt_page_stats_internal(), and PAGEINSPECT_V1_9.

bt_page_stats_internal()

static Datum bt_page_stats_internal ( PG_FUNCTION_ARGS  , enum pageinspect_version  ext_version  )

static

Definition at line 259 of file btreefuncs.c.

{
    text       *relname = PG_GETARG_TEXT_PP(0);
    int64       blkno = (ext_version == PAGEINSPECT_V1_8 ? PG_GETARG_UINT32(1) : PG_GETARG_INT64(1));
    Buffer      buffer;
    Relation    rel;
    RangeVar   *relrv;
    Datum       result;
    HeapTuple   tuple;
    TupleDesc   tupleDesc;
    int         j;
    char       *values[11];
    BTPageStat  stat;
 
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to use pageinspect functions")));
 
    relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
    rel = relation_openrv(relrv, AccessShareLock);
 
    bt_index_block_validate(rel, blkno);
 
    buffer = ReadBuffer(rel, blkno);
    LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
    /* keep compiler quiet */
    stat.btpo_prev = stat.btpo_next = InvalidBlockNumber;
    stat.btpo_flags = stat.free_size = stat.avg_item_size = 0;
 
    GetBTPageStatistics(blkno, buffer, &stat);
 
    UnlockReleaseBuffer(buffer);
    relation_close(rel, AccessShareLock);
 
    /* Build a tuple descriptor for our result type */
    if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    j = 0;
    values[j++] = psprintf("%u", stat.blkno);
    values[j++] = psprintf("%c", stat.type);
    values[j++] = psprintf("%u", stat.live_items);
    values[j++] = psprintf("%u", stat.dead_items);
    values[j++] = psprintf("%u", stat.avg_item_size);
    values[j++] = psprintf("%u", stat.page_size);
    values[j++] = psprintf("%u", stat.free_size);
    values[j++] = psprintf("%u", stat.btpo_prev);
    values[j++] = psprintf("%u", stat.btpo_next);
    values[j++] = psprintf("%u", stat.btpo_level);
    values[j++] = psprintf("%d", stat.btpo_flags);
 
    tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
                                   values);
 
    result = HeapTupleGetDatum(tuple);
 
    PG_RETURN_DATUM(result);
}

References AccessShareLock, bt_index_block_validate(), BUFFER_LOCK_SHARE, BuildTupleFromCStrings(), elog, ereport, errcode(), errmsg(), ERROR, get_call_result_type(), GetBTPageStatistics(), HeapTupleGetDatum(), InvalidBlockNumber, j, LockBuffer(), makeRangeVarFromNameList(), PAGEINSPECT_V1_8, PG_GETARG_INT64, PG_GETARG_TEXT_PP, PG_GETARG_UINT32, PG_RETURN_DATUM, psprintf(), ReadBuffer(), relation_close(), relation_openrv(), relname, stat, superuser(), textToQualifiedNameList(), TupleDescGetAttInMetadata(), TYPEFUNC_COMPOSITE, UnlockReleaseBuffer(), and values.

Referenced by bt_page_stats(), and bt_page_stats_1_9().

check_relation_block_range()

static void check_relation_block_range ( Relation  rel, int64  blkno  )

static

Definition at line 203 of file btreefuncs.c.

{
    /* Ensure we can cast to BlockNumber */
    if (blkno < 0 || blkno > MaxBlockNumber)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid block number %" PRId64, blkno)));
 
    if ((BlockNumber) (blkno) >= RelationGetNumberOfBlocks(rel))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("block number %" PRId64 " is out of range", blkno)));
}

References ereport, errcode(), errmsg(), ERROR, MaxBlockNumber, and RelationGetNumberOfBlocks.

Referenced by bt_index_block_validate(), and bt_multi_page_stats().

GetBTPageStatistics()

static void GetBTPageStatistics ( BlockNumber  blkno, Buffer  buffer, BTPageStat *  stat  )

static

Definition at line 108 of file btreefuncs.c.

{
    Page        page = BufferGetPage(buffer);
    PageHeader  phdr = (PageHeader) page;
    OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
    BTPageOpaque opaque = BTPageGetOpaque(page);
    int         item_size = 0;
    int         off;
 
    stat->blkno = blkno;
 
    stat->max_avail = BLCKSZ - (BLCKSZ - phdr->pd_special + SizeOfPageHeaderData);
 
    stat->dead_items = stat->live_items = 0;
 
    stat->page_size = PageGetPageSize(page);
 
    /* page type (flags) */
    if (P_ISDELETED(opaque))
    {
        /* We divide deleted pages into leaf ('d') or internal ('D') */
        if (P_ISLEAF(opaque) || !P_HAS_FULLXID(opaque))
            stat->type = 'd';
        else
            stat->type = 'D';
 
        /*
         * Report safexid in a deleted page.
         *
         * Handle pg_upgrade'd deleted pages that used the previous safexid
         * representation in btpo_level field (this used to be a union type
         * called "bpto").
         */
        if (P_HAS_FULLXID(opaque))
        {
            FullTransactionId safexid = BTPageGetDeleteXid(page);
 
            elog(DEBUG2, "deleted page from block %u has safexid %u:%u",
                 blkno, EpochFromFullTransactionId(safexid),
                 XidFromFullTransactionId(safexid));
        }
        else
            elog(DEBUG2, "deleted page from block %u has safexid %u",
                 blkno, opaque->btpo_level);
 
        /* Don't interpret BTDeletedPageData as index tuples */
        maxoff = InvalidOffsetNumber;
    }
    else if (P_IGNORE(opaque))
        stat->type = 'e';
    else if (P_ISLEAF(opaque))
        stat->type = 'l';
    else if (P_ISROOT(opaque))
        stat->type = 'r';
    else
        stat->type = 'i';
 
    /* btpage opaque data */
    stat->btpo_prev = opaque->btpo_prev;
    stat->btpo_next = opaque->btpo_next;
    stat->btpo_level = opaque->btpo_level;
    stat->btpo_flags = opaque->btpo_flags;
    stat->btpo_cycleid = opaque->btpo_cycleid;
 
    /* count live and dead tuples, and free space */
    for (off = FirstOffsetNumber; off <= maxoff; off++)
    {
        IndexTuple  itup;
 
        ItemId      id = PageGetItemId(page, off);
 
        itup = (IndexTuple) PageGetItem(page, id);
 
        item_size += IndexTupleSize(itup);
 
        if (!ItemIdIsDead(id))
            stat->live_items++;
        else
            stat->dead_items++;
    }
    stat->free_size = PageGetFreeSpace(page);
 
    if ((stat->live_items + stat->dead_items) > 0)
        stat->avg_item_size = item_size / (stat->live_items + stat->dead_items);
    else
        stat->avg_item_size = 0;
}

References BTPageGetDeleteXid(), BTPageGetOpaque, BTPageOpaqueData::btpo_cycleid, BTPageOpaqueData::btpo_flags, BTPageOpaqueData::btpo_level, BTPageOpaqueData::btpo_next, BTPageOpaqueData::btpo_prev, BufferGetPage(), DEBUG2, elog, EpochFromFullTransactionId, FirstOffsetNumber, IndexTupleSize(), InvalidOffsetNumber, ItemIdIsDead, P_HAS_FULLXID, P_IGNORE, P_ISDELETED, P_ISLEAF, P_ISROOT, PageGetFreeSpace(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageGetPageSize(), PageHeaderData::pd_special, SizeOfPageHeaderData, and XidFromFullTransactionId.

Referenced by bt_multi_page_stats(), and bt_page_stats_internal().

PG_FUNCTION_INFO_V1() [1/7]

PG_FUNCTION_INFO_V1

(

bt_metap

)

PG_FUNCTION_INFO_V1() [2/7]

PG_FUNCTION_INFO_V1

(

bt_multi_page_stats

)

PG_FUNCTION_INFO_V1() [3/7]

PG_FUNCTION_INFO_V1

(

bt_page_items

)

PG_FUNCTION_INFO_V1() [4/7]

PG_FUNCTION_INFO_V1

(

bt_page_items_1_9

)

PG_FUNCTION_INFO_V1() [5/7]

PG_FUNCTION_INFO_V1

(

bt_page_items_bytea

)

PG_FUNCTION_INFO_V1() [6/7]

PG_FUNCTION_INFO_V1

(

bt_page_stats

)

PG_FUNCTION_INFO_V1() [7/7]

PG_FUNCTION_INFO_V1

(

bt_page_stats_1_9

)