walsummaryfuncs.c File Reference

#include "postgres.h"
#include "backup/walsummary.h"
#include "common/blkreftable.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "postmaster/walsummarizer.h"
#include "utils/fmgrprotos.h"
#include "utils/pg_lsn.h"

Include dependency graph for walsummaryfuncs.c:

Go to the source code of this file.

Macros
#define	NUM_WS_ATTS   3
#define	NUM_SUMMARY_ATTS   6
#define	NUM_STATE_ATTS   4
#define	MAX_BLOCKS_PER_CALL   256

Functions
Datum	pg_available_wal_summaries (PG_FUNCTION_ARGS)
Datum	pg_wal_summary_contents (PG_FUNCTION_ARGS)
Datum	pg_get_wal_summarizer_state (PG_FUNCTION_ARGS)

Macro Definition Documentation

MAX_BLOCKS_PER_CALL

#define MAX_BLOCKS_PER_CALL   256

Definition at line 26 of file walsummaryfuncs.c.

NUM_STATE_ATTS

#define NUM_STATE_ATTS   4

Definition at line 25 of file walsummaryfuncs.c.

NUM_SUMMARY_ATTS

#define NUM_SUMMARY_ATTS   6

Definition at line 24 of file walsummaryfuncs.c.

NUM_WS_ATTS

#define NUM_WS_ATTS   3

Definition at line 23 of file walsummaryfuncs.c.

Function Documentation

pg_available_wal_summaries()

Datum pg_available_wal_summaries

(

PG_FUNCTION_ARGS

)

Definition at line 32 of file walsummaryfuncs.c.

{
    ReturnSetInfo *rsi;
    List       *wslist;
    ListCell   *lc;
    Datum       values[NUM_WS_ATTS];
    bool        nulls[NUM_WS_ATTS];
 
    InitMaterializedSRF(fcinfo, 0);
    rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 
    memset(nulls, 0, sizeof(nulls));
 
    wslist = GetWalSummaries(0, InvalidXLogRecPtr, InvalidXLogRecPtr);
    foreach(lc, wslist)
    {
        WalSummaryFile *ws = (WalSummaryFile *) lfirst(lc);
        HeapTuple   tuple;
 
        CHECK_FOR_INTERRUPTS();
 
        values[0] = Int64GetDatum((int64) ws->tli);
        values[1] = LSNGetDatum(ws->start_lsn);
        values[2] = LSNGetDatum(ws->end_lsn);
 
        tuple = heap_form_tuple(rsi->setDesc, values, nulls);
        tuplestore_puttuple(rsi->setResult, tuple);
    }
 
    return (Datum) 0;
}

References CHECK_FOR_INTERRUPTS, WalSummaryFile::end_lsn, GetWalSummaries(), heap_form_tuple(), InitMaterializedSRF(), Int64GetDatum(), InvalidXLogRecPtr, lfirst, LSNGetDatum(), NUM_WS_ATTS, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, WalSummaryFile::start_lsn, WalSummaryFile::tli, tuplestore_puttuple(), and values.

pg_get_wal_summarizer_state()

Datum pg_get_wal_summarizer_state

(

PG_FUNCTION_ARGS

)

Definition at line 177 of file walsummaryfuncs.c.

{
    Datum       values[NUM_STATE_ATTS];
    bool        nulls[NUM_STATE_ATTS];
    TimeLineID  summarized_tli;
    XLogRecPtr  summarized_lsn;
    XLogRecPtr  pending_lsn;
    int         summarizer_pid;
    TupleDesc   tupdesc;
    HeapTuple   htup;
 
    GetWalSummarizerState(&summarized_tli, &summarized_lsn, &pending_lsn,
                          &summarizer_pid);
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    memset(nulls, 0, sizeof(nulls));
 
    values[0] = Int64GetDatum((int64) summarized_tli);
    values[1] = LSNGetDatum(summarized_lsn);
    values[2] = LSNGetDatum(pending_lsn);
 
    if (summarizer_pid < 0)
        nulls[3] = true;
    else
        values[3] = Int32GetDatum(summarizer_pid);
 
    htup = heap_form_tuple(tupdesc, values, nulls);
 
    PG_RETURN_DATUM(HeapTupleGetDatum(htup));
}

References elog, ERROR, get_call_result_type(), GetWalSummarizerState(), heap_form_tuple(), HeapTupleGetDatum(), Int32GetDatum(), Int64GetDatum(), LSNGetDatum(), NUM_STATE_ATTS, PG_RETURN_DATUM, TYPEFUNC_COMPOSITE, and values.

pg_wal_summary_contents()

Datum pg_wal_summary_contents

(

PG_FUNCTION_ARGS

)

Definition at line 69 of file walsummaryfuncs.c.

{
    ReturnSetInfo *rsi;
    Datum       values[NUM_SUMMARY_ATTS];
    bool        nulls[NUM_SUMMARY_ATTS];
    WalSummaryFile ws;
    WalSummaryIO io;
    BlockRefTableReader *reader;
    int64       raw_tli;
    RelFileLocator rlocator;
    ForkNumber  forknum;
    BlockNumber limit_block;
 
    InitMaterializedSRF(fcinfo, 0);
    rsi = (ReturnSetInfo *) fcinfo->resultinfo;
    memset(nulls, 0, sizeof(nulls));
 
    /*
     * Since the timeline could at least in theory be more than 2^31, and
     * since we don't have unsigned types at the SQL level, it is passed as a
     * 64-bit integer. Test whether it's out of range.
     */
    raw_tli = PG_GETARG_INT64(0);
    if (raw_tli < 1 || raw_tli > PG_INT32_MAX)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("invalid timeline %lld", (long long) raw_tli));
 
    /* Prepare to read the specified WAL summary file. */
    ws.tli = (TimeLineID) raw_tli;
    ws.start_lsn = PG_GETARG_LSN(1);
    ws.end_lsn = PG_GETARG_LSN(2);
    io.filepos = 0;
    io.file = OpenWalSummaryFile(&ws, false);
    reader = CreateBlockRefTableReader(ReadWalSummary, &io,
                                       FilePathName(io.file),
                                       ReportWalSummaryError, NULL);
 
    /* Loop over relation forks. */
    while (BlockRefTableReaderNextRelation(reader, &rlocator, &forknum,
                                           &limit_block))
    {
        BlockNumber blocks[MAX_BLOCKS_PER_CALL];
        HeapTuple   tuple;
 
        CHECK_FOR_INTERRUPTS();
 
        values[0] = ObjectIdGetDatum(rlocator.relNumber);
        values[1] = ObjectIdGetDatum(rlocator.spcOid);
        values[2] = ObjectIdGetDatum(rlocator.dbOid);
        values[3] = Int16GetDatum((int16) forknum);
 
        /* Loop over blocks within the current relation fork. */
        while (1)
        {
            unsigned    nblocks;
            unsigned    i;
 
            CHECK_FOR_INTERRUPTS();
 
            nblocks = BlockRefTableReaderGetBlocks(reader, blocks,
                                                   MAX_BLOCKS_PER_CALL);
            if (nblocks == 0)
                break;
 
            /*
             * For each block that we specifically know to have been modified,
             * emit a row with that block number and limit_block = false.
             */
            values[5] = BoolGetDatum(false);
            for (i = 0; i < nblocks; ++i)
            {
                values[4] = Int64GetDatum((int64) blocks[i]);
 
                tuple = heap_form_tuple(rsi->setDesc, values, nulls);
                tuplestore_puttuple(rsi->setResult, tuple);
            }
 
            /*
             * If the limit block is not InvalidBlockNumber, emit an extra row
             * with that block number and limit_block = true.
             *
             * There is no point in doing this when the limit_block is
             * InvalidBlockNumber, because no block with that number or any
             * higher number can ever exist.
             */
            if (BlockNumberIsValid(limit_block))
            {
                values[4] = Int64GetDatum((int64) limit_block);
                values[5] = BoolGetDatum(true);
 
                tuple = heap_form_tuple(rsi->setDesc, values, nulls);
                tuplestore_puttuple(rsi->setResult, tuple);
            }
        }
    }
 
    /* Cleanup */
    DestroyBlockRefTableReader(reader);
    FileClose(io.file);
 
    return (Datum) 0;
}

References BlockNumberIsValid(), BlockRefTableReaderGetBlocks(), BlockRefTableReaderNextRelation(), BoolGetDatum(), CHECK_FOR_INTERRUPTS, CreateBlockRefTableReader(), RelFileLocator::dbOid, DestroyBlockRefTableReader(), WalSummaryFile::end_lsn, ereport, errcode(), errmsg(), ERROR, WalSummaryIO::file, FileClose(), FilePathName(), WalSummaryIO::filepos, heap_form_tuple(), i, InitMaterializedSRF(), Int16GetDatum(), Int64GetDatum(), MAX_BLOCKS_PER_CALL, NUM_SUMMARY_ATTS, ObjectIdGetDatum(), OpenWalSummaryFile(), PG_GETARG_INT64, PG_GETARG_LSN, PG_INT32_MAX, ReadWalSummary(), RelFileLocator::relNumber, ReportWalSummaryError(), ReturnSetInfo::setDesc, ReturnSetInfo::setResult, RelFileLocator::spcOid, WalSummaryFile::start_lsn, WalSummaryFile::tli, tuplestore_puttuple(), and values.