test_custom_var_stats.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "common/hashfn.h"
#include "funcapi.h"
#include "storage/dsm_registry.h"
#include "storage/fd.h"
#include "utils/builtins.h"
#include "utils/pgstat_internal.h"

Include dependency graph for test_custom_var_stats.c:

Go to the source code of this file.

Data Structures
struct	PgStat_StatCustomVarEntry
struct	PgStatShared_CustomVarEntry

Macros
#define	write_chunk(fpout, ptr, len)   (fwrite(ptr, len, 1, fpout) == 1)
#define	write_chunk_s(fpout, ptr)   write_chunk(fpout, ptr, sizeof(*ptr))
#define	read_chunk(fpin, ptr, len)   (fread(ptr, 1, len, fpin) == (len))
#define	read_chunk_s(fpin, ptr)   read_chunk(fpin, ptr, sizeof(*ptr))
#define	TEST_CUSTOM_VAR_MAGIC_NUMBER   (0xBEEFBEEF)
#define	PGSTAT_KIND_TEST_CUSTOM_VAR_STATS   25
#define	TEST_CUSTOM_AUX_DATA_DESC   "pg_stat/test_custom_var_stats_desc.stats"
#define	PGSTAT_CUSTOM_VAR_STATS_IDX(name)   hash_bytes_extended((const unsigned char *) name, strlen(name), 0)

Typedefs
typedef struct PgStat_StatCustomVarEntry	PgStat_StatCustomVarEntry
typedef struct PgStatShared_CustomVarEntry	PgStatShared_CustomVarEntry

Functions
	PG_MODULE_MAGIC_EXT (.name="test_custom_var_stats",.version=PG_VERSION)
static bool	test_custom_stats_var_flush_pending_cb (PgStat_EntryRef *entry_ref, bool nowait)
static bool	test_custom_stats_var_to_serialized_data (const PgStat_HashKey *key, const PgStatShared_Common *header, FILE *statfile)
static bool	test_custom_stats_var_from_serialized_data (const PgStat_HashKey *key, PgStatShared_Common *header, FILE *statfile)
static void	test_custom_stats_var_finish (PgStat_StatsFileOp status)
void	_PG_init (void)
static PgStat_StatCustomVarEntry *	test_custom_stats_var_fetch_entry (const char *stat_name)
	PG_FUNCTION_INFO_V1 (test_custom_stats_var_create)
Datum	test_custom_stats_var_create (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (test_custom_stats_var_update)
Datum	test_custom_stats_var_update (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (test_custom_stats_var_drop)
Datum	test_custom_stats_var_drop (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (test_custom_stats_var_report)
Datum	test_custom_stats_var_report (PG_FUNCTION_ARGS)

Variables
static FILE *	fd_description = NULL
static pgoff_t	fd_description_offset = 0
static dsa_area *	custom_stats_description_dsa = NULL
static const PgStat_KindInfo	custom_stats

Macro Definition Documentation

PGSTAT_CUSTOM_VAR_STATS_IDX

#define PGSTAT_CUSTOM_VAR_STATS_IDX

(

name

)

hash_bytes_extended((const unsigned char *) name, strlen(name), 0)

Definition at line 52 of file test_custom_var_stats.c.

PGSTAT_KIND_TEST_CUSTOM_VAR_STATS

#define PGSTAT_KIND_TEST_CUSTOM_VAR_STATS   25

Definition at line 44 of file test_custom_var_stats.c.

read_chunk

#define read_chunk	(		fpin,
			ptr,
			len
	)		(fread(ptr, 1, len, fpin) == (len))

Definition at line 31 of file test_custom_var_stats.c.

read_chunk_s

#define read_chunk_s	(		fpin,
			ptr
	)		read_chunk(fpin, ptr, sizeof(*ptr))

Definition at line 32 of file test_custom_var_stats.c.

TEST_CUSTOM_AUX_DATA_DESC

#define TEST_CUSTOM_AUX_DATA_DESC   "pg_stat/test_custom_var_stats_desc.stats"

Definition at line 47 of file test_custom_var_stats.c.

TEST_CUSTOM_VAR_MAGIC_NUMBER

#define TEST_CUSTOM_VAR_MAGIC_NUMBER   (0xBEEFBEEF)

Definition at line 34 of file test_custom_var_stats.c.

write_chunk

#define write_chunk	(		fpout,
			ptr,
			len
	)		(fwrite(ptr, len, 1, fpout) == 1)

Definition at line 29 of file test_custom_var_stats.c.

write_chunk_s

#define write_chunk_s	(		fpout,
			ptr
	)		write_chunk(fpout, ptr, sizeof(*ptr))

Definition at line 30 of file test_custom_var_stats.c.

Typedef Documentation

PgStat_StatCustomVarEntry

typedef struct PgStat_StatCustomVarEntry PgStat_StatCustomVarEntry

PgStatShared_CustomVarEntry

typedef struct PgStatShared_CustomVarEntry PgStatShared_CustomVarEntry

Function Documentation

_PG_init()

void _PG_init

(

void

)

Definition at line 136 of file test_custom_var_stats.c.

{
    /* Register custom statistics kind */
    pgstat_register_kind(PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, &custom_stats);
}

References custom_stats, PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, and pgstat_register_kind().

PG_FUNCTION_INFO_V1() [1/4]

PG_FUNCTION_INFO_V1

(

test_custom_stats_var_create

)

PG_FUNCTION_INFO_V1() [2/4]

PG_FUNCTION_INFO_V1

(

test_custom_stats_var_drop

)

PG_FUNCTION_INFO_V1() [3/4]

PG_FUNCTION_INFO_V1

(

test_custom_stats_var_report

)

PG_FUNCTION_INFO_V1() [4/4]

PG_FUNCTION_INFO_V1

(

test_custom_stats_var_update

)

PG_MODULE_MAGIC_EXT()

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

test_custom_stats_var_create()

Datum test_custom_stats_var_create

(

PG_FUNCTION_ARGS

)

Definition at line 523 of file test_custom_var_stats.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_CustomVarEntry *shared_entry;
    char       *stat_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    char       *description = text_to_cstring(PG_GETARG_TEXT_PP(1));
    dsa_pointer dp = InvalidDsaPointer;
    bool        found;
 
    /* Validate name length first */
    if (strlen(stat_name) >= NAMEDATALEN)
        ereport(ERROR,
                (errcode(ERRCODE_NAME_TOO_LONG),
                 errmsg("custom statistic name \"%s\" is too long", stat_name),
                 errdetail("Name must be less than %d characters.", NAMEDATALEN)));
 
    /* Initialize DSA and description provided */
    if (!custom_stats_description_dsa)
        custom_stats_description_dsa = GetNamedDSA("test_custom_stat_dsa", &found);
 
    if (!custom_stats_description_dsa)
        ereport(ERROR,
                (errmsg("could not access DSA for custom statistics descriptions")));
 
    /* Allocate space in DSA and copy description */
    dp = dsa_allocate(custom_stats_description_dsa, strlen(description) + 1);
    memcpy(dsa_get_address(custom_stats_description_dsa, dp),
           description,
           strlen(description) + 1);
 
    /* Create or get existing entry */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, InvalidOid,
                                            PGSTAT_CUSTOM_VAR_STATS_IDX(stat_name), true);
 
    if (!entry_ref)
        PG_RETURN_VOID();
 
    shared_entry = (PgStatShared_CustomVarEntry *) entry_ref->shared_stats;
 
    /* Zero-initialize statistics */
    memset(&shared_entry->stats, 0, sizeof(shared_entry->stats));
 
    /* Store description pointer */
    shared_entry->description = dp;
 
    pgstat_unlock_entry(entry_ref);
 
    PG_RETURN_VOID();
}

References custom_stats_description_dsa, description, PgStatShared_CustomVarEntry::description, dsa_allocate, dsa_get_address(), ereport, errcode(), errdetail(), errmsg, ERROR, fb(), GetNamedDSA(), InvalidDsaPointer, InvalidOid, memcpy(), NAMEDATALEN, PG_GETARG_TEXT_PP, PG_RETURN_VOID, PGSTAT_CUSTOM_VAR_STATS_IDX, pgstat_get_entry_ref_locked(), PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, PgStatShared_CustomVarEntry::stats, and text_to_cstring().

test_custom_stats_var_drop()

Datum test_custom_stats_var_drop

(

PG_FUNCTION_ARGS

)

Definition at line 606 of file test_custom_var_stats.c.

{
    char       *stat_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    /* Drop entry and request GC if the entry could not be freed */
    if (!pgstat_drop_entry(PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, InvalidOid,
                           PGSTAT_CUSTOM_VAR_STATS_IDX(stat_name), false))
        pgstat_request_entry_refs_gc();
 
    PG_RETURN_VOID();
}

References fb(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_VOID, PGSTAT_CUSTOM_VAR_STATS_IDX, pgstat_drop_entry(), PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, pgstat_request_entry_refs_gc(), and text_to_cstring().

test_custom_stats_var_fetch_entry()

static PgStat_StatCustomVarEntry * test_custom_stats_var_fetch_entry ( const char *  stat_name )

static

Definition at line 500 of file test_custom_var_stats.c.

{
    /* Fetch entry by hashed name */
    return (PgStat_StatCustomVarEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_TEST_CUSTOM_VAR_STATS,
                           InvalidOid,
                           PGSTAT_CUSTOM_VAR_STATS_IDX(stat_name),
                           NULL);
}

References fb(), InvalidOid, PGSTAT_CUSTOM_VAR_STATS_IDX, pgstat_fetch_entry(), and PGSTAT_KIND_TEST_CUSTOM_VAR_STATS.

Referenced by test_custom_stats_var_report().

test_custom_stats_var_finish()

static void test_custom_stats_var_finish ( PgStat_StatsFileOp  status )

static

Definition at line 418 of file test_custom_var_stats.c.

{
    switch (status)
    {
        case STATS_WRITE:
            if (!fd_description)
                return;
 
            fd_description_offset = 0;
 
            /* Check for write errors and cleanup if necessary */
            if (ferror(fd_description))
            {
                ereport(LOG,
                        (errcode_for_file_access(),
                         errmsg("could not write to file \"%s\": %m",
                                TEST_CUSTOM_AUX_DATA_DESC)));
                FreeFile(fd_description);
                unlink(TEST_CUSTOM_AUX_DATA_DESC);
            }
            else if (FreeFile(fd_description) < 0)
            {
                ereport(LOG,
                        (errcode_for_file_access(),
                         errmsg("could not close file \"%s\": %m",
                                TEST_CUSTOM_AUX_DATA_DESC)));
                unlink(TEST_CUSTOM_AUX_DATA_DESC);
            }
            break;
 
        case STATS_READ:
            if (fd_description)
                FreeFile(fd_description);
 
            /* Remove the file after reading */
            elog(DEBUG2, "removing file \"%s\"", TEST_CUSTOM_AUX_DATA_DESC);
            unlink(TEST_CUSTOM_AUX_DATA_DESC);
            break;
 
        case STATS_DISCARD:
            {
                int         ret;
 
                /* Attempt to remove the file */
                ret = unlink(TEST_CUSTOM_AUX_DATA_DESC);
                if (ret != 0)
                {
                    if (errno == ENOENT)
                        elog(LOG,
                             "didn't need to unlink file \"%s\" - didn't exist",
                             TEST_CUSTOM_AUX_DATA_DESC);
                    else
                        ereport(LOG,
                                (errcode_for_file_access(),
                                 errmsg("could not unlink file \"%s\": %m",
                                        TEST_CUSTOM_AUX_DATA_DESC)));
                }
                else
                {
                    ereport(LOG,
                            (errmsg_internal("unlinked file \"%s\"",
                                             TEST_CUSTOM_AUX_DATA_DESC)));
                }
            }
            break;
    }
 
    fd_description = NULL;
}

References DEBUG2, elog, ereport, errcode_for_file_access(), errmsg, errmsg_internal(), fb(), fd_description, fd_description_offset, FreeFile(), LOG, STATS_DISCARD, STATS_READ, STATS_WRITE, and TEST_CUSTOM_AUX_DATA_DESC.

test_custom_stats_var_flush_pending_cb()

static bool test_custom_stats_var_flush_pending_cb ( PgStat_EntryRef *  entry_ref, bool  nowait  )

static

Definition at line 157 of file test_custom_var_stats.c.

{
    PgStat_StatCustomVarEntry *pending_entry;
    PgStatShared_CustomVarEntry *shared_entry;
 
    pending_entry = (PgStat_StatCustomVarEntry *) entry_ref->pending;
    shared_entry = (PgStatShared_CustomVarEntry *) entry_ref->shared_stats;
 
    if (!pgstat_lock_entry(entry_ref, nowait))
        return false;
 
    /* Add pending counts to shared totals */
    shared_entry->stats.numcalls += pending_entry->numcalls;
 
    pgstat_unlock_entry(entry_ref);
 
    return true;
}

References fb(), PgStat_StatCustomVarEntry::numcalls, PgStat_EntryRef::pending, pgstat_lock_entry(), pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, and PgStatShared_CustomVarEntry::stats.

test_custom_stats_var_from_serialized_data()

static bool test_custom_stats_var_from_serialized_data ( const PgStat_HashKey *  key, PgStatShared_Common *  header, FILE *  statfile  )

static

Definition at line 289 of file test_custom_var_stats.c.

{
    PgStatShared_CustomVarEntry *entry;
    dsa_pointer dp;
    size_t      len;
    pgoff_t     offset;
    char       *buffer;
    bool        found;
    uint32      magic_number = 0;
    PgStat_HashKey file_key;
 
    /* Check the magic number first, in the main file. */
    if (!read_chunk_s(statfile, &magic_number))
    {
        elog(WARNING, "failed to read magic number from statistics file");
        return false;
    }
 
    if (magic_number != TEST_CUSTOM_VAR_MAGIC_NUMBER)
    {
        elog(WARNING, "found magic number %u from statistics file, should be %u",
             magic_number, TEST_CUSTOM_VAR_MAGIC_NUMBER);
        return false;
    }
 
    /*
     * Read the offset from the main stats file, to be able to read the
     * auxiliary data from the secondary statistics file.
     */
    if (!read_chunk_s(statfile, &offset))
    {
        elog(WARNING, "failed to read metadata offset from statistics file");
        return false;
    }
 
    /* Open statistics file for reading if not already open */
    if (!fd_description)
    {
        fd_description = AllocateFile(TEST_CUSTOM_AUX_DATA_DESC, PG_BINARY_R);
        if (fd_description == NULL)
        {
            if (errno != ENOENT)
                ereport(LOG,
                        (errcode_for_file_access(),
                         errmsg("could not open statistics file \"%s\" for reading: %m",
                                TEST_CUSTOM_AUX_DATA_DESC)));
            pgstat_reset_of_kind(PGSTAT_KIND_TEST_CUSTOM_VAR_STATS);
            return false;
        }
    }
 
    /* Read data from the secondary statistics file, at the specified offset */
    if (fseeko(fd_description, offset, SEEK_SET) != 0)
    {
        elog(WARNING, "could not seek in file \"%s\": %m",
             TEST_CUSTOM_AUX_DATA_DESC);
        return false;
    }
 
    /* Read the hash key from the secondary statistics file */
    if (!read_chunk_s(fd_description, &file_key))
    {
        elog(WARNING, "failed to read hash key from file");
        return false;
    }
 
    /* Check key consistency */
    if (file_key.kind != key->kind ||
        file_key.dboid != key->dboid ||
        file_key.objid != key->objid)
    {
        elog(WARNING, "found entry key %u/%u/%" PRIu64 " not matching with %u/%u/%" PRIu64,
             file_key.kind, file_key.dboid, file_key.objid,
             key->kind, key->dboid, key->objid);
        return false;
    }
 
    entry = (PgStatShared_CustomVarEntry *) header;
 
    /* Read the description length and its data */
    if (!read_chunk_s(fd_description, &len))
    {
        elog(WARNING, "failed to read metadata length from statistics file");
        return false;
    }
 
    /* Handle empty descriptions */
    if (len == 0)
    {
        entry->description = InvalidDsaPointer;
        return true;
    }
 
    /* Initialize DSA if needed */
    if (!custom_stats_description_dsa)
        custom_stats_description_dsa = GetNamedDSA("test_custom_stat_dsa", &found);
 
    if (!custom_stats_description_dsa)
    {
        elog(WARNING, "could not access DSA for custom statistics descriptions");
        return false;
    }
 
    buffer = palloc(len);
    if (!read_chunk(fd_description, buffer, len))
    {
        pfree(buffer);
        elog(WARNING, "failed to read description from file");
        return false;
    }
 
    /* Allocate space in DSA and copy the description */
    dp = dsa_allocate(custom_stats_description_dsa, len);
    memcpy(dsa_get_address(custom_stats_description_dsa, dp), buffer, len);
    entry->description = dp;
    pfree(buffer);
 
    return true;
}

References AllocateFile(), custom_stats_description_dsa, PgStatShared_CustomVarEntry::description, dsa_allocate, dsa_get_address(), elog, ereport, errcode_for_file_access(), errmsg, fb(), fd_description, fseeko, GetNamedDSA(), InvalidDsaPointer, len, LOG, memcpy(), palloc(), pfree(), PG_BINARY_R, PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, pgstat_reset_of_kind(), read_chunk, read_chunk_s, TEST_CUSTOM_AUX_DATA_DESC, TEST_CUSTOM_VAR_MAGIC_NUMBER, and WARNING.

test_custom_stats_var_report()

Datum test_custom_stats_var_report

(

PG_FUNCTION_ARGS

)

Definition at line 627 of file test_custom_var_stats.c.

{
    FuncCallContext *funcctx;
    char       *stat_name;
    PgStat_StatCustomVarEntry *stat_entry;
 
    if (SRF_IS_FIRSTCALL())
    {
        TupleDesc   tupdesc;
        MemoryContext oldcontext;
 
        /* Initialize SRF context */
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /* Get composite return type */
        if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
            elog(ERROR, "test_custom_stats_var_report: return type is not composite");
 
        funcctx->tuple_desc = BlessTupleDesc(tupdesc);
        funcctx->max_calls = 1; /* single row result */
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
 
    if (funcctx->call_cntr < funcctx->max_calls)
    {
        Datum       values[3];
        bool        nulls[3] = {false, false, false};
        HeapTuple   tuple;
        PgStat_EntryRef *entry_ref;
        PgStatShared_CustomVarEntry *shared_entry;
        char       *description = NULL;
        bool        found;
 
        stat_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
        stat_entry = test_custom_stats_var_fetch_entry(stat_name);
 
        /* Return row only if entry exists */
        if (stat_entry)
        {
            /* Get entry ref to access shared entry */
            entry_ref = pgstat_get_entry_ref(PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, InvalidOid,
                                             PGSTAT_CUSTOM_VAR_STATS_IDX(stat_name), false, NULL);
 
            if (entry_ref)
            {
                shared_entry = (PgStatShared_CustomVarEntry *) entry_ref->shared_stats;
 
                /* Get description from DSA if available */
                if (DsaPointerIsValid(shared_entry->description))
                {
                    if (!custom_stats_description_dsa)
                        custom_stats_description_dsa = GetNamedDSA("test_custom_stat_dsa", &found);
 
                    if (custom_stats_description_dsa)
                        description = dsa_get_address(custom_stats_description_dsa, shared_entry->description);
                }
            }
 
            values[0] = PointerGetDatum(cstring_to_text(stat_name));
            values[1] = Int64GetDatum(stat_entry->numcalls);
 
            if (description)
                values[2] = PointerGetDatum(cstring_to_text(description));
            else
                nulls[2] = true;
 
            tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
            SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
        }
    }
 
    SRF_RETURN_DONE(funcctx);
}

References BlessTupleDesc(), cstring_to_text(), custom_stats_description_dsa, description, PgStatShared_CustomVarEntry::description, dsa_get_address(), DsaPointerIsValid, elog, ERROR, fb(), get_call_result_type(), GetNamedDSA(), heap_form_tuple(), HeapTupleGetDatum(), Int64GetDatum(), InvalidOid, MemoryContextSwitchTo(), PG_GETARG_TEXT_PP, PGSTAT_CUSTOM_VAR_STATS_IDX, pgstat_get_entry_ref(), PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, PointerGetDatum, PgStat_EntryRef::shared_stats, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, test_custom_stats_var_fetch_entry(), text_to_cstring(), TYPEFUNC_COMPOSITE, and values.

test_custom_stats_var_to_serialized_data()

static bool test_custom_stats_var_to_serialized_data ( const PgStat_HashKey *  key, const PgStatShared_Common *  header, FILE *  statfile  )

static

Definition at line 197 of file test_custom_var_stats.c.

{
    char       *description;
    size_t      len;
    const PgStatShared_CustomVarEntry *entry = (const PgStatShared_CustomVarEntry *) header;
    bool        found;
    uint32      magic_number = TEST_CUSTOM_VAR_MAGIC_NUMBER;
 
    /*
     * First mark the main file with a magic number, keeping a trace that some
     * auxiliary data will exist in the secondary statistics file.
     */
    if (!write_chunk_s(statfile, &magic_number))
        return false;
 
    /* Open statistics file for writing. */
    if (!fd_description)
    {
        fd_description = AllocateFile(TEST_CUSTOM_AUX_DATA_DESC, PG_BINARY_W);
        if (fd_description == NULL)
        {
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not open statistics file \"%s\" for writing: %m",
                            TEST_CUSTOM_AUX_DATA_DESC)));
            return false;
        }
 
        /* Initialize offset for secondary statistics file. */
        fd_description_offset = 0;
    }
 
    /* Write offset to the main data file */
    if (!write_chunk_s(statfile, &fd_description_offset))
        return false;
 
    /*
     * First write the entry key to the secondary statistics file.  This will
     * be cross-checked with the key read from main stats file at loading
     * time.
     */
    if (!write_chunk_s(fd_description, (PgStat_HashKey *) key))
        return false;
    fd_description_offset += sizeof(PgStat_HashKey);
 
    if (!custom_stats_description_dsa)
        custom_stats_description_dsa = GetNamedDSA("test_custom_stat_dsa", &found);
 
    /* Handle entries without descriptions */
    if (!DsaPointerIsValid(entry->description) || !custom_stats_description_dsa)
    {
        /* length to description file */
        len = 0;
        if (!write_chunk_s(fd_description, &len))
            return false;
        fd_description_offset += sizeof(size_t);
        return true;
    }
 
    /*
     * Retrieve description from DSA, then write the length followed by the
     * description.
     */
    description = dsa_get_address(custom_stats_description_dsa,
                                  entry->description);
    len = strlen(description) + 1;
    if (!write_chunk_s(fd_description, &len))
        return false;
    if (!write_chunk(fd_description, description, len))
        return false;
 
    /*
     * Update offset for next entry, counting for the length (size_t) of the
     * description and the description contents.
     */
    fd_description_offset += len + sizeof(size_t);
    return true;
}

References AllocateFile(), custom_stats_description_dsa, description, PgStatShared_CustomVarEntry::description, dsa_get_address(), DsaPointerIsValid, ereport, errcode_for_file_access(), errmsg, fb(), fd_description, fd_description_offset, GetNamedDSA(), len, LOG, PG_BINARY_W, TEST_CUSTOM_AUX_DATA_DESC, TEST_CUSTOM_VAR_MAGIC_NUMBER, write_chunk, and write_chunk_s.

test_custom_stats_var_update()

Datum test_custom_stats_var_update

(

PG_FUNCTION_ARGS

)

Definition at line 582 of file test_custom_var_stats.c.

{
    char       *stat_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    PgStat_EntryRef *entry_ref;
    PgStat_StatCustomVarEntry *pending_entry;
 
    /* Get pending entry in local memory */
    entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, InvalidOid,
                                          PGSTAT_CUSTOM_VAR_STATS_IDX(stat_name), NULL);
 
    pending_entry = (PgStat_StatCustomVarEntry *) entry_ref->pending;
    pending_entry->numcalls++;
 
    PG_RETURN_VOID();
}

References fb(), InvalidOid, PgStat_EntryRef::pending, PG_GETARG_TEXT_PP, PG_RETURN_VOID, PGSTAT_CUSTOM_VAR_STATS_IDX, PGSTAT_KIND_TEST_CUSTOM_VAR_STATS, pgstat_prep_pending_entry(), and text_to_cstring().

Variable Documentation

custom_stats

const PgStat_KindInfo custom_stats

static

Initial value:

= {
    .name = "test_custom_var_stats",
    .fixed_amount = false,      
    .write_to_file = true,      
    .track_entry_count = true,  
    .accessed_across_databases = true,  
    .shared_size = sizeof(PgStatShared_CustomVarEntry),
    .shared_data_off = offsetof(PgStatShared_CustomVarEntry, stats),
    .shared_data_len = sizeof(((PgStatShared_CustomVarEntry *) 0)->stats),
    .pending_size = sizeof(PgStat_StatCustomVarEntry),
    .flush_pending_cb = test_custom_stats_var_flush_pending_cb,
    .to_serialized_data = test_custom_stats_var_to_serialized_data,
    .from_serialized_data = test_custom_stats_var_from_serialized_data,
    .finish = test_custom_stats_var_finish,
}

Definition at line 114 of file test_custom_var_stats.c.

                                            {
    .name = "test_custom_var_stats",
    .fixed_amount = false,      /* variable number of entries */
    .write_to_file = true,      /* persist across restarts */
    .track_entry_count = true,  /* count active entries */
    .accessed_across_databases = true,  /* global statistics */
    .shared_size = sizeof(PgStatShared_CustomVarEntry),
    .shared_data_off = offsetof(PgStatShared_CustomVarEntry, stats),
    .shared_data_len = sizeof(((PgStatShared_CustomVarEntry *) 0)->stats),
    .pending_size = sizeof(PgStat_StatCustomVarEntry),
    .flush_pending_cb = test_custom_stats_var_flush_pending_cb,
    .to_serialized_data = test_custom_stats_var_to_serialized_data,
    .from_serialized_data = test_custom_stats_var_from_serialized_data,
    .finish = test_custom_stats_var_finish,
};

Referenced by _PG_init().

custom_stats_description_dsa

dsa_area* custom_stats_description_dsa = NULL

static

Definition at line 85 of file test_custom_var_stats.c.

Referenced by test_custom_stats_var_create(), test_custom_stats_var_from_serialized_data(), test_custom_stats_var_report(), and test_custom_stats_var_to_serialized_data().

fd_description

FILE* fd_description = NULL

static

Definition at line 79 of file test_custom_var_stats.c.

Referenced by test_custom_stats_var_finish(), test_custom_stats_var_from_serialized_data(), and test_custom_stats_var_to_serialized_data().

fd_description_offset

pgoff_t fd_description_offset = 0

static

Definition at line 82 of file test_custom_var_stats.c.

Referenced by test_custom_stats_var_finish(), and test_custom_stats_var_to_serialized_data().