#include "datatype/timestamp.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "utils/backend_progress.h"
#include "utils/backend_status.h"
#include "utils/relcache.h"
#include "utils/wait_event.h"

Include dependency graph for pgstat.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PgStat_FunctionCounts

struct	PgStat_FunctionCallUsage

struct	PgStat_BackendSubEntry

struct	PgStat_TableCounts

struct	PgStat_TableStatus

struct	PgStat_TableXactStatus

struct	PgStat_ArchiverStats

struct	PgStat_BgWriterStats

struct	PgStat_CheckpointerStats

struct	PgStat_BktypeIO

struct	PgStat_IO

struct	PgStat_StatDBEntry

struct	PgStat_StatFuncEntry

struct	PgStat_StatReplSlotEntry

struct	PgStat_SLRUStats

struct	PgStat_StatSubEntry

struct	PgStat_StatTabEntry

struct	PgStat_WalStats

struct	PgStat_PendingWalStats

Macros
#define	PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat"

#define	PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/pgstat.stat"

#define	PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/pgstat.tmp"

#define	PG_STAT_TMP_DIR "pg_stat_tmp"

#define	PGSTAT_KIND_FIRST_VALID PGSTAT_KIND_DATABASE

#define	PGSTAT_KIND_LAST PGSTAT_KIND_WAL

#define	PGSTAT_NUM_KINDS (PGSTAT_KIND_LAST + 1)

#define	PGSTAT_FILE_FORMAT_ID 0x01A5BCAC

#define	IOOBJECT_NUM_TYPES (IOOBJECT_TEMP_RELATION + 1)

#define	IOCONTEXT_NUM_TYPES (IOCONTEXT_VACUUM + 1)

#define	IOOP_NUM_TYPES (IOOP_WRITEBACK + 1)

#define	pgstat_count_buffer_read_time(n) (pgStatBlockReadTime += (n))

#define	pgstat_count_buffer_write_time(n) (pgStatBlockWriteTime += (n))

#define	pgstat_count_conn_active_time(n) (pgStatActiveTime += (n))

#define	pgstat_count_conn_txn_idle_time(n) (pgStatTransactionIdleTime += (n))

#define	pgstat_should_count_relation(rel)

#define	pgstat_count_heap_scan(rel)

#define	pgstat_count_heap_getnext(rel)

#define	pgstat_count_heap_fetch(rel)

#define	pgstat_count_index_scan(rel)

#define	pgstat_count_index_tuples(rel, n)

#define	pgstat_count_buffer_read(rel)

#define	pgstat_count_buffer_hit(rel)

Typedefs
typedef enum PgStat_Kind	PgStat_Kind

typedef enum TrackFunctionsLevel	TrackFunctionsLevel

typedef enum PgStat_FetchConsistency	PgStat_FetchConsistency

typedef enum SessionEndType	SessionEndType

typedef int64	PgStat_Counter

typedef struct PgStat_FunctionCounts	PgStat_FunctionCounts

typedef struct PgStat_FunctionCallUsage	PgStat_FunctionCallUsage

typedef struct PgStat_BackendSubEntry	PgStat_BackendSubEntry

typedef struct PgStat_TableCounts	PgStat_TableCounts

typedef struct PgStat_TableStatus	PgStat_TableStatus

typedef struct PgStat_TableXactStatus	PgStat_TableXactStatus

typedef struct PgStat_ArchiverStats	PgStat_ArchiverStats

typedef struct PgStat_BgWriterStats	PgStat_BgWriterStats

typedef struct PgStat_CheckpointerStats	PgStat_CheckpointerStats

typedef enum IOObject	IOObject

typedef enum IOContext	IOContext

typedef enum IOOp	IOOp

typedef struct PgStat_BktypeIO	PgStat_BktypeIO

typedef struct PgStat_IO	PgStat_IO

typedef struct PgStat_StatDBEntry	PgStat_StatDBEntry

typedef struct PgStat_StatFuncEntry	PgStat_StatFuncEntry

typedef struct PgStat_StatReplSlotEntry	PgStat_StatReplSlotEntry

typedef struct PgStat_SLRUStats	PgStat_SLRUStats

typedef struct PgStat_StatSubEntry	PgStat_StatSubEntry

typedef struct PgStat_StatTabEntry	PgStat_StatTabEntry

typedef struct PgStat_WalStats	PgStat_WalStats

typedef struct PgStat_PendingWalStats	PgStat_PendingWalStats

Enumerations
enum	PgStat_Kind { PGSTAT_KIND_INVALID = 0 , PGSTAT_KIND_DATABASE , PGSTAT_KIND_RELATION , PGSTAT_KIND_FUNCTION , PGSTAT_KIND_REPLSLOT , PGSTAT_KIND_SUBSCRIPTION , PGSTAT_KIND_ARCHIVER , PGSTAT_KIND_BGWRITER , PGSTAT_KIND_CHECKPOINTER , PGSTAT_KIND_IO , PGSTAT_KIND_SLRU , PGSTAT_KIND_WAL }

enum	TrackFunctionsLevel { TRACK_FUNC_OFF , TRACK_FUNC_PL , TRACK_FUNC_ALL }

enum	PgStat_FetchConsistency { PGSTAT_FETCH_CONSISTENCY_NONE , PGSTAT_FETCH_CONSISTENCY_CACHE , PGSTAT_FETCH_CONSISTENCY_SNAPSHOT }

enum	SessionEndType { DISCONNECT_NOT_YET , DISCONNECT_NORMAL , DISCONNECT_CLIENT_EOF , DISCONNECT_FATAL , DISCONNECT_KILLED }

enum	IOObject { IOOBJECT_RELATION , IOOBJECT_TEMP_RELATION }

enum	IOContext { IOCONTEXT_BULKREAD , IOCONTEXT_BULKWRITE , IOCONTEXT_NORMAL , IOCONTEXT_VACUUM }

enum	IOOp { IOOP_EVICT , IOOP_EXTEND , IOOP_FSYNC , IOOP_HIT , IOOP_READ , IOOP_REUSE , IOOP_WRITE , IOOP_WRITEBACK }

Functions
Size	StatsShmemSize (void)

void	StatsShmemInit (void)

void	pgstat_restore_stats (void)

void	pgstat_discard_stats (void)

void	pgstat_before_server_shutdown (int code, Datum arg)

void	pgstat_initialize (void)

long	pgstat_report_stat (bool force)

void	pgstat_force_next_flush (void)

void	pgstat_reset_counters (void)

void	pgstat_reset (PgStat_Kind kind, Oid dboid, Oid objoid)

void	pgstat_reset_of_kind (PgStat_Kind kind)

void	pgstat_clear_snapshot (void)

TimestampTz	pgstat_get_stat_snapshot_timestamp (bool *have_snapshot)

PgStat_Kind	pgstat_get_kind_from_str (char *kind_str)

bool	pgstat_have_entry (PgStat_Kind kind, Oid dboid, Oid objoid)

void	pgstat_report_archiver (const char *xlog, bool failed)

PgStat_ArchiverStats *	pgstat_fetch_stat_archiver (void)

void	pgstat_report_bgwriter (void)

PgStat_BgWriterStats *	pgstat_fetch_stat_bgwriter (void)

void	pgstat_report_checkpointer (void)

PgStat_CheckpointerStats *	pgstat_fetch_stat_checkpointer (void)

bool	pgstat_bktype_io_stats_valid (PgStat_BktypeIO *backend_io, BackendType bktype)

void	pgstat_count_io_op (IOObject io_object, IOContext io_context, IOOp io_op)

void	pgstat_count_io_op_n (IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt)

instr_time	pgstat_prepare_io_time (void)

void	pgstat_count_io_op_time (IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt)

PgStat_IO *	pgstat_fetch_stat_io (void)

const char *	pgstat_get_io_context_name (IOContext io_context)

const char *	pgstat_get_io_object_name (IOObject io_object)

bool	pgstat_tracks_io_bktype (BackendType bktype)

bool	pgstat_tracks_io_object (BackendType bktype, IOObject io_object, IOContext io_context)

bool	pgstat_tracks_io_op (BackendType bktype, IOObject io_object, IOContext io_context, IOOp io_op)

void	pgstat_drop_database (Oid databaseid)

void	pgstat_report_autovac (Oid dboid)

void	pgstat_report_recovery_conflict (int reason)

void	pgstat_report_deadlock (void)

void	pgstat_report_checksum_failures_in_db (Oid dboid, int failurecount)

void	pgstat_report_checksum_failure (void)

void	pgstat_report_connect (Oid dboid)

PgStat_StatDBEntry *	pgstat_fetch_stat_dbentry (Oid dboid)

void	pgstat_create_function (Oid proid)

void	pgstat_drop_function (Oid proid)

void	pgstat_init_function_usage (struct FunctionCallInfoBaseData fcinfo, PgStat_FunctionCallUsage fcu)

void	pgstat_end_function_usage (PgStat_FunctionCallUsage *fcu, bool finalize)

PgStat_StatFuncEntry *	pgstat_fetch_stat_funcentry (Oid func_id)

PgStat_FunctionCounts *	find_funcstat_entry (Oid func_id)

void	pgstat_create_relation (Relation rel)

void	pgstat_drop_relation (Relation rel)

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_report_vacuum (Oid tableoid, bool shared, PgStat_Counter livetuples, PgStat_Counter deadtuples)

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

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)

void	pgstat_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)

void	pgstat_twophase_postabort (TransactionId xid, uint16 info, void *recdata, uint32 len)

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	pgstat_reset_replslot (const char *name)

void	pgstat_report_replslot (struct ReplicationSlot slot, const PgStat_StatReplSlotEntry repSlotStat)

void	pgstat_create_replslot (struct ReplicationSlot *slot)

void	pgstat_acquire_replslot (struct ReplicationSlot *slot)

void	pgstat_drop_replslot (struct ReplicationSlot *slot)

PgStat_StatReplSlotEntry *	pgstat_fetch_replslot (NameData slotname)

void	pgstat_reset_slru (const char *)

void	pgstat_count_slru_page_zeroed (int slru_idx)

void	pgstat_count_slru_page_hit (int slru_idx)

void	pgstat_count_slru_page_read (int slru_idx)

void	pgstat_count_slru_page_written (int slru_idx)

void	pgstat_count_slru_page_exists (int slru_idx)

void	pgstat_count_slru_flush (int slru_idx)

void	pgstat_count_slru_truncate (int slru_idx)

const char *	pgstat_get_slru_name (int slru_idx)

int	pgstat_get_slru_index (const char *name)

PgStat_SLRUStats *	pgstat_fetch_slru (void)

void	pgstat_report_subscription_error (Oid subid, bool is_apply_error)

void	pgstat_create_subscription (Oid subid)

void	pgstat_drop_subscription (Oid subid)

PgStat_StatSubEntry *	pgstat_fetch_stat_subscription (Oid subid)

void	AtEOXact_PgStat (bool isCommit, bool parallel)

void	AtEOSubXact_PgStat (bool isCommit, int nestDepth)

void	AtPrepare_PgStat (void)

void	PostPrepare_PgStat (void)

int	pgstat_get_transactional_drops (bool isCommit, struct xl_xact_stats_item **items)

void	pgstat_execute_transactional_drops (int ndrops, struct xl_xact_stats_item *items, bool is_redo)

void	pgstat_report_wal (bool force)

PgStat_WalStats *	pgstat_fetch_stat_wal (void)

Macro Definition Documentation

◆ IOCONTEXT_NUM_TYPES

#define IOCONTEXT_NUM_TYPES (IOCONTEXT_VACUUM + 1)

Definition at line 292 of file pgstat.h.

◆ IOOBJECT_NUM_TYPES

#define IOOBJECT_NUM_TYPES (IOOBJECT_TEMP_RELATION + 1)

Definition at line 282 of file pgstat.h.

◆ IOOP_NUM_TYPES

#define IOOP_NUM_TYPES (IOOP_WRITEBACK + 1)

Definition at line 306 of file pgstat.h.

◆ PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR "pg_stat_tmp"

Definition at line 32 of file pgstat.h.

◆ pgstat_count_buffer_hit

#define pgstat_count_buffer_hit ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.blocks_hit++;                \
    } while (0)

Definition at line 638 of file pgstat.h.

◆ pgstat_count_buffer_read

#define pgstat_count_buffer_read ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.blocks_fetched++;            \
    } while (0)

Definition at line 633 of file pgstat.h.

◆ pgstat_count_buffer_read_time

#define pgstat_count_buffer_read_time ( n ) (pgStatBlockReadTime += (n))

Definition at line 550 of file pgstat.h.

◆ pgstat_count_buffer_write_time

#define pgstat_count_buffer_write_time ( n ) (pgStatBlockWriteTime += (n))

Definition at line 552 of file pgstat.h.

◆ pgstat_count_conn_active_time

#define pgstat_count_conn_active_time ( n ) (pgStatActiveTime += (n))

Definition at line 554 of file pgstat.h.

◆ pgstat_count_conn_txn_idle_time

#define pgstat_count_conn_txn_idle_time ( n ) (pgStatTransactionIdleTime += (n))

Definition at line 556 of file pgstat.h.

◆ pgstat_count_heap_fetch

#define pgstat_count_heap_fetch ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_fetched++;            \
    } while (0)

Definition at line 618 of file pgstat.h.

◆ pgstat_count_heap_getnext

#define pgstat_count_heap_getnext ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_returned++;           \
    } while (0)

Definition at line 613 of file pgstat.h.

◆ pgstat_count_heap_scan

#define pgstat_count_heap_scan ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.numscans++;                  \
    } while (0)

Definition at line 608 of file pgstat.h.

◆ pgstat_count_index_scan

#define pgstat_count_index_scan ( rel )

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.numscans++;                  \
    } while (0)

Definition at line 623 of file pgstat.h.

◆ pgstat_count_index_tuples

#define pgstat_count_index_tuples	(	rel,
		n
	)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_returned += (n);      \
    } while (0)

Definition at line 628 of file pgstat.h.

◆ PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID 0x01A5BCAC

Definition at line 238 of file pgstat.h.

◆ PGSTAT_KIND_FIRST_VALID

#define PGSTAT_KIND_FIRST_VALID PGSTAT_KIND_DATABASE

Definition at line 56 of file pgstat.h.

◆ PGSTAT_KIND_LAST

#define PGSTAT_KIND_LAST PGSTAT_KIND_WAL

Definition at line 57 of file pgstat.h.

◆ PGSTAT_NUM_KINDS

#define PGSTAT_NUM_KINDS (PGSTAT_KIND_LAST + 1)

Definition at line 58 of file pgstat.h.

◆ pgstat_should_count_relation

#define pgstat_should_count_relation ( rel )

Value:

(likely((rel)->pgstat_info != NULL) ? true : \

((rel)->pgstat_enabled ? pgstat_assoc_relation(rel), true : false))

likely

#define likely(x)

Definition: c.h:299

true

return true

Definition: isn.c:126

pgstat_assoc_relation

void pgstat_assoc_relation(Relation rel)

Definition: pgstat_relation.c:133

Definition at line 602 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat"

Definition at line 27 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/pgstat.stat"

Definition at line 28 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/pgstat.tmp"

Definition at line 29 of file pgstat.h.

Typedef Documentation

◆ IOContext

typedef enum IOContext IOContext

◆ IOObject

typedef enum IOObject IOObject

◆ IOOp

typedef enum IOOp IOOp

◆ PgStat_ArchiverStats

typedef struct PgStat_ArchiverStats PgStat_ArchiverStats

◆ PgStat_BackendSubEntry

typedef struct PgStat_BackendSubEntry PgStat_BackendSubEntry

◆ PgStat_BgWriterStats

typedef struct PgStat_BgWriterStats PgStat_BgWriterStats

◆ PgStat_BktypeIO

typedef struct PgStat_BktypeIO PgStat_BktypeIO

◆ PgStat_CheckpointerStats

typedef struct PgStat_CheckpointerStats PgStat_CheckpointerStats

◆ PgStat_Counter

typedef int64 PgStat_Counter

Definition at line 89 of file pgstat.h.

◆ PgStat_FetchConsistency

typedef enum PgStat_FetchConsistency PgStat_FetchConsistency

◆ PgStat_FunctionCallUsage

typedef struct PgStat_FunctionCallUsage PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

typedef struct PgStat_FunctionCounts PgStat_FunctionCounts

◆ PgStat_IO

typedef struct PgStat_IO PgStat_IO

◆ PgStat_Kind

typedef enum PgStat_Kind PgStat_Kind

◆ PgStat_PendingWalStats

typedef struct PgStat_PendingWalStats PgStat_PendingWalStats

◆ PgStat_SLRUStats

typedef struct PgStat_SLRUStats PgStat_SLRUStats

◆ PgStat_StatDBEntry

typedef struct PgStat_StatDBEntry PgStat_StatDBEntry

◆ PgStat_StatFuncEntry

typedef struct PgStat_StatFuncEntry PgStat_StatFuncEntry

◆ PgStat_StatReplSlotEntry

typedef struct PgStat_StatReplSlotEntry PgStat_StatReplSlotEntry

◆ PgStat_StatSubEntry

typedef struct PgStat_StatSubEntry PgStat_StatSubEntry

◆ PgStat_StatTabEntry

typedef struct PgStat_StatTabEntry PgStat_StatTabEntry

◆ PgStat_TableCounts

typedef struct PgStat_TableCounts PgStat_TableCounts

◆ PgStat_TableStatus

typedef struct PgStat_TableStatus PgStat_TableStatus

◆ PgStat_TableXactStatus

typedef struct PgStat_TableXactStatus PgStat_TableXactStatus

◆ PgStat_WalStats

typedef struct PgStat_WalStats PgStat_WalStats

◆ SessionEndType

typedef enum SessionEndType SessionEndType

◆ TrackFunctionsLevel

typedef enum TrackFunctionsLevel TrackFunctionsLevel

Enumeration Type Documentation

◆ IOContext

enum IOContext

Enumerator
IOCONTEXT_BULKREAD
IOCONTEXT_BULKWRITE
IOCONTEXT_NORMAL
IOCONTEXT_VACUUM

Definition at line 284 of file pgstat.h.

 {
     IOCONTEXT_BULKREAD,
     IOCONTEXT_BULKWRITE,
     IOCONTEXT_NORMAL,
     IOCONTEXT_VACUUM,
 } IOContext;

◆ IOObject

enum IOObject

Enumerator
IOOBJECT_RELATION
IOOBJECT_TEMP_RELATION

Definition at line 276 of file pgstat.h.

 {
     IOOBJECT_RELATION,
     IOOBJECT_TEMP_RELATION,
 } IOObject;

◆ IOOp

enum IOOp

Enumerator
IOOP_EVICT
IOOP_EXTEND
IOOP_FSYNC
IOOP_HIT
IOOP_READ
IOOP_REUSE
IOOP_WRITE
IOOP_WRITEBACK

Definition at line 294 of file pgstat.h.

 {
     IOOP_EVICT,
     IOOP_EXTEND,
     IOOP_FSYNC,
     IOOP_HIT,
     IOOP_READ,
     IOOP_REUSE,
     IOOP_WRITE,
     IOOP_WRITEBACK,
 } IOOp;

◆ PgStat_FetchConsistency

enum PgStat_FetchConsistency

Enumerator
PGSTAT_FETCH_CONSISTENCY_NONE
PGSTAT_FETCH_CONSISTENCY_CACHE
PGSTAT_FETCH_CONSISTENCY_SNAPSHOT

Definition at line 68 of file pgstat.h.

 {
     PGSTAT_FETCH_CONSISTENCY_NONE,
     PGSTAT_FETCH_CONSISTENCY_CACHE,
     PGSTAT_FETCH_CONSISTENCY_SNAPSHOT,
 } PgStat_FetchConsistency;

◆ PgStat_Kind

enum PgStat_Kind

Enumerator
PGSTAT_KIND_INVALID
PGSTAT_KIND_DATABASE
PGSTAT_KIND_RELATION
PGSTAT_KIND_FUNCTION
PGSTAT_KIND_REPLSLOT
PGSTAT_KIND_SUBSCRIPTION
PGSTAT_KIND_ARCHIVER
PGSTAT_KIND_BGWRITER
PGSTAT_KIND_CHECKPOINTER
PGSTAT_KIND_IO
PGSTAT_KIND_SLRU
PGSTAT_KIND_WAL

Definition at line 35 of file pgstat.h.

 {
     /* use 0 for INVALID, to catch zero-initialized data */
     PGSTAT_KIND_INVALID = 0,
  
     /* stats for variable-numbered objects */
     PGSTAT_KIND_DATABASE,       /* database-wide statistics */
     PGSTAT_KIND_RELATION,       /* per-table statistics */
     PGSTAT_KIND_FUNCTION,       /* per-function statistics */
     PGSTAT_KIND_REPLSLOT,       /* per-slot statistics */
     PGSTAT_KIND_SUBSCRIPTION,   /* per-subscription statistics */
  
     /* stats for fixed-numbered objects */
     PGSTAT_KIND_ARCHIVER,
     PGSTAT_KIND_BGWRITER,
     PGSTAT_KIND_CHECKPOINTER,
     PGSTAT_KIND_IO,
     PGSTAT_KIND_SLRU,
     PGSTAT_KIND_WAL,
 } PgStat_Kind;

◆ SessionEndType

enum SessionEndType

Enumerator
DISCONNECT_NOT_YET
DISCONNECT_NORMAL
DISCONNECT_CLIENT_EOF
DISCONNECT_FATAL
DISCONNECT_KILLED

Definition at line 76 of file pgstat.h.

 {
     DISCONNECT_NOT_YET,         /* still active */
     DISCONNECT_NORMAL,
     DISCONNECT_CLIENT_EOF,
     DISCONNECT_FATAL,
     DISCONNECT_KILLED
 } SessionEndType;

◆ TrackFunctionsLevel

enum TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF
TRACK_FUNC_PL
TRACK_FUNC_ALL

Definition at line 61 of file pgstat.h.

 {
     TRACK_FUNC_OFF,
     TRACK_FUNC_PL,
     TRACK_FUNC_ALL
 }           TrackFunctionsLevel;

Function Documentation

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat	(	bool	isCommit,
		int	nestDepth
	)

Definition at line 113 of file pgstat_xact.c.

 {
     PgStat_SubXactStatus *xact_state;
  
     /* merge the sub-transaction's transactional stats into the parent */
     xact_state = pgStatXactStack;
     if (xact_state != NULL &&
         xact_state->nest_level >= nestDepth)
     {
         /* delink xact_state from stack immediately to simplify reuse case */
         pgStatXactStack = xact_state->prev;
  
         AtEOSubXact_PgStat_Relations(xact_state, isCommit, nestDepth);
         AtEOSubXact_PgStat_DroppedStats(xact_state, isCommit, nestDepth);
  
         pfree(xact_state);
     }
 }

References AtEOSubXact_PgStat_DroppedStats(), AtEOSubXact_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pfree(), pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AtEOXact_PgStat()

void AtEOXact_PgStat	(	bool	isCommit,
		bool	parallel
	)

Definition at line 41 of file pgstat_xact.c.

 {
     PgStat_SubXactStatus *xact_state;
  
     AtEOXact_PgStat_Database(isCommit, parallel);
  
     /* handle transactional stats information */
     xact_state = pgStatXactStack;
     if (xact_state != NULL)
     {
         Assert(xact_state->nest_level == 1);
         Assert(xact_state->prev == NULL);
  
         AtEOXact_PgStat_Relations(xact_state, isCommit);
         AtEOXact_PgStat_DroppedStats(xact_state, isCommit);
     }
     pgStatXactStack = NULL;
  
     /* Make sure any stats snapshot is thrown away */
     pgstat_clear_snapshot();
 }

References Assert(), AtEOXact_PgStat_Database(), AtEOXact_PgStat_DroppedStats(), AtEOXact_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pgstat_clear_snapshot(), pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by AbortTransaction(), CommitTransaction(), and FinishPreparedTransaction().

◆ AtPrepare_PgStat()

void AtPrepare_PgStat ( void )

Definition at line 190 of file pgstat_xact.c.

 {
     PgStat_SubXactStatus *xact_state;
  
     xact_state = pgStatXactStack;
     if (xact_state != NULL)
     {
         Assert(xact_state->nest_level == 1);
         Assert(xact_state->prev == NULL);
  
         AtPrepare_PgStat_Relations(xact_state);
     }
 }

References Assert(), AtPrepare_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by PrepareTransaction().

◆ find_funcstat_entry()

PgStat_FunctionCounts* find_funcstat_entry ( Oid func_id )

Definition at line 223 of file pgstat_function.c.

 {
     PgStat_EntryRef *entry_ref;
  
     entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_FUNCTION, MyDatabaseId, func_id);
  
     if (entry_ref)
         return entry_ref->pending;
     return NULL;
 }

References MyDatabaseId, PgStat_EntryRef::pending, pgstat_fetch_pending_entry(), and PGSTAT_KIND_FUNCTION.

Referenced by pg_stat_get_xact_function_calls().

◆ find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry ( Oid rel_id )

Definition at line 484 of file pgstat_relation.c.

 {
     PgStat_EntryRef *entry_ref;
  
     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 entry_ref->pending;
     return NULL;
 }

References InvalidOid, MyDatabaseId, PgStat_EntryRef::pending, pgstat_fetch_pending_entry(), and PGSTAT_KIND_RELATION.

Referenced by pg_stat_get_xact_tuples_deleted(), pg_stat_get_xact_tuples_inserted(), and pg_stat_get_xact_tuples_updated().

◆ pgstat_acquire_replslot()

void pgstat_acquire_replslot ( struct ReplicationSlot * slot )

Definition at line 144 of file pgstat_replslot.c.

 {
     pgstat_get_entry_ref(PGSTAT_KIND_REPLSLOT, InvalidOid,
                          ReplicationSlotIndex(slot), true, NULL);
 }

References InvalidOid, pgstat_get_entry_ref(), PGSTAT_KIND_REPLSLOT, and ReplicationSlotIndex().

Referenced by ReplicationSlotAcquire().

◆ pgstat_assoc_relation()

void pgstat_assoc_relation ( Relation rel )

Definition at line 133 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_before_server_shutdown()

void pgstat_before_server_shutdown	(	int	code,
		Datum	arg
	)

Definition at line 465 of file pgstat.c.

 {
     Assert(pgStatLocal.shmem != NULL);
     Assert(!pgStatLocal.shmem->is_shutdown);
  
     /*
      * Stats should only be reported after pgstat_initialize() and before
      * pgstat_shutdown(). This is a convenient point to catch most violations
      * of this rule.
      */
     Assert(pgstat_is_initialized && !pgstat_is_shutdown);
  
     /* flush out our own pending changes before writing out */
     pgstat_report_stat(true);
  
     /*
      * Only write out file during normal shutdown. Don't even signal that
      * we've shutdown during irregular shutdowns, because the shutdown
      * sequence isn't coordinated to ensure this backend shuts down last.
      */
     if (code == 0)
     {
         pgStatLocal.shmem->is_shutdown = true;
         pgstat_write_statsfile();
     }
 }

References Assert(), PgStat_ShmemControl::is_shutdown, pgstat_report_stat(), pgstat_write_statsfile(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by CheckpointerMain(), and InitPostgres().

◆ pgstat_bktype_io_stats_valid()

bool pgstat_bktype_io_stats_valid	(	PgStat_BktypeIO *	backend_io,
		BackendType	bktype
	)

Definition at line 46 of file pgstat_io.c.

 {
     for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++)
     {
         for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
         {
             for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
             {
                 /* we do track it */
                 if (pgstat_tracks_io_op(bktype, io_object, io_context, io_op))
                 {
                     /* ensure that if IO times are non-zero, counts are > 0 */
                     if (backend_io->times[io_object][io_context][io_op] != 0 &&
                         backend_io->counts[io_object][io_context][io_op] <= 0)
                         return false;
  
                     continue;
                 }
  
                 /* we don't track it, and it is not 0 */
                 if (backend_io->counts[io_object][io_context][io_op] != 0)
                     return false;
             }
         }
     }
  
     return true;
 }

References PgStat_BktypeIO::counts, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, pgstat_tracks_io_op(), and PgStat_BktypeIO::times.

Referenced by pg_stat_get_io(), and pgstat_flush_io().

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void )

Definition at line 785 of file pgstat.c.

 {
     pgstat_assert_is_up();
  
     memset(&pgStatLocal.snapshot.fixed_valid, 0,
            sizeof(pgStatLocal.snapshot.fixed_valid));
     pgStatLocal.snapshot.stats = NULL;
     pgStatLocal.snapshot.mode = PGSTAT_FETCH_CONSISTENCY_NONE;
  
     /* Release memory, if any was allocated */
     if (pgStatLocal.snapshot.context)
     {
         MemoryContextDelete(pgStatLocal.snapshot.context);
  
         /* Reset variables */
         pgStatLocal.snapshot.context = NULL;
     }
  
     /*
      * Historically the backend_status.c facilities lived in this file, and
      * were reset with the same function. For now keep it that way, and
      * forward the reset request.
      */
     pgstat_clear_backend_activity_snapshot();
  
     /* Reset this flag, as it may be possible that a cleanup was forced. */
     force_stats_snapshot_clear = false;
 }

References PgStat_Snapshot::context, PgStat_Snapshot::fixed_valid, force_stats_snapshot_clear, MemoryContextDelete(), PgStat_Snapshot::mode, pgstat_assert_is_up, pgstat_clear_backend_activity_snapshot(), PGSTAT_FETCH_CONSISTENCY_NONE, pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::stats.

Referenced by AtEOXact_PgStat(), pg_stat_clear_snapshot(), pgstat_get_stat_snapshot_timestamp(), pgstat_prep_snapshot(), and PostPrepare_PgStat().

◆ pgstat_copy_relation_stats()

void pgstat_copy_relation_stats	(	Relation	dst,
		Relation	src
	)

Definition at line 59 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 402 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 361 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 ExecRefreshMatView(), heap_insert(), and heap_multi_insert().

◆ pgstat_count_heap_update()

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

Definition at line 376 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_io_op()

void pgstat_count_io_op	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op
	)

Definition at line 77 of file pgstat_io.c.

 {
     pgstat_count_io_op_n(io_object, io_context, io_op, 1);
 }

References pgstat_count_io_op_n().

Referenced by GetLocalVictimBuffer(), GetVictimBuffer(), and ReadBuffer_common().

◆ pgstat_count_io_op_n()

void pgstat_count_io_op_n	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		uint32	cnt
	)

Definition at line 83 of file pgstat_io.c.

 {
     Assert((unsigned int) io_object < IOOBJECT_NUM_TYPES);
     Assert((unsigned int) io_context < IOCONTEXT_NUM_TYPES);
     Assert((unsigned int) io_op < IOOP_NUM_TYPES);
     Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
  
     PendingIOStats.counts[io_object][io_context][io_op] += cnt;
  
     have_iostats = true;
 }

References Assert(), PgStat_PendingIO::counts, have_iostats, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, MyBackendType, PendingIOStats, and pgstat_tracks_io_op().

Referenced by pgstat_count_io_op(), and pgstat_count_io_op_time().

◆ pgstat_count_io_op_time()

void pgstat_count_io_op_time	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		instr_time	start_time,
		uint32	cnt
	)

Definition at line 112 of file pgstat_io.c.

 {
     if (track_io_timing)
     {
         instr_time  io_time;
  
         INSTR_TIME_SET_CURRENT(io_time);
         INSTR_TIME_SUBTRACT(io_time, start_time);
  
         if (io_op == IOOP_WRITE)
         {
             pgstat_count_buffer_write_time(INSTR_TIME_GET_MICROSEC(io_time));
             if (io_object == IOOBJECT_RELATION)
                 INSTR_TIME_ADD(pgBufferUsage.blk_write_time, io_time);
         }
         else if (io_op == IOOP_READ)
         {
             pgstat_count_buffer_read_time(INSTR_TIME_GET_MICROSEC(io_time));
             if (io_object == IOOBJECT_RELATION)
                 INSTR_TIME_ADD(pgBufferUsage.blk_read_time, io_time);
         }
  
         INSTR_TIME_ADD(PendingIOStats.pending_times[io_object][io_context][io_op],
                        io_time);
     }
  
     pgstat_count_io_op_n(io_object, io_context, io_op, cnt);
 }

References BufferUsage::blk_read_time, BufferUsage::blk_write_time, INSTR_TIME_ADD, INSTR_TIME_GET_MICROSEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, IOOBJECT_RELATION, IOOP_READ, IOOP_WRITE, PgStat_PendingIO::pending_times, PendingIOStats, pgBufferUsage, pgstat_count_buffer_read_time, pgstat_count_buffer_write_time, pgstat_count_io_op_n(), start_time, and track_io_timing.

Referenced by ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushRelationBuffers(), GetLocalVictimBuffer(), IssuePendingWritebacks(), mdsyncfiletag(), ReadBuffer_common(), and register_dirty_segment().

◆ pgstat_count_slru_flush()

void pgstat_count_slru_flush ( int slru_idx )

Definition at line 89 of file pgstat_slru.c.

 {
     get_slru_entry(slru_idx)->flush += 1;
 }

References PgStat_SLRUStats::flush, and get_slru_entry().

Referenced by SimpleLruWriteAll().

◆ pgstat_count_slru_page_exists()

void pgstat_count_slru_page_exists ( int slru_idx )

Definition at line 71 of file pgstat_slru.c.

 {
     get_slru_entry(slru_idx)->blocks_exists += 1;
 }

References PgStat_SLRUStats::blocks_exists, and get_slru_entry().

Referenced by SimpleLruDoesPhysicalPageExist().

◆ pgstat_count_slru_page_hit()

void pgstat_count_slru_page_hit ( int slru_idx )

Definition at line 65 of file pgstat_slru.c.

 {
     get_slru_entry(slru_idx)->blocks_hit += 1;
 }

References PgStat_SLRUStats::blocks_hit, and get_slru_entry().

Referenced by SimpleLruReadPage(), and SimpleLruReadPage_ReadOnly().

◆ pgstat_count_slru_page_read()

void pgstat_count_slru_page_read ( int slru_idx )

Definition at line 77 of file pgstat_slru.c.

 {
     get_slru_entry(slru_idx)->blocks_read += 1;
 }

References PgStat_SLRUStats::blocks_read, and get_slru_entry().

Referenced by SimpleLruReadPage().

◆ pgstat_count_slru_page_written()

void pgstat_count_slru_page_written ( int slru_idx )

Definition at line 83 of file pgstat_slru.c.

 {
     get_slru_entry(slru_idx)->blocks_written += 1;
 }

References PgStat_SLRUStats::blocks_written, and get_slru_entry().

Referenced by SlruPhysicalWritePage().

◆ pgstat_count_slru_page_zeroed()

void pgstat_count_slru_page_zeroed ( int slru_idx )

Definition at line 59 of file pgstat_slru.c.

 {
     get_slru_entry(slru_idx)->blocks_zeroed += 1;
 }

References PgStat_SLRUStats::blocks_zeroed, and get_slru_entry().

Referenced by SimpleLruZeroPage().

◆ pgstat_count_slru_truncate()

void pgstat_count_slru_truncate ( int slru_idx )

Definition at line 95 of file pgstat_slru.c.

 {
     get_slru_entry(slru_idx)->truncate += 1;
 }

References get_slru_entry(), and PgStat_SLRUStats::truncate.

Referenced by SimpleLruTruncate().

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation rel )

Definition at line 417 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 ExecRefreshMatView(), and ExecuteTruncateGuts().

◆ pgstat_create_function()

void pgstat_create_function ( Oid proid )

Definition at line 45 of file pgstat_function.c.

 {
     pgstat_create_transactional(PGSTAT_KIND_FUNCTION,
                                 MyDatabaseId,
                                 proid);
 }

References MyDatabaseId, pgstat_create_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by ProcedureCreate().

◆ pgstat_create_relation()

void pgstat_create_relation ( Relation rel )

Definition at line 170 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_create_replslot()

void pgstat_create_replslot ( struct ReplicationSlot * slot )

Definition at line 111 of file pgstat_replslot.c.

 {
     PgStat_EntryRef *entry_ref;
     PgStatShared_ReplSlot *shstatent;
  
     entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_REPLSLOT, InvalidOid,
                                             ReplicationSlotIndex(slot), false);
     shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
  
     /*
      * NB: need to accept that there might be stats from an older slot, e.g.
      * if we previously crashed after dropping a slot.
      */
     memset(&shstatent->stats, 0, sizeof(shstatent->stats));
  
     pgstat_unlock_entry(entry_ref);
 }

References InvalidOid, pgstat_get_entry_ref_locked(), PGSTAT_KIND_REPLSLOT, pgstat_unlock_entry(), ReplicationSlotIndex(), PgStat_EntryRef::shared_stats, and PgStatShared_ReplSlot::stats.

Referenced by ReplicationSlotCreate().

◆ pgstat_create_subscription()

void pgstat_create_subscription ( Oid subid )

Definition at line 46 of file pgstat_subscription.c.

 {
     /* Ensures that stats are dropped if transaction rolls back */
     pgstat_create_transactional(PGSTAT_KIND_SUBSCRIPTION,
                                 InvalidOid, subid);
  
     /* Create and initialize the subscription stats entry */
     pgstat_get_entry_ref(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid,
                          true, NULL);
     pgstat_reset_entry(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid, 0);
 }

References InvalidOid, pgstat_create_transactional(), pgstat_get_entry_ref(), PGSTAT_KIND_SUBSCRIPTION, and pgstat_reset_entry().

Referenced by CreateSubscription().

◆ pgstat_discard_stats()

void pgstat_discard_stats ( void )

Definition at line 422 of file pgstat.c.

 {
     int         ret;
  
     /* NB: this needs to be done even in single user mode */
  
     ret = unlink(PGSTAT_STAT_PERMANENT_FILENAME);
     if (ret != 0)
     {
         if (errno == ENOENT)
             elog(DEBUG2,
                  "didn't need to unlink permanent stats file \"%s\" - didn't exist",
                  PGSTAT_STAT_PERMANENT_FILENAME);
         else
             ereport(LOG,
                     (errcode_for_file_access(),
                      errmsg("could not unlink permanent statistics file \"%s\": %m",
                             PGSTAT_STAT_PERMANENT_FILENAME)));
     }
     else
     {
         ereport(DEBUG2,
                 (errcode_for_file_access(),
                  errmsg_internal("unlinked permanent statistics file \"%s\"",
                                  PGSTAT_STAT_PERMANENT_FILENAME)));
     }
  
     /*
      * Reset stats contents. This will set reset timestamps of fixed-numbered
      * stats to the current time (no variable stats exist).
      */
     pgstat_reset_after_failure();
 }

References DEBUG2, elog(), ereport, errcode_for_file_access(), errmsg(), errmsg_internal(), LOG, pgstat_reset_after_failure(), and PGSTAT_STAT_PERMANENT_FILENAME.

Referenced by StartupXLOG().

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid databaseid )

Definition at line 44 of file pgstat_database.c.

 {
     pgstat_drop_transactional(PGSTAT_KIND_DATABASE, databaseid, InvalidOid);
 }

References InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_DATABASE.

Referenced by dropdb().

◆ pgstat_drop_function()

void pgstat_drop_function ( Oid proid )

Definition at line 60 of file pgstat_function.c.

 {
     pgstat_drop_transactional(PGSTAT_KIND_FUNCTION,
                               MyDatabaseId,
                               proid);
 }

References MyDatabaseId, pgstat_drop_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by RemoveFunctionById().

◆ pgstat_drop_relation()

void pgstat_drop_relation ( Relation rel )

Definition at line 181 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_drop_replslot()

void pgstat_drop_replslot ( struct ReplicationSlot * slot )

Definition at line 154 of file pgstat_replslot.c.

 {
     pgstat_drop_entry(PGSTAT_KIND_REPLSLOT, InvalidOid,
                       ReplicationSlotIndex(slot));
 }

References InvalidOid, pgstat_drop_entry(), PGSTAT_KIND_REPLSLOT, and ReplicationSlotIndex().

Referenced by InvalidatePossiblyObsoleteSlot(), and ReplicationSlotDropPtr().

◆ pgstat_drop_subscription()

void pgstat_drop_subscription ( Oid subid )

Definition at line 64 of file pgstat_subscription.c.

 {
     pgstat_drop_transactional(PGSTAT_KIND_SUBSCRIPTION,
                               InvalidOid, subid);
 }

References InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_SUBSCRIPTION.

Referenced by DropSubscription().

◆ pgstat_end_function_usage()

void pgstat_end_function_usage	(	PgStat_FunctionCallUsage *	fcu,
		bool	finalize
	)

Definition at line 146 of file pgstat_function.c.

 {
     PgStat_FunctionCounts *fs = fcu->fs;
     instr_time  total;
     instr_time  others;
     instr_time  self;
  
     /* stats not wanted? */
     if (fs == NULL)
         return;
  
     /* total elapsed time in this function call */
     INSTR_TIME_SET_CURRENT(total);
     INSTR_TIME_SUBTRACT(total, fcu->start);
  
     /* self usage: elapsed minus anything already charged to other calls */
     others = total_func_time;
     INSTR_TIME_SUBTRACT(others, fcu->save_total);
     self = total;
     INSTR_TIME_SUBTRACT(self, others);
  
     /* update backend-wide total time */
     INSTR_TIME_ADD(total_func_time, self);
  
     /*
      * Compute the new total_time as the total elapsed time added to the
      * pre-call value of total_time.  This is necessary to avoid
      * double-counting any time taken by recursive calls of myself.  (We do
      * not need any similar kluge for self time, since that already excludes
      * any recursive calls.)
      */
     INSTR_TIME_ADD(total, fcu->save_f_total_time);
  
     /* update counters in function stats table */
     if (finalize)
         fs->numcalls++;
     fs->total_time = total;
     INSTR_TIME_ADD(fs->self_time, self);
 }

References PgStat_FunctionCallUsage::fs, INSTR_TIME_ADD, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, PgStat_FunctionCounts::numcalls, PgStat_FunctionCallUsage::save_f_total_time, PgStat_FunctionCallUsage::save_total, PgStat_FunctionCounts::self_time, PgStat_FunctionCallUsage::start, total_func_time, and PgStat_FunctionCounts::total_time.

Referenced by call_pltcl_start_proc(), EventTriggerInvoke(), ExecCallTriggerFunc(), ExecEvalFuncExprFusage(), ExecEvalFuncExprStrictFusage(), ExecMakeFunctionResultSet(), ExecMakeTableFunctionResult(), ExecuteCallStmt(), and fmgr_security_definer().

◆ pgstat_execute_transactional_drops()

void pgstat_execute_transactional_drops	(	int	ndrops,
		struct xl_xact_stats_item *	items,
		bool	is_redo
	)

Definition at line 313 of file pgstat_xact.c.

 {
     int         not_freed_count = 0;
  
     if (ndrops == 0)
         return;
  
     for (int i = 0; i < ndrops; i++)
     {
         xl_xact_stats_item *it = &items[i];
  
         if (!pgstat_drop_entry(it->kind, it->dboid, it->objoid))
             not_freed_count++;
     }
  
     if (not_freed_count > 0)
         pgstat_request_entry_refs_gc();
 }

References xl_xact_stats_item::dboid, i, xl_xact_stats_item::kind, xl_xact_stats_item::objoid, pgstat_drop_entry(), and pgstat_request_entry_refs_gc().

Referenced by FinishPreparedTransaction(), xact_redo_abort(), and xact_redo_commit().

◆ pgstat_fetch_replslot()

PgStat_StatReplSlotEntry* pgstat_fetch_replslot ( NameData slotname )

Definition at line 165 of file pgstat_replslot.c.

 {
     int         idx = get_replslot_index(NameStr(slotname));
  
     if (idx == -1)
         return NULL;
  
     return (PgStat_StatReplSlotEntry *)
         pgstat_fetch_entry(PGSTAT_KIND_REPLSLOT, InvalidOid, idx);
 }

References get_replslot_index(), idx(), InvalidOid, NameStr, pgstat_fetch_entry(), and PGSTAT_KIND_REPLSLOT.

Referenced by pg_stat_get_replication_slot().

◆ pgstat_fetch_slru()

PgStat_SLRUStats* pgstat_fetch_slru ( void )

Definition at line 105 of file pgstat_slru.c.

 {
     pgstat_snapshot_fixed(PGSTAT_KIND_SLRU);
  
     return pgStatLocal.snapshot.slru;
 }

References PGSTAT_KIND_SLRU, pgstat_snapshot_fixed(), pgStatLocal, PgStat_Snapshot::slru, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_slru().

◆ pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver ( void )

Definition at line 58 of file pgstat_archiver.c.

 {
     pgstat_snapshot_fixed(PGSTAT_KIND_ARCHIVER);
  
     return &pgStatLocal.snapshot.archiver;
 }

References PgStat_Snapshot::archiver, PGSTAT_KIND_ARCHIVER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_archiver().

◆ pgstat_fetch_stat_bgwriter()

PgStat_BgWriterStats* pgstat_fetch_stat_bgwriter ( void )

Definition at line 71 of file pgstat_bgwriter.c.

 {
     pgstat_snapshot_fixed(PGSTAT_KIND_BGWRITER);
  
     return &pgStatLocal.snapshot.bgwriter;
 }

References PgStat_Snapshot::bgwriter, PGSTAT_KIND_BGWRITER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_bgwriter_buf_written_clean(), pg_stat_get_bgwriter_maxwritten_clean(), pg_stat_get_bgwriter_stat_reset_time(), and pg_stat_get_buf_alloc().

◆ pgstat_fetch_stat_checkpointer()

PgStat_CheckpointerStats* pgstat_fetch_stat_checkpointer ( void )

Definition at line 79 of file pgstat_checkpointer.c.

 {
     pgstat_snapshot_fixed(PGSTAT_KIND_CHECKPOINTER);
  
     return &pgStatLocal.snapshot.checkpointer;
 }

References PgStat_Snapshot::checkpointer, PGSTAT_KIND_CHECKPOINTER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_bgwriter_buf_written_checkpoints(), pg_stat_get_bgwriter_requested_checkpoints(), pg_stat_get_bgwriter_timed_checkpoints(), pg_stat_get_buf_fsync_backend(), pg_stat_get_buf_written_backend(), pg_stat_get_checkpoint_sync_time(), and pg_stat_get_checkpoint_write_time().

◆ pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry ( Oid dboid )

Definition at line 242 of file pgstat_database.c.

 {
     return (PgStat_StatDBEntry *)
         pgstat_fetch_entry(PGSTAT_KIND_DATABASE, dboid, InvalidOid);
 }

References InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_DATABASE.

Referenced by do_start_worker(), pg_stat_get_db_checksum_failures(), pg_stat_get_db_checksum_last_failure(), pg_stat_get_db_conflict_all(), pg_stat_get_db_stat_reset_time(), and rebuild_database_list().

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry ( Oid func_id )

Definition at line 239 of file pgstat_function.c.

 {
     return (PgStat_StatFuncEntry *)
         pgstat_fetch_entry(PGSTAT_KIND_FUNCTION, MyDatabaseId, func_id);
 }

References MyDatabaseId, pgstat_fetch_entry(), and PGSTAT_KIND_FUNCTION.

Referenced by pg_stat_get_function_calls().

◆ pgstat_fetch_stat_io()

PgStat_IO* pgstat_fetch_stat_io ( void )

Definition at line 143 of file pgstat_io.c.

 {
     pgstat_snapshot_fixed(PGSTAT_KIND_IO);
  
     return &pgStatLocal.snapshot.io;
 }

References PgStat_Snapshot::io, PGSTAT_KIND_IO, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_io().

◆ pgstat_fetch_stat_subscription()

PgStat_StatSubEntry* pgstat_fetch_stat_subscription ( Oid subid )

Definition at line 75 of file pgstat_subscription.c.

 {
     return (PgStat_StatSubEntry *)
         pgstat_fetch_entry(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid);
 }

References InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_SUBSCRIPTION.

Referenced by pg_stat_get_subscription_stats().

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry ( Oid relid )

Definition at line 457 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 467 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_fetch_stat_wal()

PgStat_WalStats* pgstat_fetch_stat_wal ( void )

Definition at line 67 of file pgstat_wal.c.

 {
     pgstat_snapshot_fixed(PGSTAT_KIND_WAL);
  
     return &pgStatLocal.snapshot.wal;
 }

References PGSTAT_KIND_WAL, pgstat_snapshot_fixed(), pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::wal.

Referenced by pg_stat_get_wal().

◆ pgstat_force_next_flush()

void pgstat_force_next_flush ( void )

Definition at line 697 of file pgstat.c.

 {
     pgStatForceNextFlush = true;
 }

References pgStatForceNextFlush.

Referenced by pg_stat_force_next_flush().

◆ pgstat_get_io_context_name()

const char* pgstat_get_io_context_name ( IOContext io_context )

Definition at line 207 of file pgstat_io.c.

 {
     switch (io_context)
     {
         case IOCONTEXT_BULKREAD:
             return "bulkread";
         case IOCONTEXT_BULKWRITE:
             return "bulkwrite";
         case IOCONTEXT_NORMAL:
             return "normal";
         case IOCONTEXT_VACUUM:
             return "vacuum";
     }
  
     elog(ERROR, "unrecognized IOContext value: %d", io_context);
     pg_unreachable();
 }

References elog(), ERROR, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, and pg_unreachable.

Referenced by pg_stat_get_io().

◆ pgstat_get_io_object_name()

const char* pgstat_get_io_object_name ( IOObject io_object )

Definition at line 226 of file pgstat_io.c.

 {
     switch (io_object)
     {
         case IOOBJECT_RELATION:
             return "relation";
         case IOOBJECT_TEMP_RELATION:
             return "temp relation";
     }
  
     elog(ERROR, "unrecognized IOObject value: %d", io_object);
     pg_unreachable();
 }

References elog(), ERROR, IOOBJECT_RELATION, IOOBJECT_TEMP_RELATION, and pg_unreachable.

Referenced by pg_stat_get_io().

◆ pgstat_get_kind_from_str()

PgStat_Kind pgstat_get_kind_from_str ( char * kind_str )

Definition at line 1242 of file pgstat.c.

 {
     for (int kind = PGSTAT_KIND_FIRST_VALID; kind <= PGSTAT_KIND_LAST; kind++)
     {
         if (pg_strcasecmp(kind_str, pgstat_kind_infos[kind].name) == 0)
             return kind;
     }
  
     ereport(ERROR,
             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
              errmsg("invalid statistics kind: \"%s\"", kind_str)));
     return PGSTAT_KIND_DATABASE;    /* avoid compiler warnings */
 }

References ereport, errcode(), errmsg(), ERROR, name, pg_strcasecmp(), PGSTAT_KIND_DATABASE, PGSTAT_KIND_FIRST_VALID, pgstat_kind_infos, and PGSTAT_KIND_LAST.

Referenced by pg_stat_have_stats().

◆ pgstat_get_slru_index()

int pgstat_get_slru_index ( const char * name )

Definition at line 132 of file pgstat_slru.c.

 {
     int         i;
  
     for (i = 0; i < SLRU_NUM_ELEMENTS; i++)
     {
         if (strcmp(slru_names[i], name) == 0)
             return i;
     }
  
     /* return index of the last entry (which is the "other" one) */
     return (SLRU_NUM_ELEMENTS - 1);
 }

References i, name, slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pgstat_reset_slru(), and SimpleLruInit().

◆ pgstat_get_slru_name()

const char* pgstat_get_slru_name ( int slru_idx )

Definition at line 118 of file pgstat_slru.c.

 {
     if (slru_idx < 0 || slru_idx >= SLRU_NUM_ELEMENTS)
         return NULL;
  
     return slru_names[slru_idx];
 }

References slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pg_stat_get_slru().

◆ pgstat_get_stat_snapshot_timestamp()

TimestampTz pgstat_get_stat_snapshot_timestamp ( bool * have_snapshot )

Definition at line 908 of file pgstat.c.

 {
     if (force_stats_snapshot_clear)
         pgstat_clear_snapshot();
  
     if (pgStatLocal.snapshot.mode == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
     {
         *have_snapshot = true;
         return pgStatLocal.snapshot.snapshot_timestamp;
     }
  
     *have_snapshot = false;
  
     return 0;
 }

References force_stats_snapshot_clear, PgStat_Snapshot::mode, pgstat_clear_snapshot(), PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::snapshot_timestamp.

Referenced by pg_stat_get_snapshot_timestamp().

◆ pgstat_get_transactional_drops()

int pgstat_get_transactional_drops	(	bool	isCommit,
		struct xl_xact_stats_item **	items
	)

Definition at line 271 of file pgstat_xact.c.

 {
     PgStat_SubXactStatus *xact_state = pgStatXactStack;
     int         nitems = 0;
     dlist_iter  iter;
  
     if (xact_state == NULL)
         return 0;
  
     /*
      * We expect to be called for subtransaction abort (which logs a WAL
      * record), but not for subtransaction commit (which doesn't).
      */
     Assert(!isCommit || xact_state->nest_level == 1);
     Assert(!isCommit || xact_state->prev == NULL);
  
     *items = palloc(dclist_count(&xact_state->pending_drops)
                     * sizeof(xl_xact_stats_item));
  
     dclist_foreach(iter, &xact_state->pending_drops)
     {
         PgStat_PendingDroppedStatsItem *pending =
             dclist_container(PgStat_PendingDroppedStatsItem, node, iter.cur);
  
         if (isCommit && pending->is_create)
             continue;
         if (!isCommit && !pending->is_create)
             continue;
  
         Assert(nitems < dclist_count(&xact_state->pending_drops));
         (*items)[nitems++] = pending->item;
     }
  
     return nitems;
 }

References Assert(), dlist_iter::cur, dclist_container, dclist_count(), dclist_foreach, PgStat_PendingDroppedStatsItem::is_create, PgStat_PendingDroppedStatsItem::item, PgStat_SubXactStatus::nest_level, nitems, palloc(), PgStat_SubXactStatus::pending_drops, pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by RecordTransactionAbort(), RecordTransactionCommit(), and StartPrepare().

◆ pgstat_have_entry()

bool pgstat_have_entry	(	PgStat_Kind	kind,
		Oid	dboid,
		Oid	objoid
	)

Definition at line 925 of file pgstat.c.

 {
     /* fixed-numbered stats always exist */
     if (pgstat_get_kind_info(kind)->fixed_amount)
         return true;
  
     return pgstat_get_entry_ref(kind, dboid, objoid, false, NULL) != NULL;
 }

References pgstat_get_entry_ref(), and pgstat_get_kind_info().

Referenced by pg_stat_have_stats().

◆ pgstat_init_function_usage()

void pgstat_init_function_usage	(	struct FunctionCallInfoBaseData *	fcinfo,
		PgStat_FunctionCallUsage *	fcu
	)

◆ pgstat_init_relation()

void pgstat_init_relation ( Relation rel )

Definition at line 93 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_initialize()

void pgstat_initialize ( void )

Definition at line 540 of file pgstat.c.

 {
     Assert(!pgstat_is_initialized);
  
     pgstat_attach_shmem();
  
     pgstat_init_wal();
  
     /* Set up a process-exit hook to clean up */
     before_shmem_exit(pgstat_shutdown_hook, 0);
  
 #ifdef USE_ASSERT_CHECKING
     pgstat_is_initialized = true;
 #endif
 }

References Assert(), before_shmem_exit(), pgstat_attach_shmem(), pgstat_init_wal(), and pgstat_shutdown_hook().

Referenced by BaseInit().

◆ pgstat_prepare_io_time()

instr_time pgstat_prepare_io_time ( void )

Definition at line 96 of file pgstat_io.c.

 {
     instr_time  io_start;
  
     if (track_io_timing)
         INSTR_TIME_SET_CURRENT(io_start);
     else
         INSTR_TIME_SET_ZERO(io_start);
  
     return io_start;
 }

References INSTR_TIME_SET_CURRENT, INSTR_TIME_SET_ZERO, and track_io_timing.

Referenced by ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushRelationBuffers(), GetLocalVictimBuffer(), IssuePendingWritebacks(), mdsyncfiletag(), ReadBuffer_common(), and register_dirty_segment().

◆ pgstat_report_analyze()

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

Definition at line 278 of file pgstat_relation.c.

 {
     PgStat_EntryRef *entry_ref;
     PgStatShared_Relation *shtabentry;
     PgStat_StatTabEntry *tabentry;
     Oid         dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
  
     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);
     }
  
     /* 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 (IsAutoVacuumWorkerProcess())
     {
         tabentry->last_autoanalyze_time = GetCurrentTimestamp();
         tabentry->autoanalyze_count++;
     }
     else
     {
         tabentry->last_analyze_time = GetCurrentTimestamp();
         tabentry->analyze_count++;
     }
  
     pgstat_unlock_entry(entry_ref);
  
     /* see pgstat_report_vacuum() */
     pgstat_flush_io(false);
 }

References PgStat_StatTabEntry::analyze_count, Assert(), PgStat_StatTabEntry::autoanalyze_count, PgStat_TableStatus::counts, PgStat_StatTabEntry::dead_tuples, PgStat_TableCounts::delta_dead_tuples, GetCurrentTimestamp(), if(), InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_StatTabEntry::last_analyze_time, PgStat_StatTabEntry::last_autoanalyze_time, PgStat_StatTabEntry::live_tuples, Max, PgStat_StatTabEntry::mod_since_analyze, MyDatabaseId, 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, PgStat_TableStatus::trans, and trans.

Referenced by do_analyze_rel().

◆ pgstat_report_archiver()

void pgstat_report_archiver	(	const char *	xlog,
		bool	failed
	)

Definition at line 28 of file pgstat_archiver.c.

 {
     PgStatShared_Archiver *stats_shmem = &pgStatLocal.shmem->archiver;
     TimestampTz now = GetCurrentTimestamp();
  
     pgstat_begin_changecount_write(&stats_shmem->changecount);
  
     if (failed)
     {
         ++stats_shmem->stats.failed_count;
         memcpy(&stats_shmem->stats.last_failed_wal, xlog,
                sizeof(stats_shmem->stats.last_failed_wal));
         stats_shmem->stats.last_failed_timestamp = now;
     }
     else
     {
         ++stats_shmem->stats.archived_count;
         memcpy(&stats_shmem->stats.last_archived_wal, xlog,
                sizeof(stats_shmem->stats.last_archived_wal));
         stats_shmem->stats.last_archived_timestamp = now;
     }
  
     pgstat_end_changecount_write(&stats_shmem->changecount);
 }

References PgStat_ArchiverStats::archived_count, PgStat_ShmemControl::archiver, PgStatShared_Archiver::changecount, PgStat_ArchiverStats::failed_count, GetCurrentTimestamp(), PgStat_ArchiverStats::last_archived_timestamp, PgStat_ArchiverStats::last_archived_wal, PgStat_ArchiverStats::last_failed_timestamp, PgStat_ArchiverStats::last_failed_wal, now(), pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgStatLocal, PgStat_LocalState::shmem, and PgStatShared_Archiver::stats.

Referenced by pgarch_ArchiverCopyLoop().

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid dboid )

Definition at line 55 of file pgstat_database.c.

 {
     PgStat_EntryRef *entry_ref;
     PgStatShared_Database *dbentry;
  
     /* can't get here in single user mode */
     Assert(IsUnderPostmaster);
  
     /*
      * End-of-vacuum is reported instantly. Report the start the same way for
      * consistency. Vacuum doesn't run frequently and is a long-lasting
      * operation so it doesn't matter if we get blocked here a little.
      */
     entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_DATABASE,
                                             dboid, InvalidOid, false);
  
     dbentry = (PgStatShared_Database *) entry_ref->shared_stats;
     dbentry->stats.last_autovac_time = GetCurrentTimestamp();
  
     pgstat_unlock_entry(entry_ref);
 }

References Assert(), GetCurrentTimestamp(), InvalidOid, IsUnderPostmaster, PgStat_StatDBEntry::last_autovac_time, pgstat_get_entry_ref_locked(), PGSTAT_KIND_DATABASE, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, and PgStatShared_Database::stats.

Referenced by AutoVacWorkerMain().

◆ pgstat_report_bgwriter()

void pgstat_report_bgwriter ( void )

Definition at line 30 of file pgstat_bgwriter.c.

 {
     PgStatShared_BgWriter *stats_shmem = &pgStatLocal.shmem->bgwriter;
     static const PgStat_BgWriterStats all_zeroes;
  
     Assert(!pgStatLocal.shmem->is_shutdown);
     pgstat_assert_is_up();
  
     /*
      * This function can be called even if nothing at all has happened. In
      * this case, avoid unnecessarily modifying the stats entry.
      */
     if (memcmp(&PendingBgWriterStats, &all_zeroes, sizeof(all_zeroes)) == 0)
         return;
  
     pgstat_begin_changecount_write(&stats_shmem->changecount);
  
 #define BGWRITER_ACC(fld) stats_shmem->stats.fld += PendingBgWriterStats.fld
     BGWRITER_ACC(buf_written_clean);
     BGWRITER_ACC(maxwritten_clean);
     BGWRITER_ACC(buf_alloc);
 #undef BGWRITER_ACC
  
     pgstat_end_changecount_write(&stats_shmem->changecount);
  
     /*
      * Clear out the statistics buffer, so it can be re-used.
      */
     MemSet(&PendingBgWriterStats, 0, sizeof(PendingBgWriterStats));
  
     /*
      * Report IO statistics
      */
     pgstat_flush_io(false);
 }

References Assert(), PgStat_ShmemControl::bgwriter, BGWRITER_ACC, PgStatShared_BgWriter::changecount, PgStat_ShmemControl::is_shutdown, MemSet, PendingBgWriterStats, pgstat_assert_is_up, pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgstat_flush_io(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by BackgroundWriterMain().

◆ pgstat_report_checkpointer()

void pgstat_report_checkpointer ( void )

Definition at line 30 of file pgstat_checkpointer.c.

 {
     /* We assume this initializes to zeroes */
     static const PgStat_CheckpointerStats all_zeroes;
     PgStatShared_Checkpointer *stats_shmem = &pgStatLocal.shmem->checkpointer;
  
     Assert(!pgStatLocal.shmem->is_shutdown);
     pgstat_assert_is_up();
  
     /*
      * This function can be called even if nothing at all has happened. In
      * this case, avoid unnecessarily modifying the stats entry.
      */
     if (memcmp(&PendingCheckpointerStats, &all_zeroes,
                sizeof(all_zeroes)) == 0)
         return;
  
     pgstat_begin_changecount_write(&stats_shmem->changecount);
  
 #define CHECKPOINTER_ACC(fld) stats_shmem->stats.fld += PendingCheckpointerStats.fld
     CHECKPOINTER_ACC(timed_checkpoints);
     CHECKPOINTER_ACC(requested_checkpoints);
     CHECKPOINTER_ACC(checkpoint_write_time);
     CHECKPOINTER_ACC(checkpoint_sync_time);
     CHECKPOINTER_ACC(buf_written_checkpoints);
     CHECKPOINTER_ACC(buf_written_backend);
     CHECKPOINTER_ACC(buf_fsync_backend);
 #undef CHECKPOINTER_ACC
  
     pgstat_end_changecount_write(&stats_shmem->changecount);
  
     /*
      * Clear out the statistics buffer, so it can be re-used.
      */
     MemSet(&PendingCheckpointerStats, 0, sizeof(PendingCheckpointerStats));
  
     /*
      * Report IO statistics
      */
     pgstat_flush_io(false);
 }

References Assert(), PgStatShared_Checkpointer::changecount, PgStat_ShmemControl::checkpointer, CHECKPOINTER_ACC, PgStat_ShmemControl::is_shutdown, MemSet, PendingCheckpointerStats, pgstat_assert_is_up, pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgstat_flush_io(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by CheckpointerMain(), CheckpointWriteDelay(), and HandleCheckpointerInterrupts().

◆ pgstat_report_checksum_failure()

void pgstat_report_checksum_failure ( void )

Definition at line 166 of file pgstat_database.c.

 {
     pgstat_report_checksum_failures_in_db(MyDatabaseId, 1);
 }

References MyDatabaseId, and pgstat_report_checksum_failures_in_db().

Referenced by PageIsVerifiedExtended().

◆ pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db	(	Oid	dboid,
		int	failurecount
	)

Definition at line 140 of file pgstat_database.c.

 {
     PgStat_EntryRef *entry_ref;
     PgStatShared_Database *sharedent;
  
     if (!pgstat_track_counts)
         return;
  
     /*
      * Update the shared stats directly - checksum failures should never be
      * common enough for that to be a problem.
      */
     entry_ref =
         pgstat_get_entry_ref_locked(PGSTAT_KIND_DATABASE, dboid, InvalidOid, false);
  
     sharedent = (PgStatShared_Database *) entry_ref->shared_stats;
     sharedent->stats.checksum_failures += failurecount;
     sharedent->stats.last_checksum_failure = GetCurrentTimestamp();
  
     pgstat_unlock_entry(entry_ref);
 }

References PgStat_StatDBEntry::checksum_failures, GetCurrentTimestamp(), InvalidOid, PgStat_StatDBEntry::last_checksum_failure, pgstat_get_entry_ref_locked(), PGSTAT_KIND_DATABASE, pgstat_track_counts, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, and PgStatShared_Database::stats.

Referenced by pgstat_report_checksum_failure(), and sendFile().

◆ pgstat_report_connect()

void pgstat_report_connect ( Oid dboid )

Definition at line 191 of file pgstat_database.c.

 {
     PgStat_StatDBEntry *dbentry;
  
     if (!pgstat_should_report_connstat())
         return;
  
     pgLastSessionReportTime = MyStartTimestamp;
  
     dbentry = pgstat_prep_database_pending(MyDatabaseId);
     dbentry->sessions++;
 }

References MyDatabaseId, MyStartTimestamp, pgLastSessionReportTime, pgstat_prep_database_pending(), pgstat_should_report_connstat(), and PgStat_StatDBEntry::sessions.

Referenced by PostgresMain().

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void )

Definition at line 125 of file pgstat_database.c.

 {
     PgStat_StatDBEntry *dbent;
  
     if (!pgstat_track_counts)
         return;
  
     dbent = pgstat_prep_database_pending(MyDatabaseId);
     dbent->deadlocks++;
 }

References PgStat_StatDBEntry::deadlocks, MyDatabaseId, pgstat_prep_database_pending(), and pgstat_track_counts.

Referenced by DeadLockReport().

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int reason )

Definition at line 81 of file pgstat_database.c.

 {
     PgStat_StatDBEntry *dbentry;
  
     Assert(IsUnderPostmaster);
     if (!pgstat_track_counts)
         return;
  
     dbentry = pgstat_prep_database_pending(MyDatabaseId);
  
     switch (reason)
     {
         case PROCSIG_RECOVERY_CONFLICT_DATABASE:
  
             /*
              * Since we drop the information about the database as soon as it
              * replicates, there is no point in counting these conflicts.
              */
             break;
         case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
             dbentry->conflict_tablespace++;
             break;
         case PROCSIG_RECOVERY_CONFLICT_LOCK:
             dbentry->conflict_lock++;
             break;
         case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
             dbentry->conflict_snapshot++;
             break;
         case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
             dbentry->conflict_bufferpin++;
             break;
         case PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT:
             dbentry->conflict_logicalslot++;
             break;
         case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
             dbentry->conflict_startup_deadlock++;
             break;
     }
 }

References Assert(), PgStat_StatDBEntry::conflict_bufferpin, PgStat_StatDBEntry::conflict_lock, PgStat_StatDBEntry::conflict_logicalslot, PgStat_StatDBEntry::conflict_snapshot, PgStat_StatDBEntry::conflict_startup_deadlock, PgStat_StatDBEntry::conflict_tablespace, IsUnderPostmaster, MyDatabaseId, pgstat_prep_database_pending(), pgstat_track_counts, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, PROCSIG_RECOVERY_CONFLICT_DATABASE, PROCSIG_RECOVERY_CONFLICT_LOCK, PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT, PROCSIG_RECOVERY_CONFLICT_SNAPSHOT, PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK, and PROCSIG_RECOVERY_CONFLICT_TABLESPACE.

Referenced by ProcessRecoveryConflictInterrupt().

◆ pgstat_report_replslot()

void pgstat_report_replslot	(	struct ReplicationSlot *	slot,
		const PgStat_StatReplSlotEntry *	repSlotStat
	)

Definition at line 78 of file pgstat_replslot.c.

 {
     PgStat_EntryRef *entry_ref;
     PgStatShared_ReplSlot *shstatent;
     PgStat_StatReplSlotEntry *statent;
  
     entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_REPLSLOT, InvalidOid,
                                             ReplicationSlotIndex(slot), false);
     shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
     statent = &shstatent->stats;
  
     /* Update the replication slot statistics */
 #define REPLSLOT_ACC(fld) statent->fld += repSlotStat->fld
     REPLSLOT_ACC(spill_txns);
     REPLSLOT_ACC(spill_count);
     REPLSLOT_ACC(spill_bytes);
     REPLSLOT_ACC(stream_txns);
     REPLSLOT_ACC(stream_count);
     REPLSLOT_ACC(stream_bytes);
     REPLSLOT_ACC(total_txns);
     REPLSLOT_ACC(total_bytes);
 #undef REPLSLOT_ACC
  
     pgstat_unlock_entry(entry_ref);
 }

References InvalidOid, pgstat_get_entry_ref_locked(), PGSTAT_KIND_REPLSLOT, pgstat_unlock_entry(), ReplicationSlotIndex(), REPLSLOT_ACC, PgStat_EntryRef::shared_stats, and PgStatShared_ReplSlot::stats.

Referenced by UpdateDecodingStats().

◆ pgstat_report_stat()

long pgstat_report_stat ( bool force )

Definition at line 582 of file pgstat.c.

 {
     static TimestampTz pending_since = 0;
     static TimestampTz last_flush = 0;
     bool        partial_flush;
     TimestampTz now;
     bool        nowait;
  
     pgstat_assert_is_up();
     Assert(!IsTransactionOrTransactionBlock());
  
     /* "absorb" the forced flush even if there's nothing to flush */
     if (pgStatForceNextFlush)
     {
         force = true;
         pgStatForceNextFlush = false;
     }
  
     /* Don't expend a clock check if nothing to do */
     if (dlist_is_empty(&pgStatPending) &&
         !have_iostats &&
         !have_slrustats &&
         !pgstat_have_pending_wal())
     {
         Assert(pending_since == 0);
         return 0;
     }
  
     /*
      * There should never be stats to report once stats are shut down. Can't
      * assert that before the checks above, as there is an unconditional
      * pgstat_report_stat() call in pgstat_shutdown_hook() - which at least
      * the process that ran pgstat_before_server_shutdown() will still call.
      */
     Assert(!pgStatLocal.shmem->is_shutdown);
  
     if (force)
     {
         /*
          * Stats reports are forced either when it's been too long since stats
          * have been reported or in processes that force stats reporting to
          * happen at specific points (including shutdown). In the former case
          * the transaction stop time might be quite old, in the latter it
          * would never get cleared.
          */
         now = GetCurrentTimestamp();
     }
     else
     {
         now = GetCurrentTransactionStopTimestamp();
  
         if (pending_since > 0 &&
             TimestampDifferenceExceeds(pending_since, now, PGSTAT_MAX_INTERVAL))
         {
             /* don't keep pending updates longer than PGSTAT_MAX_INTERVAL */
             force = true;
         }
         else if (last_flush > 0 &&
                  !TimestampDifferenceExceeds(last_flush, now, PGSTAT_MIN_INTERVAL))
         {
             /* don't flush too frequently */
             if (pending_since == 0)
                 pending_since = now;
  
             return PGSTAT_IDLE_INTERVAL;
         }
     }
  
     pgstat_update_dbstats(now);
  
     /* don't wait for lock acquisition when !force */
     nowait = !force;
  
     partial_flush = false;
  
     /* flush database / relation / function / ... stats */
     partial_flush |= pgstat_flush_pending_entries(nowait);
  
     /* flush IO stats */
     partial_flush |= pgstat_flush_io(nowait);
  
     /* flush wal stats */
     partial_flush |= pgstat_flush_wal(nowait);
  
     /* flush SLRU stats */
     partial_flush |= pgstat_slru_flush(nowait);
  
     last_flush = now;
  
     /*
      * If some of the pending stats could not be flushed due to lock
      * contention, let the caller know when to retry.
      */
     if (partial_flush)
     {
         /* force should have prevented us from getting here */
         Assert(!force);
  
         /* remember since when stats have been pending */
         if (pending_since == 0)
             pending_since = now;
  
         return PGSTAT_IDLE_INTERVAL;
     }
  
     pending_since = 0;
  
     return 0;
 }

References Assert(), dlist_is_empty(), GetCurrentTimestamp(), GetCurrentTransactionStopTimestamp(), have_iostats, have_slrustats, PgStat_ShmemControl::is_shutdown, IsTransactionOrTransactionBlock(), now(), pgstat_assert_is_up, pgstat_flush_io(), pgstat_flush_pending_entries(), pgstat_flush_wal(), pgstat_have_pending_wal(), PGSTAT_IDLE_INTERVAL, PGSTAT_MAX_INTERVAL, PGSTAT_MIN_INTERVAL, pgstat_slru_flush(), pgstat_update_dbstats(), pgStatForceNextFlush, pgStatLocal, pgStatPending, PgStat_LocalState::shmem, and TimestampDifferenceExceeds().

Referenced by AllTablesyncsReady(), apply_handle_commit_internal(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_rollback_prepared(), apply_handle_stream_prepare(), LogicalRepApplyLoop(), LogicalRepSyncTableStart(), pg_attribute_noreturn(), pgstat_before_server_shutdown(), pgstat_shutdown_hook(), PostgresMain(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), ProcessInterrupts(), standby_redo(), and worker_spi_main().

◆ pgstat_report_subscription_error()

void pgstat_report_subscription_error	(	Oid	subid,
		bool	is_apply_error
	)

Definition at line 27 of file pgstat_subscription.c.

 {
     PgStat_EntryRef *entry_ref;
     PgStat_BackendSubEntry *pending;
  
     entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_SUBSCRIPTION,
                                           InvalidOid, subid, NULL);
     pending = entry_ref->pending;
  
     if (is_apply_error)
         pending->apply_error_count++;
     else
         pending->sync_error_count++;
 }

References PgStat_BackendSubEntry::apply_error_count, InvalidOid, PgStat_EntryRef::pending, PGSTAT_KIND_SUBSCRIPTION, pgstat_prep_pending_entry(), and PgStat_BackendSubEntry::sync_error_count.

Referenced by DisableSubscriptionAndExit(), start_apply(), and start_table_sync().

◆ pgstat_report_vacuum()

void pgstat_report_vacuum	(	Oid	tableoid,
		bool	shared,
		PgStat_Counter	livetuples,
		PgStat_Counter	deadtuples
	)

Definition at line 212 of file pgstat_relation.c.

 {
     PgStat_EntryRef *entry_ref;
     PgStatShared_Relation *shtabentry;
     PgStat_StatTabEntry *tabentry;
     Oid         dboid = (shared ? InvalidOid : MyDatabaseId);
     TimestampTz ts;
  
     if (!pgstat_track_counts)
         return;
  
     /* Store the data in the table's hash table entry. */
     ts = GetCurrentTimestamp();
  
     /* block acquiring lock for the same reason as pgstat_report_autovac() */
     entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
                                             dboid, tableoid, 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 (IsAutoVacuumWorkerProcess())
     {
         tabentry->last_autovacuum_time = ts;
         tabentry->autovacuum_count++;
     }
     else
     {
         tabentry->last_vacuum_time = ts;
         tabentry->vacuum_count++;
     }
  
     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);
 }

References PgStat_StatTabEntry::autovacuum_count, PgStat_StatTabEntry::dead_tuples, GetCurrentTimestamp(), if(), PgStat_StatTabEntry::ins_since_vacuum, InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_StatTabEntry::last_autovacuum_time, PgStat_StatTabEntry::last_vacuum_time, PgStat_StatTabEntry::live_tuples, MyDatabaseId, pgstat_flush_io(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_RELATION, pgstat_track_counts, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, PgStatShared_Relation::stats, and PgStat_StatTabEntry::vacuum_count.

Referenced by heap_vacuum_rel().

◆ pgstat_report_wal()

void pgstat_report_wal ( bool force )

Definition at line 48 of file pgstat_wal.c.

 {
     bool        nowait;
  
     /* like in pgstat.c, don't wait for lock acquisition when !force */
     nowait = !force;
  
     /* flush wal stats */
     pgstat_flush_wal(nowait);
  
     /* flush IO stats */
     pgstat_flush_io(nowait);
 }

References pgstat_flush_io(), and pgstat_flush_wal().

Referenced by CheckpointerMain(), HandleCheckpointerInterrupts(), and WalWriterMain().

◆ pgstat_reset()

void pgstat_reset	(	PgStat_Kind	kind,
		Oid	dboid,
		Oid	objoid
	)

Definition at line 737 of file pgstat.c.

 {
     const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
     TimestampTz ts = GetCurrentTimestamp();
  
     /* not needed atm, and doesn't make sense with the current signature */
     Assert(!pgstat_get_kind_info(kind)->fixed_amount);
  
     /* reset the "single counter" */
     pgstat_reset_entry(kind, dboid, objoid, ts);
  
     if (!kind_info->accessed_across_databases)
         pgstat_reset_database_timestamp(dboid, ts);
 }

References PgStat_KindInfo::accessed_across_databases, Assert(), GetCurrentTimestamp(), pgstat_get_kind_info(), pgstat_reset_database_timestamp(), and pgstat_reset_entry().

Referenced by pg_stat_reset_single_function_counters(), pg_stat_reset_single_table_counters(), pg_stat_reset_subscription_stats(), pgstat_create_transactional(), and pgstat_reset_replslot().

◆ pgstat_reset_counters()

void pgstat_reset_counters ( void )

Definition at line 718 of file pgstat.c.

 {
     TimestampTz ts = GetCurrentTimestamp();
  
     pgstat_reset_matching_entries(match_db_entries,
                                   ObjectIdGetDatum(MyDatabaseId),
                                   ts);
 }

References GetCurrentTimestamp(), match_db_entries(), MyDatabaseId, ObjectIdGetDatum(), and pgstat_reset_matching_entries().

Referenced by pg_stat_reset().

◆ pgstat_reset_of_kind()

void pgstat_reset_of_kind ( PgStat_Kind kind )

Definition at line 759 of file pgstat.c.

 {
     const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
     TimestampTz ts = GetCurrentTimestamp();
  
     if (kind_info->fixed_amount)
         kind_info->reset_all_cb(ts);
     else
         pgstat_reset_entries_of_kind(kind, ts);
 }

References PgStat_KindInfo::fixed_amount, GetCurrentTimestamp(), pgstat_get_kind_info(), pgstat_reset_entries_of_kind(), and PgStat_KindInfo::reset_all_cb.

Referenced by pg_stat_reset_replication_slot(), pg_stat_reset_shared(), pg_stat_reset_slru(), and pg_stat_reset_subscription_stats().

◆ pgstat_reset_replslot()

void pgstat_reset_replslot ( const char * name )

Definition at line 43 of file pgstat_replslot.c.

 {
     ReplicationSlot *slot;
  
     Assert(name != NULL);
  
     /* Check if the slot exits with the given name. */
     slot = SearchNamedReplicationSlot(name, true);
  
     if (!slot)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("replication slot \"%s\" does not exist",
                         name)));
  
     /*
      * Nothing to do for physical slots as we collect stats only for logical
      * slots.
      */
     if (SlotIsPhysical(slot))
         return;
  
     /* reset this one entry */
     pgstat_reset(PGSTAT_KIND_REPLSLOT, InvalidOid,
                  ReplicationSlotIndex(slot));
 }

References Assert(), ereport, errcode(), errmsg(), ERROR, InvalidOid, name, PGSTAT_KIND_REPLSLOT, pgstat_reset(), ReplicationSlotIndex(), SearchNamedReplicationSlot(), and SlotIsPhysical.

Referenced by pg_stat_reset_replication_slot().

◆ pgstat_reset_slru()

void pgstat_reset_slru ( const char * name )

Definition at line 45 of file pgstat_slru.c.

 {
     TimestampTz ts = GetCurrentTimestamp();
  
     Assert(name != NULL);
  
     pgstat_reset_slru_counter_internal(pgstat_get_slru_index(name), ts);
 }

References Assert(), GetCurrentTimestamp(), name, pgstat_get_slru_index(), and pgstat_reset_slru_counter_internal().

Referenced by pg_stat_reset_slru().

◆ pgstat_restore_stats()

void pgstat_restore_stats ( void )

Definition at line 410 of file pgstat.c.

 {
     pgstat_read_statsfile();
 }

References pgstat_read_statsfile().

Referenced by StartupXLOG().

◆ pgstat_tracks_io_bktype()

bool pgstat_tracks_io_bktype ( BackendType bktype )

Definition at line 304 of file pgstat_io.c.

 {
     /*
      * List every type so that new backend types trigger a warning about
      * needing to adjust this switch.
      */
     switch (bktype)
     {
         case B_INVALID:
         case B_ARCHIVER:
         case B_LOGGER:
         case B_WAL_RECEIVER:
         case B_WAL_WRITER:
             return false;
  
         case B_AUTOVAC_LAUNCHER:
         case B_AUTOVAC_WORKER:
         case B_BACKEND:
         case B_BG_WORKER:
         case B_BG_WRITER:
         case B_CHECKPOINTER:
         case B_STANDALONE_BACKEND:
         case B_STARTUP:
         case B_WAL_SENDER:
             return true;
     }
  
     return false;
 }

References B_ARCHIVER, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_INVALID, B_LOGGER, B_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, and B_WAL_WRITER.

Referenced by pg_stat_get_io(), and pgstat_tracks_io_object().

◆ pgstat_tracks_io_object()

bool pgstat_tracks_io_object	(	BackendType	bktype,
		IOObject	io_object,
		IOContext	io_context
	)

Definition at line 342 of file pgstat_io.c.

 {
     bool        no_temp_rel;
  
     /*
      * Some BackendTypes should never track IO statistics.
      */
     if (!pgstat_tracks_io_bktype(bktype))
         return false;
  
     /*
      * Currently, IO on temporary relations can only occur in the
      * IOCONTEXT_NORMAL IOContext.
      */
     if (io_context != IOCONTEXT_NORMAL &&
         io_object == IOOBJECT_TEMP_RELATION)
         return false;
  
     /*
      * In core Postgres, only regular backends and WAL Sender processes
      * executing queries will use local buffers and operate on temporary
      * relations. Parallel workers will not use local buffers (see
      * InitLocalBuffers()); however, extensions leveraging background workers
      * have no such limitation, so track IO on IOOBJECT_TEMP_RELATION for
      * BackendType B_BG_WORKER.
      */
     no_temp_rel = bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
         bktype == B_CHECKPOINTER || bktype == B_AUTOVAC_WORKER ||
         bktype == B_STANDALONE_BACKEND || bktype == B_STARTUP;
  
     if (no_temp_rel && io_context == IOCONTEXT_NORMAL &&
         io_object == IOOBJECT_TEMP_RELATION)
         return false;
  
     /*
      * Some BackendTypes do not currently perform any IO in certain
      * IOContexts, and, while it may not be inherently incorrect for them to
      * do so, excluding those rows from the view makes the view easier to use.
      */
     if ((bktype == B_CHECKPOINTER || bktype == B_BG_WRITER) &&
         (io_context == IOCONTEXT_BULKREAD ||
          io_context == IOCONTEXT_BULKWRITE ||
          io_context == IOCONTEXT_VACUUM))
         return false;
  
     if (bktype == B_AUTOVAC_LAUNCHER && io_context == IOCONTEXT_VACUUM)
         return false;
  
     if ((bktype == B_AUTOVAC_WORKER || bktype == B_AUTOVAC_LAUNCHER) &&
         io_context == IOCONTEXT_BULKWRITE)
         return false;
  
     return true;
 }

References B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_STANDALONE_BACKEND, B_STARTUP, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, and pgstat_tracks_io_bktype().

Referenced by pg_stat_get_io(), and pgstat_tracks_io_op().

◆ pgstat_tracks_io_op()

bool pgstat_tracks_io_op	(	BackendType	bktype,
		IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op
	)

Definition at line 407 of file pgstat_io.c.

 {
     bool        strategy_io_context;
  
     /* if (io_context, io_object) will never collect stats, we're done */
     if (!pgstat_tracks_io_object(bktype, io_object, io_context))
         return false;
  
     /*
      * Some BackendTypes will not do certain IOOps.
      */
     if ((bktype == B_BG_WRITER || bktype == B_CHECKPOINTER) &&
         (io_op == IOOP_READ || io_op == IOOP_EVICT || io_op == IOOP_HIT))
         return false;
  
     if ((bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
          bktype == B_CHECKPOINTER) && io_op == IOOP_EXTEND)
         return false;
  
     /*
      * Temporary tables are not logged and thus do not require fsync'ing.
      * Writeback is not requested for temporary tables.
      */
     if (io_object == IOOBJECT_TEMP_RELATION &&
         (io_op == IOOP_FSYNC || io_op == IOOP_WRITEBACK))
         return false;
  
     /*
      * Some IOOps are not valid in certain IOContexts and some IOOps are only
      * valid in certain contexts.
      */
     if (io_context == IOCONTEXT_BULKREAD && io_op == IOOP_EXTEND)
         return false;
  
     strategy_io_context = io_context == IOCONTEXT_BULKREAD ||
         io_context == IOCONTEXT_BULKWRITE || io_context == IOCONTEXT_VACUUM;
  
     /*
      * IOOP_REUSE is only relevant when a BufferAccessStrategy is in use.
      */
     if (!strategy_io_context && io_op == IOOP_REUSE)
         return false;
  
     /*
      * IOOP_FSYNC IOOps done by a backend using a BufferAccessStrategy are
      * counted in the IOCONTEXT_NORMAL IOContext. See comment in
      * register_dirty_segment() for more details.
      */
     if (strategy_io_context && io_op == IOOP_FSYNC)
         return false;
  
  
     return true;
 }

References B_AUTOVAC_LAUNCHER, B_BG_WRITER, B_CHECKPOINTER, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, IOOP_EVICT, IOOP_EXTEND, IOOP_FSYNC, IOOP_HIT, IOOP_READ, IOOP_REUSE, IOOP_WRITEBACK, and pgstat_tracks_io_object().

Referenced by pg_stat_get_io(), pgstat_bktype_io_stats_valid(), and pgstat_count_io_op_n().

◆ pgstat_twophase_postabort()

void pgstat_twophase_postabort	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 738 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	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 702 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 154 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 440 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()

void PostPrepare_PgStat ( void )

Definition at line 210 of file pgstat_xact.c.

 {
     PgStat_SubXactStatus *xact_state;
  
     /*
      * We don't bother to free any of the transactional state, since it's all
      * in TopTransactionContext and will go away anyway.
      */
     xact_state = pgStatXactStack;
     if (xact_state != NULL)
     {
         Assert(xact_state->nest_level == 1);
         Assert(xact_state->prev == NULL);
  
         PostPrepare_PgStat_Relations(xact_state);
     }
     pgStatXactStack = NULL;
  
     /* Make sure any stats snapshot is thrown away */
     pgstat_clear_snapshot();
 }

References Assert(), PgStat_SubXactStatus::nest_level, pgstat_clear_snapshot(), pgStatXactStack, PostPrepare_PgStat_Relations(), and PgStat_SubXactStatus::prev.

Referenced by PrepareTransaction().

◆ StatsShmemInit()

void StatsShmemInit ( void )

Definition at line 140 of file pgstat_shmem.c.

 {
     bool        found;
     Size        sz;
  
     sz = StatsShmemSize();
     pgStatLocal.shmem = (PgStat_ShmemControl *)
         ShmemInitStruct("Shared Memory Stats", sz, &found);
  
     if (!IsUnderPostmaster)
     {
         dsa_area   *dsa;
         dshash_table *dsh;
         PgStat_ShmemControl *ctl = pgStatLocal.shmem;
         char       *p = (char *) ctl;
  
         Assert(!found);
  
         /* the allocation of pgStatLocal.shmem itself */
         p += MAXALIGN(sizeof(PgStat_ShmemControl));
  
         /*
          * Create a small dsa allocation in plain shared memory. This is
          * required because postmaster cannot use dsm segments. It also
          * provides a small efficiency win.
          */
         ctl->raw_dsa_area = p;
         p += MAXALIGN(pgstat_dsa_init_size());
         dsa = dsa_create_in_place(ctl->raw_dsa_area,
                                   pgstat_dsa_init_size(),
                                   LWTRANCHE_PGSTATS_DSA, 0);
         dsa_pin(dsa);
  
         /*
          * To ensure dshash is created in "plain" shared memory, temporarily
          * limit size of dsa to the initial size of the dsa.
          */
         dsa_set_size_limit(dsa, pgstat_dsa_init_size());
  
         /*
          * With the limit in place, create the dshash table. XXX: It'd be nice
          * if there were dshash_create_in_place().
          */
         dsh = dshash_create(dsa, &dsh_params, 0);
         ctl->hash_handle = dshash_get_hash_table_handle(dsh);
  
         /* lift limit set above */
         dsa_set_size_limit(dsa, -1);
  
         /*
          * Postmaster will never access these again, thus free the local
          * dsa/dshash references.
          */
         dshash_detach(dsh);
         dsa_detach(dsa);
  
         pg_atomic_init_u64(&ctl->gc_request_count, 1);
  
  
         /* initialize fixed-numbered stats */
         LWLockInitialize(&ctl->archiver.lock, LWTRANCHE_PGSTATS_DATA);
         LWLockInitialize(&ctl->bgwriter.lock, LWTRANCHE_PGSTATS_DATA);
         LWLockInitialize(&ctl->checkpointer.lock, LWTRANCHE_PGSTATS_DATA);
         LWLockInitialize(&ctl->slru.lock, LWTRANCHE_PGSTATS_DATA);
         LWLockInitialize(&ctl->wal.lock, LWTRANCHE_PGSTATS_DATA);
  
         for (int i = 0; i < BACKEND_NUM_TYPES; i++)
             LWLockInitialize(&ctl->io.locks[i],
                              LWTRANCHE_PGSTATS_DATA);
     }
     else
     {
         Assert(found);
     }
 }

Referenced by CreateSharedMemoryAndSemaphores().

◆ StatsShmemSize()

Size StatsShmemSize ( void )

Definition at line 126 of file pgstat_shmem.c.

 {
     Size        sz;
  
     sz = MAXALIGN(sizeof(PgStat_ShmemControl));
     sz = add_size(sz, pgstat_dsa_init_size());
  
     return sz;
 }

References add_size(), MAXALIGN, and pgstat_dsa_init_size().

Referenced by CalculateShmemSize(), and StatsShmemInit().

Variable Documentation

◆ PendingBgWriterStats

PGDLLIMPORT PgStat_BgWriterStats PendingBgWriterStats

extern

Definition at line 23 of file pgstat_bgwriter.c.

Referenced by BgBufferSync(), and pgstat_report_bgwriter().

◆ PendingCheckpointerStats

PGDLLIMPORT PgStat_CheckpointerStats PendingCheckpointerStats

extern

Definition at line 23 of file pgstat_checkpointer.c.

Referenced by AbsorbSyncRequests(), BufferSync(), CheckpointerMain(), HandleCheckpointerInterrupts(), LogCheckpointEnd(), and pgstat_report_checkpointer().

◆ PendingWalStats

PGDLLIMPORT PgStat_PendingWalStats PendingWalStats

extern

Definition at line 24 of file pgstat_wal.c.

Referenced by AdvanceXLInsertBuffer(), issue_xlog_fsync(), pgstat_flush_wal(), pgstat_have_pending_wal(), and XLogWrite().

◆ pgstat_fetch_consistency

PGDLLIMPORT int pgstat_fetch_consistency

extern

Definition at line 188 of file pgstat.c.

Referenced by assign_stats_fetch_consistency(), pgstat_build_snapshot(), pgstat_build_snapshot_fixed(), pgstat_fetch_entry(), pgstat_prep_snapshot(), pgstat_snapshot_fixed(), and pgstat_write_statsfile().

◆ pgstat_track_counts

PGDLLIMPORT bool pgstat_track_counts

extern

Definition at line 187 of file pgstat.c.

Referenced by autovac_init(), AutoVacuumingActive(), pgstat_init_relation(), pgstat_report_analyze(), pgstat_report_checksum_failures_in_db(), pgstat_report_deadlock(), pgstat_report_recovery_conflict(), pgstat_report_tempfile(), and pgstat_report_vacuum().

◆ pgstat_track_functions

PGDLLIMPORT int pgstat_track_functions

extern

Definition at line 30 of file pgstat_function.c.

◆ pgStatActiveTime

PGDLLIMPORT PgStat_Counter pgStatActiveTime

extern

Definition at line 30 of file pgstat_database.c.

Referenced by pgstat_update_dbstats().

◆ pgStatBlockReadTime

PGDLLIMPORT PgStat_Counter pgStatBlockReadTime

extern

Definition at line 28 of file pgstat_database.c.

Referenced by do_analyze_rel(), heap_vacuum_rel(), and pgstat_update_dbstats().

◆ pgStatBlockWriteTime

PGDLLIMPORT PgStat_Counter pgStatBlockWriteTime

extern

Definition at line 29 of file pgstat_database.c.

Referenced by do_analyze_rel(), heap_vacuum_rel(), and pgstat_update_dbstats().

◆ pgStatSessionEndCause

PGDLLIMPORT SessionEndType pgStatSessionEndCause

extern

Definition at line 32 of file pgstat_database.c.

Referenced by die(), errfinish(), pgstat_report_disconnect(), and PostgresMain().

◆ pgStatTransactionIdleTime

PGDLLIMPORT PgStat_Counter pgStatTransactionIdleTime

extern

Definition at line 31 of file pgstat_database.c.

Referenced by pgstat_update_dbstats().

Variables
PGDLLIMPORT bool	pgstat_track_counts

PGDLLIMPORT int	pgstat_track_functions

PGDLLIMPORT int	pgstat_fetch_consistency

PGDLLIMPORT PgStat_BgWriterStats	PendingBgWriterStats

PGDLLIMPORT PgStat_CheckpointerStats	PendingCheckpointerStats

PGDLLIMPORT PgStat_Counter	pgStatBlockReadTime

PGDLLIMPORT PgStat_Counter	pgStatBlockWriteTime

PGDLLIMPORT PgStat_Counter	pgStatActiveTime

PGDLLIMPORT PgStat_Counter	pgStatTransactionIdleTime

PGDLLIMPORT SessionEndType	pgStatSessionEndCause

PGDLLIMPORT PgStat_PendingWalStats	PendingWalStats

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ IOCONTEXT_NUM_TYPES

◆ IOOBJECT_NUM_TYPES

◆ IOOP_NUM_TYPES

◆ PG_STAT_TMP_DIR

◆ pgstat_count_buffer_hit

◆ pgstat_count_buffer_read

◆ pgstat_count_buffer_read_time

◆ pgstat_count_buffer_write_time

◆ pgstat_count_conn_active_time

◆ pgstat_count_conn_txn_idle_time

◆ pgstat_count_heap_fetch

◆ pgstat_count_heap_getnext

◆ pgstat_count_heap_scan

◆ pgstat_count_index_scan

◆ pgstat_count_index_tuples

◆ PGSTAT_FILE_FORMAT_ID

◆ PGSTAT_KIND_FIRST_VALID

◆ PGSTAT_KIND_LAST

◆ PGSTAT_NUM_KINDS

◆ pgstat_should_count_relation

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

◆ PGSTAT_STAT_PERMANENT_FILENAME

◆ PGSTAT_STAT_PERMANENT_TMPFILE

Typedef Documentation

◆ IOContext

◆ IOObject

◆ IOOp

◆ PgStat_ArchiverStats

◆ PgStat_BackendSubEntry

◆ PgStat_BgWriterStats

◆ PgStat_BktypeIO

◆ PgStat_CheckpointerStats

◆ PgStat_Counter

◆ PgStat_FetchConsistency

◆ PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

◆ PgStat_IO

◆ PgStat_Kind

◆ PgStat_PendingWalStats

◆ PgStat_SLRUStats

◆ PgStat_StatDBEntry

◆ PgStat_StatFuncEntry

◆ PgStat_StatReplSlotEntry

◆ PgStat_StatSubEntry

◆ PgStat_StatTabEntry

◆ PgStat_TableCounts

◆ PgStat_TableStatus

◆ PgStat_TableXactStatus

◆ PgStat_WalStats

◆ SessionEndType

◆ TrackFunctionsLevel

Enumeration Type Documentation

◆ IOContext

◆ IOObject

◆ IOOp

◆ PgStat_FetchConsistency

◆ PgStat_Kind

◆ SessionEndType

◆ TrackFunctionsLevel

Function Documentation

◆ AtEOSubXact_PgStat()

◆ AtEOXact_PgStat()

◆ AtPrepare_PgStat()

◆ find_funcstat_entry()

◆ find_tabstat_entry()

◆ pgstat_acquire_replslot()

◆ pgstat_assoc_relation()

◆ pgstat_before_server_shutdown()

◆ pgstat_bktype_io_stats_valid()

◆ pgstat_clear_snapshot()

◆ pgstat_copy_relation_stats()

◆ pgstat_count_heap_delete()

◆ pgstat_count_heap_insert()