pgstat_relation.c File Reference

#include "postgres.h"
#include "access/twophase_rmgr.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "utils/memutils.h"
#include "utils/pgstat_internal.h"
#include "utils/rel.h"
#include "utils/timestamp.h"

Include dependency graph for pgstat_relation.c:

Go to the source code of this file.

Data Structures
struct	TwoPhasePgStatRecord

Typedefs
typedef struct TwoPhasePgStatRecord	TwoPhasePgStatRecord

Functions
static PgStat_TableStatus *	pgstat_prep_relation_pending (Oid rel_id, bool isshared)
static void	add_tabstat_xact_level (PgStat_TableStatus *pgstat_info, int nest_level)
static void	ensure_tabstat_xact_level (PgStat_TableStatus *pgstat_info)
static void	save_truncdrop_counters (PgStat_TableXactStatus *trans, bool is_drop)
static void	restore_truncdrop_counters (PgStat_TableXactStatus *trans)
void	pgstat_copy_relation_stats (Relation dst, Relation src)
void	pgstat_init_relation (Relation rel)
void	pgstat_assoc_relation (Relation rel)
void	pgstat_unlink_relation (Relation rel)
void	pgstat_create_relation (Relation rel)
void	pgstat_drop_relation (Relation rel)
void	pgstat_report_vacuum (Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, TimestampTz starttime)
void	pgstat_report_analyze (Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, bool resetcounter, TimestampTz starttime)
void	pgstat_count_heap_insert (Relation rel, PgStat_Counter n)
void	pgstat_count_heap_update (Relation rel, bool hot, bool newpage)
void	pgstat_count_heap_delete (Relation rel)
void	pgstat_count_truncate (Relation rel)
void	pgstat_update_heap_dead_tuples (Relation rel, int delta)
PgStat_StatTabEntry *	pgstat_fetch_stat_tabentry (Oid relid)
PgStat_StatTabEntry *	pgstat_fetch_stat_tabentry_ext (bool shared, Oid reloid)
PgStat_TableStatus *	find_tabstat_entry (Oid rel_id)
void	AtEOXact_PgStat_Relations (PgStat_SubXactStatus *xact_state, bool isCommit)
void	AtEOSubXact_PgStat_Relations (PgStat_SubXactStatus *xact_state, bool isCommit, int nestDepth)
void	AtPrepare_PgStat_Relations (PgStat_SubXactStatus *xact_state)
void	PostPrepare_PgStat_Relations (PgStat_SubXactStatus *xact_state)
void	pgstat_twophase_postcommit (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)
void	pgstat_twophase_postabort (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)
bool	pgstat_relation_flush_cb (PgStat_EntryRef *entry_ref, bool nowait)
void	pgstat_relation_delete_pending_cb (PgStat_EntryRef *entry_ref)
void	pgstat_relation_reset_timestamp_cb (PgStatShared_Common *header, TimestampTz ts)

Typedef Documentation

TwoPhasePgStatRecord

typedef struct TwoPhasePgStatRecord TwoPhasePgStatRecord

Function Documentation

add_tabstat_xact_level()

static void add_tabstat_xact_level ( PgStat_TableStatus *  pgstat_info, int  nest_level  )

static

Definition at line 942 of file pgstat_relation.c.

{
    PgStat_SubXactStatus *xact_state;
    PgStat_TableXactStatus *trans;
 
    /*
     * If this is the first rel to be modified at the current nest level, we
     * first have to push a transaction stack entry.
     */
    xact_state = pgstat_get_xact_stack_level(nest_level);
 
    /* Now make a per-table stack entry */
    trans = (PgStat_TableXactStatus *)
        MemoryContextAllocZero(TopTransactionContext,
                               sizeof(PgStat_TableXactStatus));
    trans->nest_level = nest_level;
    trans->upper = pgstat_info->trans;
    trans->parent = pgstat_info;
    trans->next = xact_state->first;
    xact_state->first = trans;
    pgstat_info->trans = trans;
}

References PgStat_SubXactStatus::first, MemoryContextAllocZero(), pgstat_get_xact_stack_level(), TopTransactionContext, PgStat_TableStatus::trans, and trans.

Referenced by ensure_tabstat_xact_level().

AtEOSubXact_PgStat_Relations()

void AtEOSubXact_PgStat_Relations	(	PgStat_SubXactStatus *	xact_state,
		bool	isCommit,
		int	nestDepth
	)

Definition at line 608 of file pgstat_relation.c.

{
    PgStat_TableXactStatus *trans;
    PgStat_TableXactStatus *next_trans;
 
    for (trans = xact_state->first; trans != NULL; trans = next_trans)
    {
        PgStat_TableStatus *tabstat;
 
        next_trans = trans->next;
        Assert(trans->nest_level == nestDepth);
        tabstat = trans->parent;
        Assert(tabstat->trans == trans);
 
        if (isCommit)
        {
            if (trans->upper && trans->upper->nest_level == nestDepth - 1)
            {
                if (trans->truncdropped)
                {
                    /* propagate the truncate/drop status one level up */
                    save_truncdrop_counters(trans->upper, false);
                    /* replace upper xact stats with ours */
                    trans->upper->tuples_inserted = trans->tuples_inserted;
                    trans->upper->tuples_updated = trans->tuples_updated;
                    trans->upper->tuples_deleted = trans->tuples_deleted;
                }
                else
                {
                    trans->upper->tuples_inserted += trans->tuples_inserted;
                    trans->upper->tuples_updated += trans->tuples_updated;
                    trans->upper->tuples_deleted += trans->tuples_deleted;
                }
                tabstat->trans = trans->upper;
                pfree(trans);
            }
            else
            {
                /*
                 * When there isn't an immediate parent state, we can just
                 * reuse the record instead of going through a palloc/pfree
                 * pushup (this works since it's all in TopTransactionContext
                 * anyway).  We have to re-link it into the parent level,
                 * though, and that might mean pushing a new entry into the
                 * pgStatXactStack.
                 */
                PgStat_SubXactStatus *upper_xact_state;
 
                upper_xact_state = pgstat_get_xact_stack_level(nestDepth - 1);
                trans->next = upper_xact_state->first;
                upper_xact_state->first = trans;
                trans->nest_level = nestDepth - 1;
            }
        }
        else
        {
            /*
             * On abort, update top-level tabstat counts, then forget the
             * subtransaction
             */
 
            /* first restore values obliterated by truncate/drop */
            restore_truncdrop_counters(trans);
            /* count attempted actions regardless of commit/abort */
            tabstat->counts.tuples_inserted += trans->tuples_inserted;
            tabstat->counts.tuples_updated += trans->tuples_updated;
            tabstat->counts.tuples_deleted += trans->tuples_deleted;
            /* inserted tuples are dead, deleted tuples are unaffected */
            tabstat->counts.delta_dead_tuples +=
                trans->tuples_inserted + trans->tuples_updated;
            tabstat->trans = trans->upper;
            pfree(trans);
        }
    }
}

References Assert(), PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, PgStat_SubXactStatus::first, pfree(), pgstat_get_xact_stack_level(), restore_truncdrop_counters(), save_truncdrop_counters(), PgStat_TableStatus::trans, trans, PgStat_TableCounts::tuples_deleted, PgStat_TableCounts::tuples_inserted, and PgStat_TableCounts::tuples_updated.

Referenced by AtEOSubXact_PgStat().

AtEOXact_PgStat_Relations()

void AtEOXact_PgStat_Relations	(	PgStat_SubXactStatus *	xact_state,
		bool	isCommit
	)

Definition at line 550 of file pgstat_relation.c.

{
    PgStat_TableXactStatus *trans;
 
    for (trans = xact_state->first; trans != NULL; trans = trans->next)
    {
        PgStat_TableStatus *tabstat;
 
        Assert(trans->nest_level == 1);
        Assert(trans->upper == NULL);
        tabstat = trans->parent;
        Assert(tabstat->trans == trans);
        /* restore pre-truncate/drop stats (if any) in case of aborted xact */
        if (!isCommit)
            restore_truncdrop_counters(trans);
        /* count attempted actions regardless of commit/abort */
        tabstat->counts.tuples_inserted += trans->tuples_inserted;
        tabstat->counts.tuples_updated += trans->tuples_updated;
        tabstat->counts.tuples_deleted += trans->tuples_deleted;
        if (isCommit)
        {
            tabstat->counts.truncdropped = trans->truncdropped;
            if (trans->truncdropped)
            {
                /* forget live/dead stats seen by backend thus far */
                tabstat->counts.delta_live_tuples = 0;
                tabstat->counts.delta_dead_tuples = 0;
            }
            /* insert adds a live tuple, delete removes one */
            tabstat->counts.delta_live_tuples +=
                trans->tuples_inserted - trans->tuples_deleted;
            /* update and delete each create a dead tuple */
            tabstat->counts.delta_dead_tuples +=
                trans->tuples_updated + trans->tuples_deleted;
            /* insert, update, delete each count as one change event */
            tabstat->counts.changed_tuples +=
                trans->tuples_inserted + trans->tuples_updated +
                trans->tuples_deleted;
        }
        else
        {
            /* inserted tuples are dead, deleted tuples are unaffected */
            tabstat->counts.delta_dead_tuples +=
                trans->tuples_inserted + trans->tuples_updated;
            /* an aborted xact generates no changed_tuple events */
        }
        tabstat->trans = NULL;
    }
}

References Assert(), PgStat_TableCounts::changed_tuples, PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, PgStat_TableCounts::delta_live_tuples, PgStat_SubXactStatus::first, restore_truncdrop_counters(), PgStat_TableStatus::trans, trans, PgStat_TableCounts::truncdropped, PgStat_TableCounts::tuples_deleted, PgStat_TableCounts::tuples_inserted, and PgStat_TableCounts::tuples_updated.

Referenced by AtEOXact_PgStat().

AtPrepare_PgStat_Relations()

void AtPrepare_PgStat_Relations

(

PgStat_SubXactStatus *

xact_state

)

Definition at line 689 of file pgstat_relation.c.

{
    PgStat_TableXactStatus *trans;
 
    for (trans = xact_state->first; trans != NULL; trans = trans->next)
    {
        PgStat_TableStatus *tabstat PG_USED_FOR_ASSERTS_ONLY;
        TwoPhasePgStatRecord record;
 
        Assert(trans->nest_level == 1);
        Assert(trans->upper == NULL);
        tabstat = trans->parent;
        Assert(tabstat->trans == trans);
 
        record.tuples_inserted = trans->tuples_inserted;
        record.tuples_updated = trans->tuples_updated;
        record.tuples_deleted = trans->tuples_deleted;
        record.inserted_pre_truncdrop = trans->inserted_pre_truncdrop;
        record.updated_pre_truncdrop = trans->updated_pre_truncdrop;
        record.deleted_pre_truncdrop = trans->deleted_pre_truncdrop;
        record.id = tabstat->id;
        record.shared = tabstat->shared;
        record.truncdropped = trans->truncdropped;
 
        RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
                               &record, sizeof(TwoPhasePgStatRecord));
    }
}

References Assert(), TwoPhasePgStatRecord::deleted_pre_truncdrop, PgStat_SubXactStatus::first, TwoPhasePgStatRecord::id, TwoPhasePgStatRecord::inserted_pre_truncdrop, PG_USED_FOR_ASSERTS_ONLY, RegisterTwoPhaseRecord(), TwoPhasePgStatRecord::shared, trans, TwoPhasePgStatRecord::truncdropped, TwoPhasePgStatRecord::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, TwoPhasePgStatRecord::tuples_updated, TWOPHASE_RM_PGSTAT_ID, and TwoPhasePgStatRecord::updated_pre_truncdrop.

Referenced by AtPrepare_PgStat().

ensure_tabstat_xact_level()

static void ensure_tabstat_xact_level ( PgStat_TableStatus *  pgstat_info )

static

Definition at line 969 of file pgstat_relation.c.

{
    int         nest_level = GetCurrentTransactionNestLevel();
 
    if (pgstat_info->trans == NULL ||
        pgstat_info->trans->nest_level != nest_level)
        add_tabstat_xact_level(pgstat_info, nest_level);
}

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, and PgStat_TableStatus::trans.

Referenced by pgstat_count_heap_delete(), pgstat_count_heap_insert(), pgstat_count_heap_update(), and pgstat_count_truncate().

find_tabstat_entry()

PgStat_TableStatus * find_tabstat_entry

(

Oid

rel_id

)

Definition at line 500 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStat_TableXactStatus *trans;
    PgStat_TableStatus *tabentry = NULL;
    PgStat_TableStatus *tablestatus = NULL;
 
    entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, MyDatabaseId, rel_id);
    if (!entry_ref)
    {
        entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, InvalidOid, rel_id);
        if (!entry_ref)
            return tablestatus;
    }
 
    tabentry = (PgStat_TableStatus *) entry_ref->pending;
    tablestatus = palloc_object(PgStat_TableStatus);
    *tablestatus = *tabentry;
 
    /*
     * Reset tablestatus->trans in the copy of PgStat_TableStatus as it may
     * point to a shared memory area.  Its data is saved below, so removing it
     * does not matter.
     */
    tablestatus->trans = NULL;
 
    /*
     * Live subtransaction counts are not included yet.  This is not a hot
     * code path so reconcile tuples_inserted, tuples_updated and
     * tuples_deleted even if the caller may not be interested in this data.
     */
    for (trans = tabentry->trans; trans != NULL; trans = trans->upper)
    {
        tablestatus->counts.tuples_inserted += trans->tuples_inserted;
        tablestatus->counts.tuples_updated += trans->tuples_updated;
        tablestatus->counts.tuples_deleted += trans->tuples_deleted;
    }
 
    return tablestatus;
}

References PgStat_TableStatus::counts, InvalidOid, MyDatabaseId, palloc_object, PgStat_EntryRef::pending, pgstat_fetch_pending_entry(), PGSTAT_KIND_RELATION, PgStat_TableStatus::trans, trans, PgStat_TableCounts::tuples_deleted, PgStat_TableCounts::tuples_inserted, and PgStat_TableCounts::tuples_updated.

pgstat_assoc_relation()

void pgstat_assoc_relation

(

Relation

rel

)

Definition at line 131 of file pgstat_relation.c.

{
    Assert(rel->pgstat_enabled);
    Assert(rel->pgstat_info == NULL);
 
    /* Else find or make the PgStat_TableStatus entry, and update link */
    rel->pgstat_info = pgstat_prep_relation_pending(RelationGetRelid(rel),
                                                    rel->rd_rel->relisshared);
 
    /* don't allow link a stats to multiple relcache entries */
    Assert(rel->pgstat_info->relation == NULL);
 
    /* mark this relation as the owner */
    rel->pgstat_info->relation = rel;
}

References Assert(), RelationData::pgstat_enabled, RelationData::pgstat_info, pgstat_prep_relation_pending(), RelationData::rd_rel, PgStat_TableStatus::relation, and RelationGetRelid.

pgstat_copy_relation_stats()

void pgstat_copy_relation_stats	(	Relation	dst,
		Relation	src
	)

Definition at line 57 of file pgstat_relation.c.

{
    PgStat_StatTabEntry *srcstats;
    PgStatShared_Relation *dstshstats;
    PgStat_EntryRef *dst_ref;
 
    srcstats = pgstat_fetch_stat_tabentry_ext(src->rd_rel->relisshared,
                                              RelationGetRelid(src));
    if (!srcstats)
        return;
 
    dst_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
                                          dst->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                                          RelationGetRelid(dst),
                                          false);
 
    dstshstats = (PgStatShared_Relation *) dst_ref->shared_stats;
    dstshstats->stats = *srcstats;
 
    pgstat_unlock_entry(dst_ref);
}

References InvalidOid, MyDatabaseId, pgstat_fetch_stat_tabentry_ext(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_RELATION, pgstat_unlock_entry(), RelationData::rd_rel, RelationGetRelid, PgStat_EntryRef::shared_stats, and PgStatShared_Relation::stats.

Referenced by index_concurrently_swap().

pgstat_count_heap_delete()

void pgstat_count_heap_delete

(

Relation

rel

)

Definition at line 414 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_deleted++;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_deleted.

Referenced by heap_abort_speculative(), and heap_delete().

pgstat_count_heap_insert()

void pgstat_count_heap_insert	(	Relation	rel,
		PgStat_Counter	n
	)

Definition at line 373 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_inserted += n;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_inserted.

Referenced by heap_insert(), heap_multi_insert(), and RefreshMatViewByOid().

pgstat_count_heap_update()

void pgstat_count_heap_update	(	Relation	rel,
		bool	hot,
		bool	newpage
	)

Definition at line 388 of file pgstat_relation.c.

{
    Assert(!(hot && newpage));
 
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_updated++;
 
        /*
         * tuples_hot_updated and tuples_newpage_updated counters are
         * nontransactional, so just advance them
         */
        if (hot)
            pgstat_info->counts.tuples_hot_updated++;
        else if (newpage)
            pgstat_info->counts.tuples_newpage_updated++;
    }
}

References Assert(), PgStat_TableStatus::counts, ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, PgStat_TableCounts::tuples_hot_updated, PgStat_TableCounts::tuples_newpage_updated, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_update().

pgstat_count_truncate()

void pgstat_count_truncate

(

Relation

rel

)

Definition at line 429 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        save_truncdrop_counters(pgstat_info->trans, false);
        pgstat_info->trans->tuples_inserted = 0;
        pgstat_info->trans->tuples_updated = 0;
        pgstat_info->trans->tuples_deleted = 0;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, save_truncdrop_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by ExecuteTruncateGuts(), and RefreshMatViewByOid().

pgstat_create_relation()

void pgstat_create_relation

(

Relation

rel

)

Definition at line 168 of file pgstat_relation.c.

{
    pgstat_create_transactional(PGSTAT_KIND_RELATION,
                                rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                                RelationGetRelid(rel));
}

References InvalidOid, MyDatabaseId, pgstat_create_transactional(), PGSTAT_KIND_RELATION, RelationData::rd_rel, and RelationGetRelid.

Referenced by heap_create().

pgstat_drop_relation()

void pgstat_drop_relation

(

Relation

rel

)

Definition at line 179 of file pgstat_relation.c.

{
    int         nest_level = GetCurrentTransactionNestLevel();
    PgStat_TableStatus *pgstat_info;
 
    pgstat_drop_transactional(PGSTAT_KIND_RELATION,
                              rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                              RelationGetRelid(rel));
 
    if (!pgstat_should_count_relation(rel))
        return;
 
    /*
     * Transactionally set counters to 0. That ensures that accesses to
     * pg_stat_xact_all_tables inside the transaction show 0.
     */
    pgstat_info = rel->pgstat_info;
    if (pgstat_info->trans &&
        pgstat_info->trans->nest_level == nest_level)
    {
        save_truncdrop_counters(pgstat_info->trans, true);
        pgstat_info->trans->tuples_inserted = 0;
        pgstat_info->trans->tuples_updated = 0;
        pgstat_info->trans->tuples_deleted = 0;
    }
}

References GetCurrentTransactionNestLevel(), InvalidOid, MyDatabaseId, PgStat_TableXactStatus::nest_level, pgstat_drop_transactional(), RelationData::pgstat_info, PGSTAT_KIND_RELATION, pgstat_should_count_relation, RelationData::rd_rel, RelationGetRelid, save_truncdrop_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_drop_with_catalog(), and index_drop().

pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry * pgstat_fetch_stat_tabentry

(

Oid

relid

)

Definition at line 469 of file pgstat_relation.c.

{
    return pgstat_fetch_stat_tabentry_ext(IsSharedRelation(relid), relid);
}

References IsSharedRelation(), and pgstat_fetch_stat_tabentry_ext().

pgstat_fetch_stat_tabentry_ext()

PgStat_StatTabEntry * pgstat_fetch_stat_tabentry_ext	(	bool	shared,
		Oid	reloid
	)

Definition at line 479 of file pgstat_relation.c.

{
    Oid         dboid = (shared ? InvalidOid : MyDatabaseId);
 
    return (PgStat_StatTabEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_RELATION, dboid, reloid);
}

References InvalidOid, MyDatabaseId, pgstat_fetch_entry(), and PGSTAT_KIND_RELATION.

Referenced by do_autovacuum(), pgstat_copy_relation_stats(), pgstat_fetch_stat_tabentry(), and recheck_relation_needs_vacanalyze().

pgstat_init_relation()

void pgstat_init_relation

(

Relation

rel

)

Definition at line 91 of file pgstat_relation.c.

{
    char        relkind = rel->rd_rel->relkind;
 
    /*
     * We only count stats for relations with storage and partitioned tables
     */
    if (!RELKIND_HAS_STORAGE(relkind) && relkind != RELKIND_PARTITIONED_TABLE)
    {
        rel->pgstat_enabled = false;
        rel->pgstat_info = NULL;
        return;
    }
 
    if (!pgstat_track_counts)
    {
        if (rel->pgstat_info)
            pgstat_unlink_relation(rel);
 
        /* We're not counting at all */
        rel->pgstat_enabled = false;
        rel->pgstat_info = NULL;
        return;
    }
 
    rel->pgstat_enabled = true;
}

References RelationData::pgstat_enabled, RelationData::pgstat_info, pgstat_track_counts, pgstat_unlink_relation(), and RelationData::rd_rel.

Referenced by relation_open(), and try_relation_open().

pgstat_prep_relation_pending()

static PgStat_TableStatus * pgstat_prep_relation_pending ( Oid  rel_id, bool  isshared  )

static

Definition at line 923 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStat_TableStatus *pending;
 
    entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_RELATION,
                                          isshared ? InvalidOid : MyDatabaseId,
                                          rel_id, NULL);
    pending = entry_ref->pending;
    pending->id = rel_id;
    pending->shared = isshared;
 
    return pending;
}

References PgStat_TableStatus::id, InvalidOid, MyDatabaseId, PgStat_EntryRef::pending, PGSTAT_KIND_RELATION, pgstat_prep_pending_entry(), and PgStat_TableStatus::shared.

Referenced by pgstat_assoc_relation(), pgstat_twophase_postabort(), and pgstat_twophase_postcommit().

pgstat_relation_delete_pending_cb()

void pgstat_relation_delete_pending_cb

(

PgStat_EntryRef *

entry_ref

)

Definition at line 904 of file pgstat_relation.c.

{
    PgStat_TableStatus *pending = (PgStat_TableStatus *) entry_ref->pending;
 
    if (pending->relation)
        pgstat_unlink_relation(pending->relation);
}

References if(), PgStat_EntryRef::pending, pgstat_unlink_relation(), and PgStat_TableStatus::relation.

pgstat_relation_flush_cb()

bool pgstat_relation_flush_cb	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 815 of file pgstat_relation.c.

{
    Oid         dboid;
    PgStat_TableStatus *lstats; /* pending stats entry  */
    PgStatShared_Relation *shtabstats;
    PgStat_StatTabEntry *tabentry;  /* table entry of shared stats */
    PgStat_StatDBEntry *dbentry;    /* pending database entry */
 
    dboid = entry_ref->shared_entry->key.dboid;
    lstats = (PgStat_TableStatus *) entry_ref->pending;
    shtabstats = (PgStatShared_Relation *) entry_ref->shared_stats;
 
    /*
     * Ignore entries that didn't accumulate any actual counts, such as
     * indexes that were opened by the planner but not used.
     */
    if (pg_memory_is_all_zeros(&lstats->counts,
                               sizeof(struct PgStat_TableCounts)))
        return true;
 
    if (!pgstat_lock_entry(entry_ref, nowait))
        return false;
 
    /* add the values to the shared entry. */
    tabentry = &shtabstats->stats;
 
    tabentry->numscans += lstats->counts.numscans;
    if (lstats->counts.numscans)
    {
        TimestampTz t = GetCurrentTransactionStopTimestamp();
 
        if (t > tabentry->lastscan)
            tabentry->lastscan = t;
    }
    tabentry->tuples_returned += lstats->counts.tuples_returned;
    tabentry->tuples_fetched += lstats->counts.tuples_fetched;
    tabentry->tuples_inserted += lstats->counts.tuples_inserted;
    tabentry->tuples_updated += lstats->counts.tuples_updated;
    tabentry->tuples_deleted += lstats->counts.tuples_deleted;
    tabentry->tuples_hot_updated += lstats->counts.tuples_hot_updated;
    tabentry->tuples_newpage_updated += lstats->counts.tuples_newpage_updated;
 
    /*
     * If table was truncated/dropped, first reset the live/dead counters.
     */
    if (lstats->counts.truncdropped)
    {
        tabentry->live_tuples = 0;
        tabentry->dead_tuples = 0;
        tabentry->ins_since_vacuum = 0;
    }
 
    tabentry->live_tuples += lstats->counts.delta_live_tuples;
    tabentry->dead_tuples += lstats->counts.delta_dead_tuples;
    tabentry->mod_since_analyze += lstats->counts.changed_tuples;
 
    /*
     * Using tuples_inserted to update ins_since_vacuum does mean that we'll
     * track aborted inserts too.  This isn't ideal, but otherwise probably
     * not worth adding an extra field for.  It may just amount to autovacuums
     * triggering for inserts more often than they maybe should, which is
     * probably not going to be common enough to be too concerned about here.
     */
    tabentry->ins_since_vacuum += lstats->counts.tuples_inserted;
 
    tabentry->blocks_fetched += lstats->counts.blocks_fetched;
    tabentry->blocks_hit += lstats->counts.blocks_hit;
 
    /* Clamp live_tuples in case of negative delta_live_tuples */
    tabentry->live_tuples = Max(tabentry->live_tuples, 0);
    /* Likewise for dead_tuples */
    tabentry->dead_tuples = Max(tabentry->dead_tuples, 0);
 
    pgstat_unlock_entry(entry_ref);
 
    /* The entry was successfully flushed, add the same to database stats */
    dbentry = pgstat_prep_database_pending(dboid);
    dbentry->tuples_returned += lstats->counts.tuples_returned;
    dbentry->tuples_fetched += lstats->counts.tuples_fetched;
    dbentry->tuples_inserted += lstats->counts.tuples_inserted;
    dbentry->tuples_updated += lstats->counts.tuples_updated;
    dbentry->tuples_deleted += lstats->counts.tuples_deleted;
    dbentry->blocks_fetched += lstats->counts.blocks_fetched;
    dbentry->blocks_hit += lstats->counts.blocks_hit;
 
    return true;
}

References PgStat_TableCounts::blocks_fetched, PgStat_StatDBEntry::blocks_fetched, PgStat_StatTabEntry::blocks_fetched, PgStat_TableCounts::blocks_hit, PgStat_StatDBEntry::blocks_hit, PgStat_StatTabEntry::blocks_hit, PgStat_TableCounts::changed_tuples, PgStat_TableStatus::counts, PgStat_HashKey::dboid, PgStat_StatTabEntry::dead_tuples, PgStat_TableCounts::delta_dead_tuples, PgStat_TableCounts::delta_live_tuples, GetCurrentTransactionStopTimestamp(), PgStat_StatTabEntry::ins_since_vacuum, PgStatShared_HashEntry::key, PgStat_StatTabEntry::lastscan, PgStat_StatTabEntry::live_tuples, Max, PgStat_StatTabEntry::mod_since_analyze, PgStat_TableCounts::numscans, PgStat_StatTabEntry::numscans, PgStat_EntryRef::pending, pg_memory_is_all_zeros(), pgstat_lock_entry(), pgstat_prep_database_pending(), pgstat_unlock_entry(), PgStat_EntryRef::shared_entry, PgStat_EntryRef::shared_stats, PgStatShared_Relation::stats, PgStat_TableCounts::truncdropped, PgStat_TableCounts::tuples_deleted, PgStat_StatDBEntry::tuples_deleted, PgStat_StatTabEntry::tuples_deleted, PgStat_TableCounts::tuples_fetched, PgStat_StatDBEntry::tuples_fetched, PgStat_StatTabEntry::tuples_fetched, PgStat_TableCounts::tuples_hot_updated, PgStat_StatTabEntry::tuples_hot_updated, PgStat_TableCounts::tuples_inserted, PgStat_StatDBEntry::tuples_inserted, PgStat_StatTabEntry::tuples_inserted, PgStat_TableCounts::tuples_newpage_updated, PgStat_StatTabEntry::tuples_newpage_updated, PgStat_TableCounts::tuples_returned, PgStat_StatDBEntry::tuples_returned, PgStat_StatTabEntry::tuples_returned, PgStat_TableCounts::tuples_updated, PgStat_StatDBEntry::tuples_updated, and PgStat_StatTabEntry::tuples_updated.

pgstat_relation_reset_timestamp_cb()

void pgstat_relation_reset_timestamp_cb	(	PgStatShared_Common *	header,
		TimestampTz	ts
	)

Definition at line 913 of file pgstat_relation.c.

{
    ((PgStatShared_Relation *) header)->stats.stat_reset_time = ts;
}

pgstat_report_analyze()

void pgstat_report_analyze	(	Relation	rel,
		PgStat_Counter	livetuples,
		PgStat_Counter	deadtuples,
		bool	resetcounter,
		TimestampTz	starttime
	)

Definition at line 281 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Relation *shtabentry;
    PgStat_StatTabEntry *tabentry;
    Oid         dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
    TimestampTz ts;
    PgStat_Counter elapsedtime;
 
    if (!pgstat_track_counts)
        return;
 
    /*
     * Unlike VACUUM, ANALYZE might be running inside a transaction that has
     * already inserted and/or deleted rows in the target table. ANALYZE will
     * have counted such rows as live or dead respectively. Because we will
     * report our counts of such rows at transaction end, we should subtract
     * off these counts from the update we're making now, else they'll be
     * double-counted after commit.  (This approach also ensures that the
     * shared stats entry ends up with the right numbers if we abort instead
     * of committing.)
     *
     * Waste no time on partitioned tables, though.
     */
    if (pgstat_should_count_relation(rel) &&
        rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
    {
        PgStat_TableXactStatus *trans;
 
        for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
        {
            livetuples -= trans->tuples_inserted - trans->tuples_deleted;
            deadtuples -= trans->tuples_updated + trans->tuples_deleted;
        }
        /* count stuff inserted by already-aborted subxacts, too */
        deadtuples -= rel->pgstat_info->counts.delta_dead_tuples;
        /* Since ANALYZE's counts are estimates, we could have underflowed */
        livetuples = Max(livetuples, 0);
        deadtuples = Max(deadtuples, 0);
    }
 
    /* Store the data in the table's hash table entry. */
    ts = GetCurrentTimestamp();
    elapsedtime = TimestampDifferenceMilliseconds(starttime, ts);
 
    /* block acquiring lock for the same reason as pgstat_report_autovac() */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION, dboid,
                                            RelationGetRelid(rel),
                                            false);
    /* can't get dropped while accessed */
    Assert(entry_ref != NULL && entry_ref->shared_stats != NULL);
 
    shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
    tabentry = &shtabentry->stats;
 
    tabentry->live_tuples = livetuples;
    tabentry->dead_tuples = deadtuples;
 
    /*
     * If commanded, reset mod_since_analyze to zero.  This forgets any
     * changes that were committed while the ANALYZE was in progress, but we
     * have no good way to estimate how many of those there were.
     */
    if (resetcounter)
        tabentry->mod_since_analyze = 0;
 
    if (AmAutoVacuumWorkerProcess())
    {
        tabentry->last_autoanalyze_time = ts;
        tabentry->autoanalyze_count++;
        tabentry->total_autoanalyze_time += elapsedtime;
    }
    else
    {
        tabentry->last_analyze_time = ts;
        tabentry->analyze_count++;
        tabentry->total_analyze_time += elapsedtime;
    }
 
    pgstat_unlock_entry(entry_ref);
 
    /* see pgstat_report_vacuum() */
    pgstat_flush_io(false);
    (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO);
}

References AmAutoVacuumWorkerProcess, PgStat_StatTabEntry::analyze_count, Assert(), PgStat_StatTabEntry::autoanalyze_count, PgStat_TableStatus::counts, PgStat_StatTabEntry::dead_tuples, PgStat_TableCounts::delta_dead_tuples, GetCurrentTimestamp(), if(), InvalidOid, PgStat_StatTabEntry::last_analyze_time, PgStat_StatTabEntry::last_autoanalyze_time, PgStat_StatTabEntry::live_tuples, Max, PgStat_StatTabEntry::mod_since_analyze, MyDatabaseId, PGSTAT_BACKEND_FLUSH_IO, pgstat_flush_backend(), pgstat_flush_io(), pgstat_get_entry_ref_locked(), RelationData::pgstat_info, PGSTAT_KIND_RELATION, pgstat_should_count_relation, pgstat_track_counts, pgstat_unlock_entry(), RelationData::rd_rel, RelationGetRelid, PgStat_EntryRef::shared_stats, PgStatShared_Relation::stats, TimestampDifferenceMilliseconds(), PgStat_StatTabEntry::total_analyze_time, PgStat_StatTabEntry::total_autoanalyze_time, PgStat_TableStatus::trans, and trans.

Referenced by do_analyze_rel().

pgstat_report_vacuum()

void pgstat_report_vacuum	(	Relation	rel,
		PgStat_Counter	livetuples,
		PgStat_Counter	deadtuples,
		TimestampTz	starttime
	)

Definition at line 210 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Relation *shtabentry;
    PgStat_StatTabEntry *tabentry;
    Oid         dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
    TimestampTz ts;
    PgStat_Counter elapsedtime;
 
    if (!pgstat_track_counts)
        return;
 
    /* Store the data in the table's hash table entry. */
    ts = GetCurrentTimestamp();
    elapsedtime = TimestampDifferenceMilliseconds(starttime, ts);
 
    /* block acquiring lock for the same reason as pgstat_report_autovac() */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION, dboid,
                                            RelationGetRelid(rel), false);
 
    shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
    tabentry = &shtabentry->stats;
 
    tabentry->live_tuples = livetuples;
    tabentry->dead_tuples = deadtuples;
 
    /*
     * It is quite possible that a non-aggressive VACUUM ended up skipping
     * various pages, however, we'll zero the insert counter here regardless.
     * It's currently used only to track when we need to perform an "insert"
     * autovacuum, which are mainly intended to freeze newly inserted tuples.
     * Zeroing this may just mean we'll not try to vacuum the table again
     * until enough tuples have been inserted to trigger another insert
     * autovacuum.  An anti-wraparound autovacuum will catch any persistent
     * stragglers.
     */
    tabentry->ins_since_vacuum = 0;
 
    if (AmAutoVacuumWorkerProcess())
    {
        tabentry->last_autovacuum_time = ts;
        tabentry->autovacuum_count++;
        tabentry->total_autovacuum_time += elapsedtime;
    }
    else
    {
        tabentry->last_vacuum_time = ts;
        tabentry->vacuum_count++;
        tabentry->total_vacuum_time += elapsedtime;
    }
 
    pgstat_unlock_entry(entry_ref);
 
    /*
     * Flush IO statistics now. pgstat_report_stat() will flush IO stats,
     * however this will not be called until after an entire autovacuum cycle
     * is done -- which will likely vacuum many relations -- or until the
     * VACUUM command has processed all tables and committed.
     */
    pgstat_flush_io(false);
    (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO);
}

References AmAutoVacuumWorkerProcess, PgStat_StatTabEntry::autovacuum_count, PgStat_StatTabEntry::dead_tuples, GetCurrentTimestamp(), if(), PgStat_StatTabEntry::ins_since_vacuum, InvalidOid, PgStat_StatTabEntry::last_autovacuum_time, PgStat_StatTabEntry::last_vacuum_time, PgStat_StatTabEntry::live_tuples, MyDatabaseId, PGSTAT_BACKEND_FLUSH_IO, pgstat_flush_backend(), pgstat_flush_io(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_RELATION, pgstat_track_counts, pgstat_unlock_entry(), RelationData::rd_rel, RelationGetRelid, PgStat_EntryRef::shared_stats, PgStatShared_Relation::stats, TimestampDifferenceMilliseconds(), PgStat_StatTabEntry::total_autovacuum_time, PgStat_StatTabEntry::total_vacuum_time, and PgStat_StatTabEntry::vacuum_count.

Referenced by heap_vacuum_rel().

pgstat_twophase_postabort()

void pgstat_twophase_postabort	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 782 of file pgstat_relation.c.

{
    TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
    PgStat_TableStatus *pgstat_info;
 
    /* Find or create a tabstat entry for the rel */
    pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
 
    /* Same math as in AtEOXact_PgStat, abort case */
    if (rec->truncdropped)
    {
        rec->tuples_inserted = rec->inserted_pre_truncdrop;
        rec->tuples_updated = rec->updated_pre_truncdrop;
        rec->tuples_deleted = rec->deleted_pre_truncdrop;
    }
    pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
    pgstat_info->counts.tuples_updated += rec->tuples_updated;
    pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
    pgstat_info->counts.delta_dead_tuples +=
        rec->tuples_inserted + rec->tuples_updated;
}

References PgStat_TableStatus::counts, TwoPhasePgStatRecord::deleted_pre_truncdrop, PgStat_TableCounts::delta_dead_tuples, TwoPhasePgStatRecord::id, TwoPhasePgStatRecord::inserted_pre_truncdrop, pgstat_prep_relation_pending(), TwoPhasePgStatRecord::shared, TwoPhasePgStatRecord::truncdropped, TwoPhasePgStatRecord::tuples_deleted, PgStat_TableCounts::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, PgStat_TableCounts::tuples_inserted, TwoPhasePgStatRecord::tuples_updated, PgStat_TableCounts::tuples_updated, and TwoPhasePgStatRecord::updated_pre_truncdrop.

pgstat_twophase_postcommit()

void pgstat_twophase_postcommit	(	FullTransactionId	fxid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 746 of file pgstat_relation.c.

{
    TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
    PgStat_TableStatus *pgstat_info;
 
    /* Find or create a tabstat entry for the rel */
    pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
 
    /* Same math as in AtEOXact_PgStat, commit case */
    pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
    pgstat_info->counts.tuples_updated += rec->tuples_updated;
    pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
    pgstat_info->counts.truncdropped = rec->truncdropped;
    if (rec->truncdropped)
    {
        /* forget live/dead stats seen by backend thus far */
        pgstat_info->counts.delta_live_tuples = 0;
        pgstat_info->counts.delta_dead_tuples = 0;
    }
    pgstat_info->counts.delta_live_tuples +=
        rec->tuples_inserted - rec->tuples_deleted;
    pgstat_info->counts.delta_dead_tuples +=
        rec->tuples_updated + rec->tuples_deleted;
    pgstat_info->counts.changed_tuples +=
        rec->tuples_inserted + rec->tuples_updated +
        rec->tuples_deleted;
}

References PgStat_TableCounts::changed_tuples, PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, PgStat_TableCounts::delta_live_tuples, TwoPhasePgStatRecord::id, pgstat_prep_relation_pending(), TwoPhasePgStatRecord::shared, TwoPhasePgStatRecord::truncdropped, PgStat_TableCounts::truncdropped, TwoPhasePgStatRecord::tuples_deleted, PgStat_TableCounts::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, PgStat_TableCounts::tuples_inserted, TwoPhasePgStatRecord::tuples_updated, and PgStat_TableCounts::tuples_updated.

pgstat_unlink_relation()

void pgstat_unlink_relation

(

Relation

rel

)

Definition at line 152 of file pgstat_relation.c.

{
    /* remove the link to stats info if any */
    if (rel->pgstat_info == NULL)
        return;
 
    /* link sanity check */
    Assert(rel->pgstat_info->relation == rel);
    rel->pgstat_info->relation = NULL;
    rel->pgstat_info = NULL;
}

References Assert(), RelationData::pgstat_info, and PgStat_TableStatus::relation.

Referenced by pgstat_init_relation(), pgstat_relation_delete_pending_cb(), and RelationDestroyRelation().

pgstat_update_heap_dead_tuples()

void pgstat_update_heap_dead_tuples	(	Relation	rel,
		int	delta
	)

Definition at line 452 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        pgstat_info->counts.delta_dead_tuples -= delta;
    }
}

References PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, RelationData::pgstat_info, and pgstat_should_count_relation.

Referenced by heap_page_prune_opt().

PostPrepare_PgStat_Relations()

void PostPrepare_PgStat_Relations

(

PgStat_SubXactStatus *

xact_state

)

Definition at line 727 of file pgstat_relation.c.

{
    PgStat_TableXactStatus *trans;
 
    for (trans = xact_state->first; trans != NULL; trans = trans->next)
    {
        PgStat_TableStatus *tabstat;
 
        tabstat = trans->parent;
        tabstat->trans = NULL;
    }
}

References PgStat_SubXactStatus::first, PgStat_TableStatus::trans, and trans.

Referenced by PostPrepare_PgStat().

restore_truncdrop_counters()

static void restore_truncdrop_counters ( PgStat_TableXactStatus *  trans )

static

Definition at line 1003 of file pgstat_relation.c.

{
    if (trans->truncdropped)
    {
        trans->tuples_inserted = trans->inserted_pre_truncdrop;
        trans->tuples_updated = trans->updated_pre_truncdrop;
        trans->tuples_deleted = trans->deleted_pre_truncdrop;
    }
}

References trans.

Referenced by AtEOSubXact_PgStat_Relations(), and AtEOXact_PgStat_Relations().

save_truncdrop_counters()

static void save_truncdrop_counters ( PgStat_TableXactStatus *  trans, bool  is_drop  )

static

Definition at line 988 of file pgstat_relation.c.

{
    if (!trans->truncdropped || is_drop)
    {
        trans->inserted_pre_truncdrop = trans->tuples_inserted;
        trans->updated_pre_truncdrop = trans->tuples_updated;
        trans->deleted_pre_truncdrop = trans->tuples_deleted;
        trans->truncdropped = true;
    }
}

References trans.

Referenced by AtEOSubXact_PgStat_Relations(), pgstat_count_truncate(), and pgstat_drop_relation().