#include "datatype/timestamp.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "replication/logicalproto.h"
#include "utils/backend_progress.h"
#include "utils/backend_status.h"
#include "utils/hsearch.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_TableCounts

struct	PgStat_TableStatus

struct	PgStat_TableXactStatus

struct	PgStat_MsgHdr

struct	PgStat_MsgDummy

struct	PgStat_MsgInquiry

struct	PgStat_TableEntry

struct	PgStat_MsgTabstat

struct	PgStat_MsgTabpurge

struct	PgStat_MsgDropdb

struct	PgStat_MsgResetcounter

struct	PgStat_MsgResetsharedcounter

struct	PgStat_MsgResetsinglecounter

struct	PgStat_MsgResetslrucounter

struct	PgStat_MsgResetreplslotcounter

struct	PgStat_MsgAutovacStart

struct	PgStat_MsgVacuum

struct	PgStat_MsgAnalyze

struct	PgStat_MsgArchiver

struct	PgStat_MsgBgWriter

struct	PgStat_MsgCheckpointer

struct	PgStat_MsgWal

struct	PgStat_MsgSLRU

struct	PgStat_MsgReplSlot

struct	PgStat_MsgSubscriptionPurge

struct	PgStat_MsgSubWorkerError

struct	PgStat_MsgRecoveryConflict

struct	PgStat_MsgTempFile

struct	PgStat_FunctionCounts

struct	PgStat_BackendFunctionEntry

struct	PgStat_FunctionEntry

struct	PgStat_MsgFuncstat

struct	PgStat_MsgFuncpurge

struct	PgStat_MsgDeadlock

struct	PgStat_MsgChecksumFailure

struct	PgStat_MsgConnect

struct	PgStat_MsgDisconnect

union	PgStat_Msg

struct	PgStat_StatDBEntry

struct	PgStat_StatTabEntry

struct	PgStat_StatFuncEntry

struct	PgStat_ArchiverStats

struct	PgStat_BgWriterStats

struct	PgStat_CheckpointerStats

struct	PgStat_GlobalStats

struct	PgStat_WalStats

struct	PgStat_SLRUStats

struct	PgStat_StatReplSlotEntry

struct	PgStat_StatSubWorkerKey

struct	PgStat_StatSubWorkerEntry

struct	PgStat_FunctionCallUsage

Macros
#define	PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat"

#define	PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/global.stat"

#define	PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/global.tmp"

#define	PG_STAT_TMP_DIR "pg_stat_tmp"

#define	PGSTAT_MAX_MSG_SIZE 1000

#define	PGSTAT_MSG_PAYLOAD (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))

#define	PGSTAT_NUM_TABENTRIES

#define	PGSTAT_NUM_TABPURGE

#define	PGSTAT_NUM_SUBSCRIPTIONPURGE ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) / sizeof(Oid))

#define	PGSTAT_SUBWORKERERROR_MSGLEN 256

#define	PGSTAT_NUM_FUNCENTRIES

#define	PGSTAT_NUM_FUNCPURGE

#define	PGSTAT_FILE_FORMAT_ID 0x01A5BCA5

#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)

#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))

Typedefs
typedef enum TrackFunctionsLevel	TrackFunctionsLevel

typedef enum SessionEndType	SessionEndType

typedef enum StatMsgType	StatMsgType

typedef int64	PgStat_Counter

typedef struct PgStat_TableCounts	PgStat_TableCounts

typedef enum PgStat_Shared_Reset_Target	PgStat_Shared_Reset_Target

typedef enum PgStat_Single_Reset_Type	PgStat_Single_Reset_Type

typedef struct PgStat_TableStatus	PgStat_TableStatus

typedef struct PgStat_TableXactStatus	PgStat_TableXactStatus

typedef struct PgStat_MsgHdr	PgStat_MsgHdr

typedef struct PgStat_MsgDummy	PgStat_MsgDummy

typedef struct PgStat_MsgInquiry	PgStat_MsgInquiry

typedef struct PgStat_TableEntry	PgStat_TableEntry

typedef struct PgStat_MsgTabstat	PgStat_MsgTabstat

typedef struct PgStat_MsgTabpurge	PgStat_MsgTabpurge

typedef struct PgStat_MsgDropdb	PgStat_MsgDropdb

typedef struct PgStat_MsgResetcounter	PgStat_MsgResetcounter

typedef struct PgStat_MsgResetsharedcounter	PgStat_MsgResetsharedcounter

typedef struct PgStat_MsgResetsinglecounter	PgStat_MsgResetsinglecounter

typedef struct PgStat_MsgResetslrucounter	PgStat_MsgResetslrucounter

typedef struct PgStat_MsgResetreplslotcounter	PgStat_MsgResetreplslotcounter

typedef struct PgStat_MsgAutovacStart	PgStat_MsgAutovacStart

typedef struct PgStat_MsgVacuum	PgStat_MsgVacuum

typedef struct PgStat_MsgAnalyze	PgStat_MsgAnalyze

typedef struct PgStat_MsgArchiver	PgStat_MsgArchiver

typedef struct PgStat_MsgBgWriter	PgStat_MsgBgWriter

typedef struct PgStat_MsgCheckpointer	PgStat_MsgCheckpointer

typedef struct PgStat_MsgWal	PgStat_MsgWal

typedef struct PgStat_MsgSLRU	PgStat_MsgSLRU

typedef struct PgStat_MsgReplSlot	PgStat_MsgReplSlot

typedef struct PgStat_MsgSubscriptionPurge	PgStat_MsgSubscriptionPurge

typedef struct PgStat_MsgSubWorkerError	PgStat_MsgSubWorkerError

typedef struct PgStat_MsgRecoveryConflict	PgStat_MsgRecoveryConflict

typedef struct PgStat_MsgTempFile	PgStat_MsgTempFile

typedef struct PgStat_FunctionCounts	PgStat_FunctionCounts

typedef struct PgStat_BackendFunctionEntry	PgStat_BackendFunctionEntry

typedef struct PgStat_FunctionEntry	PgStat_FunctionEntry

typedef struct PgStat_MsgFuncstat	PgStat_MsgFuncstat

typedef struct PgStat_MsgFuncpurge	PgStat_MsgFuncpurge

typedef struct PgStat_MsgDeadlock	PgStat_MsgDeadlock

typedef struct PgStat_MsgChecksumFailure	PgStat_MsgChecksumFailure

typedef struct PgStat_MsgConnect	PgStat_MsgConnect

typedef struct PgStat_MsgDisconnect	PgStat_MsgDisconnect

typedef union PgStat_Msg	PgStat_Msg

typedef struct PgStat_StatDBEntry	PgStat_StatDBEntry

typedef struct PgStat_StatTabEntry	PgStat_StatTabEntry

typedef struct PgStat_StatFuncEntry	PgStat_StatFuncEntry

typedef struct PgStat_ArchiverStats	PgStat_ArchiverStats

typedef struct PgStat_BgWriterStats	PgStat_BgWriterStats

typedef struct PgStat_CheckpointerStats	PgStat_CheckpointerStats

typedef struct PgStat_GlobalStats	PgStat_GlobalStats

typedef struct PgStat_WalStats	PgStat_WalStats

typedef struct PgStat_SLRUStats	PgStat_SLRUStats

typedef struct PgStat_StatReplSlotEntry	PgStat_StatReplSlotEntry

typedef struct PgStat_StatSubWorkerKey	PgStat_StatSubWorkerKey

typedef struct PgStat_StatSubWorkerEntry	PgStat_StatSubWorkerEntry

typedef struct PgStat_FunctionCallUsage	PgStat_FunctionCallUsage

Enumerations
enum	TrackFunctionsLevel { TRACK_FUNC_OFF , TRACK_FUNC_PL , TRACK_FUNC_ALL }

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

enum	StatMsgType { PGSTAT_MTYPE_DUMMY , PGSTAT_MTYPE_INQUIRY , PGSTAT_MTYPE_TABSTAT , PGSTAT_MTYPE_TABPURGE , PGSTAT_MTYPE_DROPDB , PGSTAT_MTYPE_RESETCOUNTER , PGSTAT_MTYPE_RESETSHAREDCOUNTER , PGSTAT_MTYPE_RESETSINGLECOUNTER , PGSTAT_MTYPE_RESETSLRUCOUNTER , PGSTAT_MTYPE_RESETREPLSLOTCOUNTER , PGSTAT_MTYPE_AUTOVAC_START , PGSTAT_MTYPE_VACUUM , PGSTAT_MTYPE_ANALYZE , PGSTAT_MTYPE_ARCHIVER , PGSTAT_MTYPE_BGWRITER , PGSTAT_MTYPE_CHECKPOINTER , PGSTAT_MTYPE_WAL , PGSTAT_MTYPE_SLRU , PGSTAT_MTYPE_FUNCSTAT , PGSTAT_MTYPE_FUNCPURGE , PGSTAT_MTYPE_RECOVERYCONFLICT , PGSTAT_MTYPE_TEMPFILE , PGSTAT_MTYPE_DEADLOCK , PGSTAT_MTYPE_CHECKSUMFAILURE , PGSTAT_MTYPE_REPLSLOT , PGSTAT_MTYPE_CONNECT , PGSTAT_MTYPE_DISCONNECT , PGSTAT_MTYPE_SUBSCRIPTIONPURGE , PGSTAT_MTYPE_SUBWORKERERROR }

enum	PgStat_Shared_Reset_Target { RESET_ARCHIVER , RESET_BGWRITER , RESET_WAL }

enum	PgStat_Single_Reset_Type { RESET_TABLE , RESET_FUNCTION , RESET_SUBWORKER }

Functions
void	pgstat_init (void)

int	pgstat_start (void)

void	pgstat_reset_all (void)

void	allow_immediate_pgstat_restart (void)

void	pgstat_ping (void)

void	pgstat_report_stat (bool force)

void	pgstat_vacuum_stat (void)

void	pgstat_drop_database (Oid databaseid)

void	pgstat_clear_snapshot (void)

void	pgstat_reset_counters (void)

void	pgstat_reset_shared_counters (const char *)

void	pgstat_reset_single_counter (Oid objectid, Oid subobjectid, PgStat_Single_Reset_Type type)

void	pgstat_reset_slru_counter (const char *)

void	pgstat_reset_replslot_counter (const char *name)

void	pgstat_report_connect (Oid dboid)

void	pgstat_report_autovac (Oid dboid)

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_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_replslot (const PgStat_StatReplSlotEntry *repSlotStat)

void	pgstat_report_replslot_create (const char *slotname)

void	pgstat_report_replslot_drop (const char *slotname)

void	pgstat_report_subworker_error (Oid subid, Oid subrelid, Oid relid, LogicalRepMsgType command, TransactionId xid, const char *errmsg)

void	pgstat_report_subscription_drop (Oid subid)

void	pgstat_initialize (void)

PgStat_TableStatus *	find_tabstat_entry (Oid rel_id)

PgStat_BackendFunctionEntry *	find_funcstat_entry (Oid func_id)

void	pgstat_initstats (Relation rel)

void	pgstat_count_heap_insert (Relation rel, PgStat_Counter n)

void	pgstat_count_heap_update (Relation rel, bool hot)

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_init_function_usage (struct FunctionCallInfoBaseData fcinfo, PgStat_FunctionCallUsage fcu)

void	pgstat_end_function_usage (PgStat_FunctionCallUsage *fcu, bool finalize)

void	AtEOXact_PgStat (bool isCommit, bool parallel)

void	AtEOSubXact_PgStat (bool isCommit, int nestDepth)

void	AtPrepare_PgStat (void)

void	PostPrepare_PgStat (void)

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

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

void	pgstat_send_archiver (const char *xlog, bool failed)

void	pgstat_send_bgwriter (void)

void	pgstat_send_checkpointer (void)

void	pgstat_send_wal (bool force)

PgStat_StatDBEntry *	pgstat_fetch_stat_dbentry (Oid dbid)

PgStat_StatTabEntry *	pgstat_fetch_stat_tabentry (Oid relid)

PgStat_StatFuncEntry *	pgstat_fetch_stat_funcentry (Oid funcid)

PgStat_StatSubWorkerEntry *	pgstat_fetch_stat_subworker_entry (Oid subid, Oid subrelid)

PgStat_ArchiverStats *	pgstat_fetch_stat_archiver (void)

PgStat_BgWriterStats *	pgstat_fetch_stat_bgwriter (void)

PgStat_CheckpointerStats *	pgstat_fetch_stat_checkpointer (void)

PgStat_GlobalStats *	pgstat_fetch_global (void)

PgStat_WalStats *	pgstat_fetch_stat_wal (void)

PgStat_SLRUStats *	pgstat_fetch_slru (void)

PgStat_StatReplSlotEntry *	pgstat_fetch_replslot (NameData slotname)

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_slru_name (int slru_idx)

int	pgstat_slru_index (const char *name)

Macro Definition Documentation

◆ PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR "pg_stat_tmp"

Definition at line 34 of file pgstat.h.

◆ pgstat_count_buffer_hit

#define pgstat_count_buffer_hit ( rel )

Value:

    do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_blocks_hit++;            \
    } while (0)

Definition at line 1179 of file pgstat.h.

◆ pgstat_count_buffer_read

#define pgstat_count_buffer_read ( rel )

Value:

    do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_blocks_fetched++;        \
    } while (0)

Definition at line 1174 of file pgstat.h.

◆ pgstat_count_buffer_read_time

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

Definition at line 1184 of file pgstat.h.

◆ pgstat_count_buffer_write_time

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

Definition at line 1186 of file pgstat.h.

◆ pgstat_count_conn_active_time

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

Definition at line 1188 of file pgstat.h.

◆ pgstat_count_conn_txn_idle_time

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

Definition at line 1190 of file pgstat.h.

◆ pgstat_count_heap_fetch

#define pgstat_count_heap_fetch ( rel )

Value:

    do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_tuples_fetched++;        \
    } while (0)

Definition at line 1159 of file pgstat.h.

◆ pgstat_count_heap_getnext

#define pgstat_count_heap_getnext ( rel )

Value:

    do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_tuples_returned++;       \
    } while (0)

Definition at line 1154 of file pgstat.h.

◆ pgstat_count_heap_scan

#define pgstat_count_heap_scan ( rel )

Value:

    do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_numscans++;              \
    } while (0)

Definition at line 1149 of file pgstat.h.

◆ pgstat_count_index_scan

#define pgstat_count_index_scan ( rel )

Value:

    do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_numscans++;              \
    } while (0)

Definition at line 1164 of file pgstat.h.

◆ pgstat_count_index_tuples

#define pgstat_count_index_tuples	(	rel,
		n
	)

Value:

    do {                                                            \
        if ((rel)->pgstat_info != NULL)                             \
            (rel)->pgstat_info->t_counts.t_tuples_returned += (n);  \
    } while (0)

Definition at line 1169 of file pgstat.h.

◆ PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID 0x01A5BCA5

Definition at line 783 of file pgstat.h.

◆ PGSTAT_MAX_MSG_SIZE

#define PGSTAT_MAX_MSG_SIZE 1000

Definition at line 231 of file pgstat.h.

◆ PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))

Definition at line 232 of file pgstat.h.

◆ PGSTAT_NUM_FUNCENTRIES

#define PGSTAT_NUM_FUNCENTRIES

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \

/ sizeof(PgStat_FunctionEntry))

PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD

Definition: pgstat.h:232

Oid

unsigned int Oid

Definition: postgres_ext.h:31

PgStat_FunctionEntry

Definition: pgstat.h:649

Definition at line 661 of file pgstat.h.

◆ PGSTAT_NUM_FUNCPURGE

#define PGSTAT_NUM_FUNCPURGE

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \

/ sizeof(Oid))

Definition at line 678 of file pgstat.h.

◆ PGSTAT_NUM_SUBSCRIPTIONPURGE

#define PGSTAT_NUM_SUBSCRIPTIONPURGE ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) / sizeof(Oid))

Definition at line 549 of file pgstat.h.

◆ PGSTAT_NUM_TABENTRIES

#define PGSTAT_NUM_TABENTRIES

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - 3 * sizeof(int) - 5 * sizeof(PgStat_Counter)) \

/ sizeof(PgStat_TableEntry))

PgStat_TableEntry

struct PgStat_TableEntry PgStat_TableEntry

PgStat_Counter

int64 PgStat_Counter

Definition: pgstat.h:95

Definition at line 288 of file pgstat.h.

◆ PGSTAT_NUM_TABPURGE

#define PGSTAT_NUM_TABPURGE

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \

/ sizeof(Oid))

Definition at line 313 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat"

Definition at line 29 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/global.stat"

Definition at line 30 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/global.tmp"

Definition at line 31 of file pgstat.h.

◆ PGSTAT_SUBWORKERERROR_MSGLEN

#define PGSTAT_SUBWORKERERROR_MSGLEN 256

Definition at line 566 of file pgstat.h.

Typedef Documentation

◆ PgStat_ArchiverStats

typedef struct PgStat_ArchiverStats PgStat_ArchiverStats

◆ PgStat_BackendFunctionEntry

typedef struct PgStat_BackendFunctionEntry PgStat_BackendFunctionEntry

◆ PgStat_BgWriterStats

typedef struct PgStat_BgWriterStats PgStat_BgWriterStats

◆ PgStat_CheckpointerStats

typedef struct PgStat_CheckpointerStats PgStat_CheckpointerStats

◆ PgStat_Counter

typedef int64 PgStat_Counter

Definition at line 95 of file pgstat.h.

◆ PgStat_FunctionCallUsage

typedef struct PgStat_FunctionCallUsage PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

typedef struct PgStat_FunctionCounts PgStat_FunctionCounts

◆ PgStat_FunctionEntry

typedef struct PgStat_FunctionEntry PgStat_FunctionEntry

◆ PgStat_GlobalStats

typedef struct PgStat_GlobalStats PgStat_GlobalStats

◆ PgStat_Msg

typedef union PgStat_Msg PgStat_Msg

◆ PgStat_MsgAnalyze

typedef struct PgStat_MsgAnalyze PgStat_MsgAnalyze

◆ PgStat_MsgArchiver

typedef struct PgStat_MsgArchiver PgStat_MsgArchiver

◆ PgStat_MsgAutovacStart

typedef struct PgStat_MsgAutovacStart PgStat_MsgAutovacStart

◆ PgStat_MsgBgWriter

typedef struct PgStat_MsgBgWriter PgStat_MsgBgWriter

◆ PgStat_MsgCheckpointer

typedef struct PgStat_MsgCheckpointer PgStat_MsgCheckpointer

◆ PgStat_MsgChecksumFailure

typedef struct PgStat_MsgChecksumFailure PgStat_MsgChecksumFailure

◆ PgStat_MsgConnect

typedef struct PgStat_MsgConnect PgStat_MsgConnect

◆ PgStat_MsgDeadlock

typedef struct PgStat_MsgDeadlock PgStat_MsgDeadlock

◆ PgStat_MsgDisconnect

typedef struct PgStat_MsgDisconnect PgStat_MsgDisconnect

◆ PgStat_MsgDropdb

typedef struct PgStat_MsgDropdb PgStat_MsgDropdb

◆ PgStat_MsgDummy

typedef struct PgStat_MsgDummy PgStat_MsgDummy

◆ PgStat_MsgFuncpurge

typedef struct PgStat_MsgFuncpurge PgStat_MsgFuncpurge

◆ PgStat_MsgFuncstat

typedef struct PgStat_MsgFuncstat PgStat_MsgFuncstat

◆ PgStat_MsgHdr

typedef struct PgStat_MsgHdr PgStat_MsgHdr

◆ PgStat_MsgInquiry

typedef struct PgStat_MsgInquiry PgStat_MsgInquiry

◆ PgStat_MsgRecoveryConflict

typedef struct PgStat_MsgRecoveryConflict PgStat_MsgRecoveryConflict

◆ PgStat_MsgReplSlot

typedef struct PgStat_MsgReplSlot PgStat_MsgReplSlot

◆ PgStat_MsgResetcounter

typedef struct PgStat_MsgResetcounter PgStat_MsgResetcounter

◆ PgStat_MsgResetreplslotcounter

typedef struct PgStat_MsgResetreplslotcounter PgStat_MsgResetreplslotcounter

◆ PgStat_MsgResetsharedcounter

typedef struct PgStat_MsgResetsharedcounter PgStat_MsgResetsharedcounter

◆ PgStat_MsgResetsinglecounter

typedef struct PgStat_MsgResetsinglecounter PgStat_MsgResetsinglecounter

◆ PgStat_MsgResetslrucounter

typedef struct PgStat_MsgResetslrucounter PgStat_MsgResetslrucounter

◆ PgStat_MsgSLRU

typedef struct PgStat_MsgSLRU PgStat_MsgSLRU

◆ PgStat_MsgSubscriptionPurge

typedef struct PgStat_MsgSubscriptionPurge PgStat_MsgSubscriptionPurge

◆ PgStat_MsgSubWorkerError

typedef struct PgStat_MsgSubWorkerError PgStat_MsgSubWorkerError

◆ PgStat_MsgTabpurge

typedef struct PgStat_MsgTabpurge PgStat_MsgTabpurge

◆ PgStat_MsgTabstat

typedef struct PgStat_MsgTabstat PgStat_MsgTabstat

◆ PgStat_MsgTempFile

typedef struct PgStat_MsgTempFile PgStat_MsgTempFile

◆ PgStat_MsgVacuum

typedef struct PgStat_MsgVacuum PgStat_MsgVacuum

◆ PgStat_MsgWal

typedef struct PgStat_MsgWal PgStat_MsgWal

◆ PgStat_Shared_Reset_Target

typedef enum PgStat_Shared_Reset_Target PgStat_Shared_Reset_Target

◆ PgStat_Single_Reset_Type

typedef enum PgStat_Single_Reset_Type PgStat_Single_Reset_Type

◆ 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_StatSubWorkerEntry

typedef struct PgStat_StatSubWorkerEntry PgStat_StatSubWorkerEntry

◆ PgStat_StatSubWorkerKey

typedef struct PgStat_StatSubWorkerKey PgStat_StatSubWorkerKey

◆ PgStat_StatTabEntry

typedef struct PgStat_StatTabEntry PgStat_StatTabEntry

◆ PgStat_TableCounts

typedef struct PgStat_TableCounts PgStat_TableCounts

◆ PgStat_TableEntry

typedef struct PgStat_TableEntry PgStat_TableEntry

◆ 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

◆ StatMsgType

typedef enum StatMsgType StatMsgType

◆ TrackFunctionsLevel

typedef enum TrackFunctionsLevel TrackFunctionsLevel

Enumeration Type Documentation

◆ PgStat_Shared_Reset_Target

enum PgStat_Shared_Reset_Target

Enumerator
RESET_ARCHIVER
RESET_BGWRITER
RESET_WAL

Definition at line 140 of file pgstat.h.

 {
     RESET_ARCHIVER,
     RESET_BGWRITER,
     RESET_WAL
 } PgStat_Shared_Reset_Target;

◆ PgStat_Single_Reset_Type

enum PgStat_Single_Reset_Type

Enumerator
RESET_TABLE
RESET_FUNCTION
RESET_SUBWORKER

Definition at line 148 of file pgstat.h.

 {
     RESET_TABLE,
     RESET_FUNCTION,
     RESET_SUBWORKER
 } PgStat_Single_Reset_Type;

◆ SessionEndType

enum SessionEndType

Enumerator
DISCONNECT_NOT_YET
DISCONNECT_NORMAL
DISCONNECT_CLIENT_EOF
DISCONNECT_FATAL
DISCONNECT_KILLED

Definition at line 45 of file pgstat.h.

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

◆ StatMsgType

enum StatMsgType

Enumerator
PGSTAT_MTYPE_DUMMY
PGSTAT_MTYPE_INQUIRY
PGSTAT_MTYPE_TABSTAT
PGSTAT_MTYPE_TABPURGE
PGSTAT_MTYPE_DROPDB
PGSTAT_MTYPE_RESETCOUNTER
PGSTAT_MTYPE_RESETSHAREDCOUNTER
PGSTAT_MTYPE_RESETSINGLECOUNTER
PGSTAT_MTYPE_RESETSLRUCOUNTER
PGSTAT_MTYPE_RESETREPLSLOTCOUNTER
PGSTAT_MTYPE_AUTOVAC_START
PGSTAT_MTYPE_VACUUM
PGSTAT_MTYPE_ANALYZE
PGSTAT_MTYPE_ARCHIVER
PGSTAT_MTYPE_BGWRITER
PGSTAT_MTYPE_CHECKPOINTER
PGSTAT_MTYPE_WAL
PGSTAT_MTYPE_SLRU
PGSTAT_MTYPE_FUNCSTAT
PGSTAT_MTYPE_FUNCPURGE
PGSTAT_MTYPE_RECOVERYCONFLICT
PGSTAT_MTYPE_TEMPFILE
PGSTAT_MTYPE_DEADLOCK
PGSTAT_MTYPE_CHECKSUMFAILURE
PGSTAT_MTYPE_REPLSLOT
PGSTAT_MTYPE_CONNECT
PGSTAT_MTYPE_DISCONNECT
PGSTAT_MTYPE_SUBSCRIPTIONPURGE
PGSTAT_MTYPE_SUBWORKERERROR

Definition at line 58 of file pgstat.h.

 {
     PGSTAT_MTYPE_DUMMY,
     PGSTAT_MTYPE_INQUIRY,
     PGSTAT_MTYPE_TABSTAT,
     PGSTAT_MTYPE_TABPURGE,
     PGSTAT_MTYPE_DROPDB,
     PGSTAT_MTYPE_RESETCOUNTER,
     PGSTAT_MTYPE_RESETSHAREDCOUNTER,
     PGSTAT_MTYPE_RESETSINGLECOUNTER,
     PGSTAT_MTYPE_RESETSLRUCOUNTER,
     PGSTAT_MTYPE_RESETREPLSLOTCOUNTER,
     PGSTAT_MTYPE_AUTOVAC_START,
     PGSTAT_MTYPE_VACUUM,
     PGSTAT_MTYPE_ANALYZE,
     PGSTAT_MTYPE_ARCHIVER,
     PGSTAT_MTYPE_BGWRITER,
     PGSTAT_MTYPE_CHECKPOINTER,
     PGSTAT_MTYPE_WAL,
     PGSTAT_MTYPE_SLRU,
     PGSTAT_MTYPE_FUNCSTAT,
     PGSTAT_MTYPE_FUNCPURGE,
     PGSTAT_MTYPE_RECOVERYCONFLICT,
     PGSTAT_MTYPE_TEMPFILE,
     PGSTAT_MTYPE_DEADLOCK,
     PGSTAT_MTYPE_CHECKSUMFAILURE,
     PGSTAT_MTYPE_REPLSLOT,
     PGSTAT_MTYPE_CONNECT,
     PGSTAT_MTYPE_DISCONNECT,
     PGSTAT_MTYPE_SUBSCRIPTIONPURGE,
     PGSTAT_MTYPE_SUBWORKERERROR,
 } StatMsgType;

◆ TrackFunctionsLevel

enum TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF
TRACK_FUNC_PL
TRACK_FUNC_ALL

Definition at line 37 of file pgstat.h.

 {
     TRACK_FUNC_OFF,
     TRACK_FUNC_PL,
     TRACK_FUNC_ALL
 }           TrackFunctionsLevel;

Function Documentation

◆ allow_immediate_pgstat_restart()

void allow_immediate_pgstat_restart ( void )

Definition at line 835 of file pgstat.c.

842 {

Referenced by HandleChildCrash().

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat	(	bool	isCommit,
		int	nestDepth
	)

Definition at line 2694 of file pgstat.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;

References 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 2582 of file pgstat.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);

References Assert(), AtEOXact_PgStat_Database(), 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 2751 of file pgstat.c.

 {
     PgStat_SubXactStatus *xact_state;
  
     xact_state = pgStatXactStack;
     if (xact_state != NULL)
     {

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

Referenced by PrepareTransaction().

◆ find_funcstat_entry()

PgStat_BackendFunctionEntry* find_funcstat_entry ( Oid func_id )

Definition at line 2083 of file pgstat.c.

 {
     pgstat_assert_is_up();
  
     if (pgStatFunctions == NULL)

References HASH_FIND, hash_search(), pgstat_assert_is_up(), and pgStatFunctions.

Referenced by pg_stat_get_xact_function_calls(), pg_stat_get_xact_function_self_time(), and pg_stat_get_xact_function_total_time().

◆ find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry ( Oid rel_id )

Definition at line 2289 of file pgstat.c.

        : if we got an error in the most recent execution of pgstat_report_stat,
  * it's possible that an entry exists but there's no hashtable entry for it.
  * That's okay, we'll treat this case as "doesn't exist".
  */
 PgStat_TableStatus *
 find_tabstat_entry(Oid rel_id)
 {
     TabStatHashEntry *hash_entry;
  
     /* If hashtable doesn't exist, there are no entries at all */
     if (!pgStatTabHash)
         return NULL;
  
     hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_FIND, NULL);

References HASH_FIND, hash_search(), pgStatTabHash, and TabStatHashEntry::tsa_entry.

Referenced by pg_stat_get_xact_blocks_fetched(), pg_stat_get_xact_blocks_hit(), pg_stat_get_xact_numscans(), pg_stat_get_xact_tuples_deleted(), pg_stat_get_xact_tuples_fetched(), pg_stat_get_xact_tuples_hot_updated(), pg_stat_get_xact_tuples_inserted(), pg_stat_get_xact_tuples_returned(), and pg_stat_get_xact_tuples_updated().

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void )

Definition at line 5149 of file pgstat.c.

 {
     pgstat_assert_is_up();
  
     /* Release memory, if any was allocated */
     if (pgStatLocalContext)
         MemoryContextDelete(pgStatLocalContext);
  
     /* Reset variables */
     pgStatLocalContext = NULL;
     pgStatDBHash = NULL;
     replSlotStatHash = NULL;
  
     /*

References MemoryContextDelete(), pgstat_assert_is_up(), pgstat_clear_backend_activity_snapshot(), pgStatDBHash, pgStatLocalContext, and replSlotStatHash.

Referenced by AtEOXact_PgStat(), autovac_refresh_stats(), AutoVacLauncherMain(), pg_stat_clear_snapshot(), and PostPrepare_PgStat().

◆ pgstat_count_heap_delete()

void pgstat_count_heap_delete ( Relation rel )

Definition at line 2404 of file pgstat.c.

 {
     PgStat_TableStatus *pgstat_info = rel->pgstat_info;
  
     if (pgstat_info != NULL)
     {
         /* We have to log the effect at the proper transactional level */
         int         nest_level = GetCurrentTransactionNestLevel();
  
         if (pgstat_info->trans == NULL ||

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 2358 of file pgstat.c.

 {
     PgStat_TableStatus *pgstat_info = rel->pgstat_info;
  
     if (pgstat_info != NULL)
     {
         /* We have to log the effect at the proper transactional level */
         int         nest_level = GetCurrentTransactionNestLevel();
  
         if (pgstat_info->trans == NULL ||

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

◆ pgstat_count_heap_update()

void pgstat_count_heap_update	(	Relation	rel,
		bool	hot
	)

Definition at line 2379 of file pgstat.c.

 {
     PgStat_TableStatus *pgstat_info = rel->pgstat_info;
  
     if (pgstat_info != NULL)
     {
         /* We have to log the effect at the proper transactional level */
         int         nest_level = GetCurrentTransactionNestLevel();
  
         if (pgstat_info->trans == NULL ||
             pgstat_info->trans->nest_level != nest_level)
             add_tabstat_xact_level(pgstat_info, nest_level);
  
         pgstat_info->trans->tuples_updated++;

Referenced by heap_update().

◆ pgstat_count_slru_flush()

void pgstat_count_slru_flush ( int slru_idx )

Definition at line 6405 of file pgstat.c.

 {
     slru_entry(slru_idx)->m_blocks_written += 1;
 }

References PgStat_MsgSLRU::m_blocks_written, and slru_entry().

Referenced by SimpleLruWriteAll().

◆ pgstat_count_slru_page_exists()

void pgstat_count_slru_page_exists ( int slru_idx )

Definition at line 6387 of file pgstat.c.

 {
     slru_entry(slru_idx)->m_blocks_hit += 1;
 }

References PgStat_MsgSLRU::m_blocks_hit, and slru_entry().

Referenced by SimpleLruDoesPhysicalPageExist().

◆ pgstat_count_slru_page_hit()

void pgstat_count_slru_page_hit ( int slru_idx )

Definition at line 6381 of file pgstat.c.

 {
     slru_entry(slru_idx)->m_blocks_zeroed += 1;
 }

References PgStat_MsgSLRU::m_blocks_zeroed, and 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 6393 of file pgstat.c.

 {
     slru_entry(slru_idx)->m_blocks_exists += 1;
 }

References PgStat_MsgSLRU::m_blocks_exists, and slru_entry().

Referenced by SimpleLruReadPage().

◆ pgstat_count_slru_page_written()

void pgstat_count_slru_page_written ( int slru_idx )

Definition at line 6399 of file pgstat.c.

 {
     slru_entry(slru_idx)->m_blocks_read += 1;
 }

References PgStat_MsgSLRU::m_blocks_read, and slru_entry().

Referenced by SlruPhysicalWritePage().

◆ pgstat_count_slru_page_zeroed()

void pgstat_count_slru_page_zeroed ( int slru_idx )

Definition at line 6375 of file pgstat.c.

6382 {

Referenced by SimpleLruZeroPage().

◆ pgstat_count_slru_truncate()

void pgstat_count_slru_truncate ( int slru_idx )

Definition at line 6411 of file pgstat.c.

 {
     slru_entry(slru_idx)->m_flush += 1;
 }

References PgStat_MsgSLRU::m_flush, and slru_entry().

Referenced by SimpleLruTruncate().

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation rel )

Definition at line 2462 of file pgstat.c.

 {
     PgStat_TableStatus *pgstat_info = rel->pgstat_info;
  
     if (pgstat_info != NULL)
     {
         /* We have to log the effect at the proper transactional level */
         int         nest_level = GetCurrentTransactionNestLevel();
  
         if (pgstat_info->trans == NULL ||
             pgstat_info->trans->nest_level != nest_level)
             add_tabstat_xact_level(pgstat_info, nest_level);
  

Referenced by ExecRefreshMatView(), and ExecuteTruncateGuts().

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid databaseid )

Definition at line 1438 of file pgstat.c.

 {
     PgStat_MsgDropdb msg;
  
     if (pgStatSock == PGINVALID_SOCKET)

References PgStat_MsgDropdb::m_databaseid, PgStat_MsgDropdb::m_hdr, PGINVALID_SOCKET, PGSTAT_MTYPE_DROPDB, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by dropdb(), and pgstat_vacuum_stat().

◆ pgstat_end_function_usage()

void pgstat_end_function_usage	(	PgStat_FunctionCallUsage *	fcu,
		bool	finalize
	)

Definition at line 2105 of file pgstat.c.

 {
     PgStat_FunctionCounts *fs = fcu->fs;
     instr_time  f_total;
     instr_time  f_others;
     instr_time  f_self;
  
     /* stats not wanted? */
     if (fs == NULL)
         return;
  
     /* total elapsed time in this function call */
     INSTR_TIME_SET_CURRENT(f_total);
     INSTR_TIME_SUBTRACT(f_total, fcu->f_start);
  
     /* self usage: elapsed minus anything already charged to other calls */
     f_others = total_func_time;
     INSTR_TIME_SUBTRACT(f_others, fcu->save_total);
     f_self = f_total;
     INSTR_TIME_SUBTRACT(f_self, f_others);
  
     /* update backend-wide total time */
     INSTR_TIME_ADD(total_func_time, f_self);
  
     /*
      * Compute the new f_total_time as the total elapsed time added to the
      * pre-call value of f_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(f_total, fcu->save_f_total_time);
  
     /* update counters in function stats table */
     if (finalize)
         fs->f_numcalls++;

References PgStat_FunctionCounts::f_numcalls, PgStat_FunctionCounts::f_self_time, PgStat_FunctionCallUsage::f_start, PgStat_FunctionCounts::f_total_time, PgStat_FunctionCallUsage::fs, have_function_stats, INSTR_TIME_ADD, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, PgStat_FunctionCallUsage::save_f_total_time, PgStat_FunctionCallUsage::save_total, and total_func_time.

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

◆ pgstat_fetch_global()

PgStat_GlobalStats* pgstat_fetch_global ( void )

Definition at line 3082 of file pgstat.c.

3089 {

References backend_read_statsfile(), and globalStats.

Referenced by pg_stat_get_snapshot_timestamp().

◆ pgstat_fetch_replslot()

PgStat_StatReplSlotEntry* pgstat_fetch_replslot ( NameData slotname )

Definition at line 3130 of file pgstat.c.

3137 {

References backend_read_statsfile(), and pgstat_get_replslot_entry().

Referenced by pg_stat_get_replication_slot().

◆ pgstat_fetch_slru()

PgStat_SLRUStats* pgstat_fetch_slru ( void )

Definition at line 3114 of file pgstat.c.

3121 {

References backend_read_statsfile(), and slruStats.

Referenced by pg_stat_get_slru().

◆ pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver ( void )

Definition at line 3034 of file pgstat.c.

3041 {

References archiverStats, and backend_read_statsfile().

Referenced by pg_stat_get_archiver().

◆ pgstat_fetch_stat_bgwriter()

PgStat_BgWriterStats* pgstat_fetch_stat_bgwriter ( void )

Definition at line 3050 of file pgstat.c.

3057 {

References backend_read_statsfile(), PgStat_GlobalStats::bgwriter, and globalStats.

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 3066 of file pgstat.c.

3073 {

References backend_read_statsfile(), PgStat_GlobalStats::checkpointer, and globalStats.

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 dbid )

Definition at line 2892 of file pgstat.c.

 {
     /*
      * If not done for this transaction, read the statistics collector stats
      * file into some hash tables.
      */
     backend_read_statsfile();
  
     /*

References backend_read_statsfile(), HASH_FIND, hash_search(), and pgStatDBHash.

Referenced by do_autovacuum(), do_start_worker(), pg_stat_get_db_active_time(), pg_stat_get_db_blk_read_time(), pg_stat_get_db_blk_write_time(), pg_stat_get_db_blocks_fetched(), pg_stat_get_db_blocks_hit(), pg_stat_get_db_checksum_failures(), pg_stat_get_db_checksum_last_failure(), pg_stat_get_db_conflict_all(), pg_stat_get_db_conflict_bufferpin(), pg_stat_get_db_conflict_lock(), pg_stat_get_db_conflict_snapshot(), pg_stat_get_db_conflict_startup_deadlock(), pg_stat_get_db_conflict_tablespace(), pg_stat_get_db_deadlocks(), pg_stat_get_db_idle_in_transaction_time(), pg_stat_get_db_session_time(), pg_stat_get_db_sessions(), pg_stat_get_db_sessions_abandoned(), pg_stat_get_db_sessions_fatal(), pg_stat_get_db_sessions_killed(), pg_stat_get_db_stat_reset_time(), pg_stat_get_db_temp_bytes(), pg_stat_get_db_temp_files(), pg_stat_get_db_tuples_deleted(), pg_stat_get_db_tuples_fetched(), pg_stat_get_db_tuples_inserted(), pg_stat_get_db_tuples_returned(), pg_stat_get_db_tuples_updated(), pg_stat_get_db_xact_commit(), pg_stat_get_db_xact_rollback(), pgstat_fetch_stat_funcentry(), pgstat_fetch_stat_subworker_entry(), rebuild_database_list(), and recheck_relation_needs_vacanalyze().

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry ( Oid funcid )

Definition at line 2975 of file pgstat.c.

 {
     PgStat_StatDBEntry *dbentry;
     PgStat_StatFuncEntry *funcentry = NULL;
  
     /* load the stats file if needed */
     backend_read_statsfile();
  
     /* Lookup our database, then find the requested function.  */
     dbentry = pgstat_fetch_stat_dbentry(MyDatabaseId);
     if (dbentry != NULL && dbentry->functions != NULL)
     {
         funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,

References backend_read_statsfile(), PgStat_StatDBEntry::functions, HASH_FIND, hash_search(), MyDatabaseId, and pgstat_fetch_stat_dbentry().

Referenced by pg_stat_get_function_calls(), pg_stat_get_function_self_time(), and pg_stat_get_function_total_time().

◆ pgstat_fetch_stat_subworker_entry()

PgStat_StatSubWorkerEntry* pgstat_fetch_stat_subworker_entry	(	Oid	subid,
		Oid	subrelid
	)

Definition at line 3004 of file pgstat.c.

 {
     PgStat_StatDBEntry *dbentry;
     PgStat_StatSubWorkerEntry *wentry = NULL;
  
     /* Load the stats file if needed */
     backend_read_statsfile();
  
     /*
      * Lookup our database, then find the requested subscription worker stats.
      */
     dbentry = pgstat_fetch_stat_dbentry(MyDatabaseId);
     if (dbentry != NULL && dbentry->subworkers != NULL)
     {

References backend_read_statsfile(), MyDatabaseId, pgstat_fetch_stat_dbentry(), pgstat_get_subworker_entry(), and PgStat_StatDBEntry::subworkers.

Referenced by pg_stat_get_subscription_worker().

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry ( Oid relid )

Definition at line 2919 of file pgstat.c.

 {
     Oid         dbid;
     PgStat_StatDBEntry *dbentry;
     PgStat_StatTabEntry *tabentry;
  
     /*
      * If not done for this transaction, read the statistics collector stats
      * file into some hash tables.
      */
     backend_read_statsfile();
  
     /*
      * Lookup our database, then look in its table hash table.
      */
     dbid = MyDatabaseId;
     dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
                                                  (void *) &dbid,
                                                  HASH_FIND, NULL);
     if (dbentry != NULL && dbentry->tables != NULL)
     {
         tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
                                                        (void *) &relid,
                                                        HASH_FIND, NULL);
         if (tabentry)
             return tabentry;
     }
  
     /*
      * If we didn't find it, maybe it's a shared table.
      */
     dbid = InvalidOid;
     dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
                                                  (void *) &dbid,
                                                  HASH_FIND, NULL);
     if (dbentry != NULL && dbentry->tables != NULL)
     {
         tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
                                                        (void *) &relid,
                                                        HASH_FIND, NULL);

References backend_read_statsfile(), HASH_FIND, hash_search(), InvalidOid, MyDatabaseId, pgStatDBHash, and PgStat_StatDBEntry::tables.

Referenced by index_concurrently_swap(), pg_stat_get_analyze_count(), pg_stat_get_autoanalyze_count(), pg_stat_get_autovacuum_count(), pg_stat_get_blocks_fetched(), pg_stat_get_blocks_hit(), pg_stat_get_dead_tuples(), pg_stat_get_ins_since_vacuum(), pg_stat_get_last_analyze_time(), pg_stat_get_last_autoanalyze_time(), pg_stat_get_last_autovacuum_time(), pg_stat_get_last_vacuum_time(), pg_stat_get_live_tuples(), pg_stat_get_mod_since_analyze(), pg_stat_get_numscans(), pg_stat_get_tuples_deleted(), pg_stat_get_tuples_fetched(), pg_stat_get_tuples_hot_updated(), pg_stat_get_tuples_inserted(), pg_stat_get_tuples_returned(), pg_stat_get_tuples_updated(), and pg_stat_get_vacuum_count().

◆ pgstat_fetch_stat_wal()

PgStat_WalStats* pgstat_fetch_stat_wal ( void )

Definition at line 3098 of file pgstat.c.

3105 {

References backend_read_statsfile(), and walStats.

Referenced by pg_stat_get_wal().

◆ pgstat_init()

void pgstat_init ( void )

Definition at line 395 of file pgstat.c.

 {
     socklen_t   alen;
     struct addrinfo *addrs = NULL,
                *addr,
                 hints;
     int         ret;
     fd_set      rset;
     struct timeval tv;
     char        test_byte;
     int         sel_res;
     int         tries = 0;
  
 #define TESTBYTEVAL ((char) 199)
  
     /*
      * This static assertion verifies that we didn't mess up the calculations
      * involved in selecting maximum payload sizes for our UDP messages.
      * Because the only consequence of overrunning PGSTAT_MAX_MSG_SIZE would
      * be silent performance loss from fragmentation, it seems worth having a
      * compile-time cross-check that we didn't.
      */
     StaticAssertStmt(sizeof(PgStat_Msg) <= PGSTAT_MAX_MSG_SIZE,
                      "maximum stats message size exceeds PGSTAT_MAX_MSG_SIZE");
  
     /*
      * Create the UDP socket for sending and receiving statistic messages
      */
     hints.ai_flags = AI_PASSIVE;
     hints.ai_family = AF_UNSPEC;
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_protocol = 0;
     hints.ai_addrlen = 0;
     hints.ai_addr = NULL;
     hints.ai_canonname = NULL;
     hints.ai_next = NULL;
     ret = pg_getaddrinfo_all("localhost", NULL, &hints, &addrs);
     if (ret || !addrs)
     {
         ereport(LOG,
                 (errmsg("could not resolve \"localhost\": %s",
                         gai_strerror(ret))));
         goto startup_failed;
     }
  
     /*
      * On some platforms, pg_getaddrinfo_all() may return multiple addresses
      * only one of which will actually work (eg, both IPv6 and IPv4 addresses
      * when kernel will reject IPv6).  Worse, the failure may occur at the
      * bind() or perhaps even connect() stage.  So we must loop through the
      * results till we find a working combination. We will generate LOG
      * messages, but no error, for bogus combinations.
      */
     for (addr = addrs; addr; addr = addr->ai_next)
     {
 #ifdef HAVE_UNIX_SOCKETS
         /* Ignore AF_UNIX sockets, if any are returned. */
         if (addr->ai_family == AF_UNIX)
             continue;
 #endif
  
         if (++tries > 1)
             ereport(LOG,
                     (errmsg("trying another address for the statistics collector")));
  
         /*
          * Create the socket.
          */
         if ((pgStatSock = socket(addr->ai_family, SOCK_DGRAM, 0)) == PGINVALID_SOCKET)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not create socket for statistics collector: %m")));
             continue;
         }
  
         /*
          * Bind it to a kernel assigned port on localhost and get the assigned
          * port via getsockname().
          */
         if (bind(pgStatSock, addr->ai_addr, addr->ai_addrlen) < 0)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not bind socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
  
         alen = sizeof(pgStatAddr);
         if (getsockname(pgStatSock, (struct sockaddr *) &pgStatAddr, &alen) < 0)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not get address of socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
  
         /*
          * Connect the socket to its own address.  This saves a few cycles by
          * not having to respecify the target address on every send. This also
          * provides a kernel-level check that only packets from this same
          * address will be received.
          */
         if (connect(pgStatSock, (struct sockaddr *) &pgStatAddr, alen) < 0)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not connect socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
  
         /*
          * Try to send and receive a one-byte test message on the socket. This
          * is to catch situations where the socket can be created but will not
          * actually pass data (for instance, because kernel packet filtering
          * rules prevent it).
          */
         test_byte = TESTBYTEVAL;
  
 retry1:
         if (send(pgStatSock, &test_byte, 1, 0) != 1)
         {
             if (errno == EINTR)
                 goto retry1;    /* if interrupted, just retry */
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not send test message on socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
  
         /*
          * There could possibly be a little delay before the message can be
          * received.  We arbitrarily allow up to half a second before deciding
          * it's broken.
          */
         for (;;)                /* need a loop to handle EINTR */
         {
             FD_ZERO(&rset);
             FD_SET(pgStatSock, &rset);
  
             tv.tv_sec = 0;
             tv.tv_usec = 500000;
             sel_res = select(pgStatSock + 1, &rset, NULL, NULL, &tv);
             if (sel_res >= 0 || errno != EINTR)
                 break;
         }
         if (sel_res < 0)
         {
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("select() failed in statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
         if (sel_res == 0 || !FD_ISSET(pgStatSock, &rset))
         {
             /*
              * This is the case we actually think is likely, so take pains to
              * give a specific message for it.
              *
              * errno will not be set meaningfully here, so don't use it.
              */
             ereport(LOG,
                     (errcode(ERRCODE_CONNECTION_FAILURE),
                      errmsg("test message did not get through on socket for statistics collector")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
  
         test_byte++;            /* just make sure variable is changed */
  
 retry2:
         if (recv(pgStatSock, &test_byte, 1, 0) != 1)
         {
             if (errno == EINTR)
                 goto retry2;    /* if interrupted, just retry */
             ereport(LOG,
                     (errcode_for_socket_access(),
                      errmsg("could not receive test message on socket for statistics collector: %m")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
  
         if (test_byte != TESTBYTEVAL)   /* strictly paranoia ... */
         {
             ereport(LOG,
                     (errcode(ERRCODE_INTERNAL_ERROR),
                      errmsg("incorrect test message transmission on socket for statistics collector")));
             closesocket(pgStatSock);
             pgStatSock = PGINVALID_SOCKET;
             continue;
         }
  
         /* If we get here, we have a working socket */
         break;
     }
  
     /* Did we find a working address? */
     if (!addr || pgStatSock == PGINVALID_SOCKET)
         goto startup_failed;
  
     /*
      * Set the socket to non-blocking IO.  This ensures that if the collector
      * falls behind, statistics messages will be discarded; backends won't
      * block waiting to send messages to the collector.
      */
     if (!pg_set_noblock(pgStatSock))
     {
         ereport(LOG,
                 (errcode_for_socket_access(),
                  errmsg("could not set statistics collector socket to nonblocking mode: %m")));
         goto startup_failed;
     }
  
     /*
      * Try to ensure that the socket's receive buffer is at least
      * PGSTAT_MIN_RCVBUF bytes, so that it won't easily overflow and lose
      * data.  Use of UDP protocol means that we are willing to lose data under
      * heavy load, but we don't want it to happen just because of ridiculously
      * small default buffer sizes (such as 8KB on older Windows versions).
      */
     {
         int         old_rcvbuf;
         int         new_rcvbuf;
         socklen_t   rcvbufsize = sizeof(old_rcvbuf);
  
         if (getsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
                        (char *) &old_rcvbuf, &rcvbufsize) < 0)
         {
             ereport(LOG,
                     (errmsg("%s(%s) failed: %m", "getsockopt", "SO_RCVBUF")));
             /* if we can't get existing size, always try to set it */
             old_rcvbuf = 0;
         }
  
         new_rcvbuf = PGSTAT_MIN_RCVBUF;
         if (old_rcvbuf < new_rcvbuf)
         {
             if (setsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
                            (char *) &new_rcvbuf, sizeof(new_rcvbuf)) < 0)
                 ereport(LOG,
                         (errmsg("%s(%s) failed: %m", "setsockopt", "SO_RCVBUF")));
         }
     }
  
     pg_freeaddrinfo_all(hints.ai_family, addrs);
  
     /* Now that we have a long-lived socket, tell fd.c about it. */
     ReserveExternalFD();
  
     return;
  
 startup_failed:
     ereport(LOG,
             (errmsg("disabling statistics collector for lack of working socket")));
  
     if (addrs)
         pg_freeaddrinfo_all(hints.ai_family, addrs);
  
     if (pgStatSock != PGINVALID_SOCKET)
         closesocket(pgStatSock);
     pgStatSock = PGINVALID_SOCKET;
  
     /*
      * Adjust GUC variables to suppress useless activity, and for debugging

References addrinfo::ai_next, AI_PASSIVE, bind, closesocket, connect, EINTR, ereport, errcode(), errcode_for_socket_access(), errmsg(), gai_strerror, LOG, pg_freeaddrinfo_all(), pg_getaddrinfo_all(), pg_set_noblock(), PGC_INTERNAL, PGC_S_OVERRIDE, PGINVALID_SOCKET, PGSTAT_MAX_MSG_SIZE, PGSTAT_MIN_RCVBUF, pgStatAddr, pgStatSock, recv, ReserveExternalFD(), select, send, SetConfigOption(), socket, StaticAssertStmt, and TESTBYTEVAL.

Referenced by PostmasterMain().

◆ pgstat_init_function_usage()

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

◆ pgstat_initialize()

void pgstat_initialize ( void )

Definition at line 3173 of file pgstat.c.

         : MyDatabaseId isn't set yet; so the shutdown hook has to be careful.
  * ----------
  */
 void
 pgstat_initialize(void)
 {
     Assert(!pgstat_is_initialized);
  
     /*
      * Initialize prevWalUsage with pgWalUsage so that pgstat_send_wal() can
      * calculate how much pgWalUsage counters are increased by subtracting
      * prevWalUsage from pgWalUsage.
      */
     prevWalUsage = pgWalUsage;
  
     /* Set up a process-exit hook to clean up */

References Assert(), before_shmem_exit(), pgstat_shutdown_hook(), pgWalUsage, and prevWalUsage.

Referenced by BaseInit().

◆ pgstat_initstats()

void pgstat_initstats ( Relation rel )

Definition at line 2162 of file pgstat.c.

 {
     Oid         rel_id = rel->rd_id;
     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_info = NULL;
         return;
     }
  
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
     {
         /* We're not counting at all */
         rel->pgstat_info = NULL;
         return;
     }
  
     /*
      * If we already set up this relation in the current transaction, nothing
      * to do.
      */
     if (rel->pgstat_info != NULL &&

References get_tabstat_entry(), PGINVALID_SOCKET, RelationData::pgstat_info, pgstat_track_counts, pgStatSock, RelationData::rd_id, RelationData::rd_rel, and PgStat_TableStatus::t_id.

Referenced by relation_open(), and try_relation_open().

◆ pgstat_ping()

void pgstat_ping ( void )

Definition at line 1997 of file pgstat.c.

 {
     PgStat_MsgDummy msg;
  

References PgStat_MsgDummy::m_hdr, PGINVALID_SOCKET, PGSTAT_MTYPE_DUMMY, pgstat_send(), pgstat_setheader(), and pgStatSock.

◆ pgstat_report_analyze()

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

Definition at line 1679 of file pgstat.c.

 {
     PgStat_MsgAnalyze msg;
  
     if (pgStatSock == PGINVALID_SOCKET || !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 what we send to the collector now, else they'll
      * be double-counted after commit.  (This approach also ensures that the
      * collector ends up with the right numbers if we abort instead of
      * committing.)
      *
      * Waste no time on partitioned tables, though.
      */
     if (rel->pgstat_info != NULL &&
         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->t_counts.t_delta_dead_tuples;
         /* Since ANALYZE's counts are estimates, we could have underflowed */
         livetuples = Max(livetuples, 0);
         deadtuples = Max(deadtuples, 0);
     }
  
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ANALYZE);
     msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
     msg.m_tableoid = RelationGetRelid(rel);
     msg.m_autovacuum = IsAutoVacuumWorkerProcess();

Referenced by do_analyze_rel().

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid dboid )

Definition at line 1629 of file pgstat.c.

 {
     PgStat_MsgAutovacStart msg;
  
     if (pgStatSock == PGINVALID_SOCKET)
         return;
  

References GetCurrentTimestamp(), PgStat_MsgAutovacStart::m_databaseid, PgStat_MsgAutovacStart::m_hdr, PgStat_MsgAutovacStart::m_start_time, PGINVALID_SOCKET, PGSTAT_MTYPE_AUTOVAC_START, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by AutoVacWorkerMain().

◆ pgstat_report_checksum_failure()

void pgstat_report_checksum_failure ( void )

Definition at line 1798 of file pgstat.c.

1805 {

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 1776 of file pgstat.c.

 {
     PgStat_MsgChecksumFailure msg;
  
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;
  
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_CHECKSUMFAILURE);

References GetCurrentTimestamp(), PgStat_MsgChecksumFailure::m_databaseid, PgStat_MsgChecksumFailure::m_failure_time, PgStat_MsgChecksumFailure::m_failurecount, PgStat_MsgChecksumFailure::m_hdr, PGINVALID_SOCKET, PGSTAT_MTYPE_CHECKSUMFAILURE, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by pgstat_report_checksum_failure(), and sendFile().

◆ pgstat_report_connect()

void pgstat_report_connect ( Oid dboid )

Definition at line 1830 of file pgstat.c.

 {
     PgStat_MsgConnect msg;
  
     if (!pgstat_should_report_connstat())
         return;
  

References PgStat_MsgConnect::m_databaseid, PgStat_MsgConnect::m_hdr, MyDatabaseId, MyStartTimestamp, pgLastSessionReportTime, PGSTAT_MTYPE_CONNECT, pgstat_send(), pgstat_setheader(), and pgstat_should_report_connstat().

Referenced by PostgresMain().

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void )

Definition at line 1755 of file pgstat.c.

 {
     PgStat_MsgDeadlock msg;
  
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)

References PgStat_MsgDeadlock::m_databaseid, PgStat_MsgDeadlock::m_hdr, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_DEADLOCK, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by DeadLockReport().

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int reason )

Definition at line 1735 of file pgstat.c.

 {
     PgStat_MsgRecoveryConflict msg;
  
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;

References PgStat_MsgRecoveryConflict::m_databaseid, PgStat_MsgRecoveryConflict::m_hdr, PgStat_MsgRecoveryConflict::m_reason, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_RECOVERYCONFLICT, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by ProcessInterrupts().

◆ pgstat_report_replslot()

void pgstat_report_replslot ( const PgStat_StatReplSlotEntry * repSlotStat )

Definition at line 1887 of file pgstat.c.

 {
     PgStat_MsgReplSlot msg;
  
     /*
      * Prepare and send the message
      */
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_REPLSLOT);
     namestrcpy(&msg.m_slotname, NameStr(repSlotStat->slotname));
     msg.m_create = false;
     msg.m_drop = false;
     msg.m_spill_txns = repSlotStat->spill_txns;
     msg.m_spill_count = repSlotStat->spill_count;
     msg.m_spill_bytes = repSlotStat->spill_bytes;
     msg.m_stream_txns = repSlotStat->stream_txns;

Referenced by UpdateDecodingStats().

◆ pgstat_report_replslot_create()

void pgstat_report_replslot_create ( const char * slotname )

Definition at line 1916 of file pgstat.c.

 {
     PgStat_MsgReplSlot msg;
  

References PgStat_MsgReplSlot::m_create, PgStat_MsgReplSlot::m_drop, PgStat_MsgReplSlot::m_hdr, PgStat_MsgReplSlot::m_slotname, namestrcpy(), PGSTAT_MTYPE_REPLSLOT, pgstat_send(), and pgstat_setheader().

Referenced by ReplicationSlotCreate().

◆ pgstat_report_replslot_drop()

void pgstat_report_replslot_drop ( const char * slotname )

Definition at line 1934 of file pgstat.c.

 {
     PgStat_MsgReplSlot msg;
  

References PgStat_MsgReplSlot::m_create, PgStat_MsgReplSlot::m_drop, PgStat_MsgReplSlot::m_hdr, PgStat_MsgReplSlot::m_slotname, namestrcpy(), PGSTAT_MTYPE_REPLSLOT, pgstat_send(), and pgstat_setheader().

Referenced by pgstat_vacuum_stat(), and ReplicationSlotDropPtr().

◆ pgstat_report_stat()

void pgstat_report_stat ( bool force )

Definition at line 861 of file pgstat.c.

 {
     /* we assume this inits to all zeroes: */
     static const PgStat_TableCounts all_zeroes;
     static TimestampTz last_report = 0;
  
     TimestampTz now;
     PgStat_MsgTabstat regular_msg;
     PgStat_MsgTabstat shared_msg;
     TabStatusArray *tsa;
     int         i;
  
     pgstat_assert_is_up();
  
     /*
      * Don't expend a clock check if nothing to do.
      *
      * To determine whether any WAL activity has occurred since last time, not
      * only the number of generated WAL records but also the numbers of WAL
      * writes and syncs need to be checked. Because even transaction that
      * generates no WAL records can write or sync WAL data when flushing the
      * data pages.
      */
     if ((pgStatTabList == NULL || pgStatTabList->tsa_used == 0) &&
         pgStatXactCommit == 0 && pgStatXactRollback == 0 &&
         pgWalUsage.wal_records == prevWalUsage.wal_records &&
         WalStats.m_wal_write == 0 && WalStats.m_wal_sync == 0 &&
         !have_function_stats && !disconnect)
         return;
  
     /*
      * Don't send a message unless it's been at least PGSTAT_STAT_INTERVAL
      * msec since we last sent one, or the backend is about to exit.
      */
     now = GetCurrentTransactionStopTimestamp();
     if (!disconnect &&
         !TimestampDifferenceExceeds(last_report, now, PGSTAT_STAT_INTERVAL))
         return;
  
     last_report = now;
  
     if (disconnect)
         pgstat_report_disconnect(MyDatabaseId);
  
     /*
      * Destroy pgStatTabHash before we start invalidating PgStat_TableEntry
      * entries it points to.  (Should we fail partway through the loop below,
      * it's okay to have removed the hashtable already --- the only
      * consequence is we'd get multiple entries for the same table in the
      * pgStatTabList, and that's safe.)
      */
     if (pgStatTabHash)
         hash_destroy(pgStatTabHash);
     pgStatTabHash = NULL;
  
     /*
      * Scan through the TabStatusArray struct(s) to find tables that actually
      * have counts, and build messages to send.  We have to separate shared
      * relations from regular ones because the databaseid field in the message
      * header has to depend on that.
      */
     regular_msg.m_databaseid = MyDatabaseId;
     shared_msg.m_databaseid = InvalidOid;
     regular_msg.m_nentries = 0;
     shared_msg.m_nentries = 0;
  
     for (tsa = pgStatTabList; tsa != NULL; tsa = tsa->tsa_next)
     {
         for (i = 0; i < tsa->tsa_used; i++)
         {
             PgStat_TableStatus *entry = &tsa->tsa_entries[i];
             PgStat_MsgTabstat *this_msg;
             PgStat_TableEntry *this_ent;
  
             /* Shouldn't have any pending transaction-dependent counts */
             Assert(entry->trans == NULL);
  
             /*
              * Ignore entries that didn't accumulate any actual counts, such
              * as indexes that were opened by the planner but not used.
              */
             if (memcmp(&entry->t_counts, &all_zeroes,
                        sizeof(PgStat_TableCounts)) == 0)
                 continue;
  
             /*
              * OK, insert data into the appropriate message, and send if full.
              */
             this_msg = entry->t_shared ? &shared_msg : &regular_msg;
             this_ent = &this_msg->m_entry[this_msg->m_nentries];
             this_ent->t_id = entry->t_id;
             memcpy(&this_ent->t_counts, &entry->t_counts,
                    sizeof(PgStat_TableCounts));
             if (++this_msg->m_nentries >= PGSTAT_NUM_TABENTRIES)
             {
                 pgstat_send_tabstat(this_msg, now);
                 this_msg->m_nentries = 0;
             }
         }
         /* zero out PgStat_TableStatus structs after use */
         MemSet(tsa->tsa_entries, 0,
                tsa->tsa_used * sizeof(PgStat_TableStatus));
         tsa->tsa_used = 0;
     }
  
     /*
      * Send partial messages.  Make sure that any pending xact commit/abort
      * and connection stats get counted, even if there are no table stats to
      * send.
      */
     if (regular_msg.m_nentries > 0 ||
         pgStatXactCommit > 0 || pgStatXactRollback > 0 || disconnect)
         pgstat_send_tabstat(&regular_msg, now);
     if (shared_msg.m_nentries > 0)
         pgstat_send_tabstat(&shared_msg, now);
  
     /* Now, send function statistics */
     pgstat_send_funcstats();
  

References Assert(), GetCurrentTransactionStopTimestamp(), hash_destroy(), have_function_stats, i, InvalidOid, PgStat_MsgTabstat::m_databaseid, PgStat_MsgTabstat::m_entry, PgStat_MsgTabstat::m_nentries, PgStat_MsgWal::m_wal_sync, PgStat_MsgWal::m_wal_write, MemSet, MyDatabaseId, now(), pgstat_assert_is_up(), PGSTAT_NUM_TABENTRIES, pgstat_report_disconnect(), pgstat_send_funcstats(), pgstat_send_slru(), pgstat_send_tabstat(), pgstat_send_wal(), PGSTAT_STAT_INTERVAL, pgStatTabHash, pgStatTabList, pgStatXactCommit, pgStatXactRollback, pgWalUsage, prevWalUsage, PgStat_TableStatus::t_counts, PgStat_TableEntry::t_counts, PgStat_TableStatus::t_id, PgStat_TableEntry::t_id, PgStat_TableStatus::t_shared, TimestampDifferenceExceeds(), PgStat_TableStatus::trans, TabStatusArray::tsa_entries, TabStatusArray::tsa_next, TabStatusArray::tsa_used, WalUsage::wal_records, and WalStats.

Referenced by AllTablesyncsReady(), apply_handle_commit_internal(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_rollback_prepared(), apply_handle_stream_prepare(), LogicalRepSyncTableStart(), pg_attribute_noreturn(), pgstat_shutdown_hook(), PostgresMain(), and process_syncing_tables_for_apply().

◆ pgstat_report_subscription_drop()

void pgstat_report_subscription_drop ( Oid subid )

Definition at line 1980 of file pgstat.c.

1987 {

1988 PgStat_MsgSubscriptionPurge msg;

PgStat_MsgSubscriptionPurge

Definition: pgstat.h:553

References PgStat_MsgSubscriptionPurge::m_databaseid, PgStat_MsgSubscriptionPurge::m_nentries, PgStat_MsgSubscriptionPurge::m_subids, MyDatabaseId, and pgstat_send_subscription_purge().

Referenced by DropSubscription(), and pg_stat_reset_subscription_worker_sub().

◆ pgstat_report_subworker_error()

void pgstat_report_subworker_error	(	Oid	subid,
		Oid	subrelid,
		Oid	relid,
		LogicalRepMsgType	command,
		TransactionId	xid,
		const char *	errmsg
	)

Definition at line 1952 of file pgstat.c.

 {
     PgStat_MsgSubWorkerError msg;
     int         len;
  
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_SUBWORKERERROR);
     msg.m_databaseid = MyDatabaseId;
     msg.m_subid = subid;
     msg.m_subrelid = subrelid;
     msg.m_relid = relid;
     msg.m_command = command;
     msg.m_xid = xid;

Referenced by ApplyWorkerMain().

◆ pgstat_report_vacuum()

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

Definition at line 1651 of file pgstat.c.

 {
     PgStat_MsgVacuum msg;
  
     if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
         return;
  
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_VACUUM);
     msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
     msg.m_tableoid = tableoid;

References GetCurrentTimestamp(), InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_MsgVacuum::m_autovacuum, PgStat_MsgVacuum::m_databaseid, PgStat_MsgVacuum::m_dead_tuples, PgStat_MsgVacuum::m_hdr, PgStat_MsgVacuum::m_live_tuples, PgStat_MsgVacuum::m_tableoid, PgStat_MsgVacuum::m_vacuumtime, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_VACUUM, pgstat_send(), pgstat_setheader(), pgstat_track_counts, and pgStatSock.

Referenced by heap_vacuum_rel().

◆ pgstat_reset_all()

void pgstat_reset_all ( void )

Definition at line 730 of file pgstat.c.

737 {

References pgstat_reset_remove_files(), pgstat_stat_directory, and PGSTAT_STAT_PERMANENT_DIRECTORY.

Referenced by StartupXLOG().

◆ pgstat_reset_counters()

void pgstat_reset_counters ( void )

Definition at line 1493 of file pgstat.c.

 {
     PgStat_MsgResetcounter msg;
  
     if (pgStatSock == PGINVALID_SOCKET)

References PgStat_MsgResetcounter::m_databaseid, PgStat_MsgResetcounter::m_hdr, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_RESETCOUNTER, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by pg_stat_reset().

◆ pgstat_reset_replslot_counter()

void pgstat_reset_replslot_counter ( const char * name )

Definition at line 1600 of file pgstat.c.

 {
     PgStat_MsgResetreplslotcounter msg;
  
     if (pgStatSock == PGINVALID_SOCKET)
         return;
  
     if (name)
     {
         namestrcpy(&msg.m_slotname, name);
         msg.clearall = false;
     }
     else

References PgStat_MsgResetreplslotcounter::clearall, PgStat_MsgResetreplslotcounter::m_hdr, PgStat_MsgResetreplslotcounter::m_slotname, name, namestrcpy(), PGINVALID_SOCKET, PGSTAT_MTYPE_RESETREPLSLOTCOUNTER, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by pg_stat_reset_replication_slot().

◆ pgstat_reset_shared_counters()

void pgstat_reset_shared_counters ( const char * target )

Definition at line 1515 of file pgstat.c.

 {
     PgStat_MsgResetsharedcounter msg;
  
     if (pgStatSock == PGINVALID_SOCKET)
         return;
  
     if (strcmp(target, "archiver") == 0)
         msg.m_resettarget = RESET_ARCHIVER;
     else if (strcmp(target, "bgwriter") == 0)
         msg.m_resettarget = RESET_BGWRITER;
     else if (strcmp(target, "wal") == 0)
         msg.m_resettarget = RESET_WAL;
     else
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

References ereport, errcode(), errhint(), errmsg(), ERROR, PgStat_MsgResetsharedcounter::m_hdr, PgStat_MsgResetsharedcounter::m_resettarget, PGINVALID_SOCKET, PGSTAT_MTYPE_RESETSHAREDCOUNTER, pgstat_send(), pgstat_setheader(), pgStatSock, RESET_ARCHIVER, RESET_BGWRITER, and RESET_WAL.

Referenced by pg_stat_reset_shared().

◆ pgstat_reset_single_counter()

void pgstat_reset_single_counter	(	Oid	objectid,
		Oid	subobjectid,
		PgStat_Single_Reset_Type	type
	)

Definition at line 1548 of file pgstat.c.

 {
     PgStat_MsgResetsinglecounter msg;
  
     if (pgStatSock == PGINVALID_SOCKET)
         return;
  
     pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSINGLECOUNTER);
     msg.m_databaseid = MyDatabaseId;

References PgStat_MsgResetsinglecounter::m_databaseid, PgStat_MsgResetsinglecounter::m_hdr, PgStat_MsgResetsinglecounter::m_objectid, PgStat_MsgResetsinglecounter::m_resettype, PgStat_MsgResetsinglecounter::m_subobjectid, MyDatabaseId, PGINVALID_SOCKET, PGSTAT_MTYPE_RESETSINGLECOUNTER, pgstat_send(), pgstat_setheader(), pgStatSock, and generate_unaccent_rules::type.

Referenced by pg_stat_reset_single_function_counters(), pg_stat_reset_single_table_counters(), and pg_stat_reset_subscription_worker_subrel().

◆ pgstat_reset_slru_counter()

void pgstat_reset_slru_counter ( const char * name )

Definition at line 1576 of file pgstat.c.

 {
     PgStat_MsgResetslrucounter msg;
  
     if (pgStatSock == PGINVALID_SOCKET)
         return;

References PgStat_MsgResetslrucounter::m_hdr, PgStat_MsgResetslrucounter::m_index, name, PGINVALID_SOCKET, PGSTAT_MTYPE_RESETSLRUCOUNTER, pgstat_send(), pgstat_setheader(), pgstat_slru_index(), and pgStatSock.

Referenced by pg_stat_reset_slru().

◆ pgstat_send_archiver()

void pgstat_send_archiver	(	const char *	xlog,
		bool	failed
	)

Definition at line 3250 of file pgstat.c.

 {
     PgStat_MsgArchiver msg;
  
     /*
      * Prepare and send the message
      */

References GetCurrentTimestamp(), PgStat_MsgArchiver::m_failed, PgStat_MsgArchiver::m_hdr, PgStat_MsgArchiver::m_timestamp, PgStat_MsgArchiver::m_xlog, PGSTAT_MTYPE_ARCHIVER, pgstat_send(), pgstat_setheader(), and strlcpy().

Referenced by pgarch_ArchiverCopyLoop().

◆ pgstat_send_bgwriter()

void pgstat_send_bgwriter ( void )

Definition at line 3271 of file pgstat.c.

 {
     /* We assume this initializes to zeroes */
     static const PgStat_MsgBgWriter all_zeroes;
  
     pgstat_assert_is_up();
  
     /*
      * This function can be called even if nothing at all has happened. In
      * this case, avoid sending a completely empty message to the stats
      * collector.
      */
     if (memcmp(&PendingBgWriterStats, &all_zeroes, sizeof(PgStat_MsgBgWriter)) == 0)
         return;
  
     /*
      * Prepare and send the message
      */
     pgstat_setheader(&PendingBgWriterStats.m_hdr, PGSTAT_MTYPE_BGWRITER);
     pgstat_send(&PendingBgWriterStats, sizeof(PendingBgWriterStats));

References PgStat_MsgBgWriter::m_hdr, MemSet, PendingBgWriterStats, pgstat_assert_is_up(), PGSTAT_MTYPE_BGWRITER, pgstat_send(), and pgstat_setheader().

Referenced by BackgroundWriterMain().

◆ pgstat_send_checkpointer()

void pgstat_send_checkpointer ( void )

Definition at line 3305 of file pgstat.c.

 {
     /* We assume this initializes to zeroes */
     static const PgStat_MsgCheckpointer all_zeroes;
  
     /*
      * This function can be called even if nothing at all has happened. In
      * this case, avoid sending a completely empty message to the stats
      * collector.
      */
     if (memcmp(&PendingCheckpointerStats, &all_zeroes, sizeof(PgStat_MsgCheckpointer)) == 0)
         return;
  
     /*
      * Prepare and send the message
      */
     pgstat_setheader(&PendingCheckpointerStats.m_hdr, PGSTAT_MTYPE_CHECKPOINTER);
     pgstat_send(&PendingCheckpointerStats, sizeof(PendingCheckpointerStats));

References PgStat_MsgCheckpointer::m_hdr, MemSet, PendingCheckpointerStats, PGSTAT_MTYPE_CHECKPOINTER, pgstat_send(), and pgstat_setheader().

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

◆ pgstat_send_wal()

void pgstat_send_wal ( bool force )

Definition at line 3340 of file pgstat.c.

 {
     static TimestampTz sendTime = 0;
  
     /*
      * This function can be called even if nothing at all has happened. In
      * this case, avoid sending a completely empty message to the stats
      * collector.
      *
      * Check wal_records counter to determine whether any WAL activity has
      * happened since last time. Note that other WalUsage counters don't need
      * to be checked because they are incremented always together with
      * wal_records counter.
      *
      * m_wal_buffers_full also doesn't need to be checked because it's
      * incremented only when at least one WAL record is generated (i.e.,
      * wal_records counter is incremented). But for safely, we assert that
      * m_wal_buffers_full is always zero when no WAL record is generated
      *
      * This function can be called by a process like walwriter that normally
      * generates no WAL records. To determine whether any WAL activity has
      * happened at that process since the last time, the numbers of WAL writes
      * and syncs are also checked.
      */
     if (pgWalUsage.wal_records == prevWalUsage.wal_records &&
         WalStats.m_wal_write == 0 && WalStats.m_wal_sync == 0)
     {
         Assert(WalStats.m_wal_buffers_full == 0);
         return;
     }
  
     if (!force)
     {
         TimestampTz now = GetCurrentTimestamp();
  
         /*
          * Don't send a message unless it's been at least PGSTAT_STAT_INTERVAL
          * msec since we last sent one to avoid overloading the stats
          * collector.
          */
         if (!TimestampDifferenceExceeds(sendTime, now, PGSTAT_STAT_INTERVAL))
             return;
         sendTime = now;
     }
  
     /*
      * Set the counters related to generated WAL data if the counters were
      * updated.
      */
     if (pgWalUsage.wal_records != prevWalUsage.wal_records)
     {
         WalUsage    walusage;
  
         /*
          * Calculate how much WAL usage counters were increased by
          * subtracting the previous counters from the current ones. Fill the
          * results in WAL stats message.
          */
         MemSet(&walusage, 0, sizeof(WalUsage));
         WalUsageAccumDiff(&walusage, &pgWalUsage, &prevWalUsage);
  
         WalStats.m_wal_records = walusage.wal_records;
         WalStats.m_wal_fpi = walusage.wal_fpi;
         WalStats.m_wal_bytes = walusage.wal_bytes;
  
         /*
          * Save the current counters for the subsequent calculation of WAL
          * usage.
          */
         prevWalUsage = pgWalUsage;
     }
  
     /*
      * Prepare and send the message
      */
     pgstat_setheader(&WalStats.m_hdr, PGSTAT_MTYPE_WAL);
     pgstat_send(&WalStats, sizeof(WalStats));

References Assert(), GetCurrentTimestamp(), PgStat_MsgWal::m_hdr, PgStat_MsgWal::m_wal_buffers_full, PgStat_MsgWal::m_wal_bytes, PgStat_MsgWal::m_wal_fpi, PgStat_MsgWal::m_wal_records, PgStat_MsgWal::m_wal_sync, PgStat_MsgWal::m_wal_write, MemSet, now(), PGSTAT_MTYPE_WAL, pgstat_send(), pgstat_setheader(), PGSTAT_STAT_INTERVAL, pgWalUsage, prevWalUsage, TimestampDifferenceExceeds(), WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_records, WalStats, and WalUsageAccumDiff().

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

◆ pgstat_slru_index()

int pgstat_slru_index ( const char * name )

Definition at line 6318 of file pgstat.c.

 {
     int         i;
  
     for (i = 0; i < SLRU_NUM_ELEMENTS; i++)
     {
         if (strcmp(slru_names[i], name) == 0)

References i, name, slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pgstat_reset_slru_counter(), and SimpleLruInit().

◆ pgstat_slru_name()

const char* pgstat_slru_name ( int slru_idx )

Definition at line 6340 of file pgstat.c.

6347 {

References slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pg_stat_get_slru().

◆ pgstat_start()

int pgstat_start ( void )

Definition at line 772 of file pgstat.c.

         : if fail, we will be called again from the postmaster main loop.
  */
 int
 pgstat_start(void)
 {
     time_t      curtime;
     pid_t       pgStatPid;
  
     /*
      * Check that the socket is there, else pgstat_init failed and we can do
      * nothing useful.
      */
     if (pgStatSock == PGINVALID_SOCKET)
         return 0;
  
     /*
      * Do nothing if too soon since last collector start.  This is a safety
      * valve to protect against continuous respawn attempts if the collector
      * is dying immediately at launch.  Note that since we will be re-called
      * from the postmaster main loop, we will get another chance later.
      */
     curtime = time(NULL);
     if ((unsigned int) (curtime - last_pgstat_start_time) <
         (unsigned int) PGSTAT_RESTART_INTERVAL)
         return 0;
     last_pgstat_start_time = curtime;
  
     /*
      * Okay, fork off the collector.
      */
 #ifdef EXEC_BACKEND
     switch ((pgStatPid = pgstat_forkexec()))
 #else
     switch ((pgStatPid = fork_process()))
 #endif
     {
         case -1:
             ereport(LOG,
                     (errmsg("could not fork statistics collector: %m")));
             return 0;
  
 #ifndef EXEC_BACKEND
         case 0:
             /* in postmaster child ... */
             InitPostmasterChild();
  
             /* Close the postmaster's sockets */
             ClosePostmasterPorts(false);
  
             /* Drop our connection to postmaster's shared memory, as well */
             dsm_detach_all();
             PGSharedMemoryDetach();
  
             PgstatCollectorMain(0, NULL);
             break;
 #endif
  
         default:

References ClosePostmasterPorts(), dsm_detach_all(), ereport, errmsg(), fork_process(), InitPostmasterChild(), last_pgstat_start_time, LOG, PGINVALID_SOCKET, PGSharedMemoryDetach(), PGSTAT_RESTART_INTERVAL, PgstatCollectorMain(), and pgStatSock.

Referenced by reaper(), ServerLoop(), and sigusr1_handler().

◆ pgstat_twophase_postabort()

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

Definition at line 2858 of file pgstat.c.

 {
     TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
     PgStat_TableStatus *pgstat_info;
  
     /* Find or create a tabstat entry for the rel */
     pgstat_info = get_tabstat_entry(rec->t_id, rec->t_shared);
  
     /* Same math as in AtEOXact_PgStat, abort case */
     if (rec->t_truncdropped)
     {
         rec->tuples_inserted = rec->inserted_pre_truncdrop;
         rec->tuples_updated = rec->updated_pre_truncdrop;
         rec->tuples_deleted = rec->deleted_pre_truncdrop;
     }

References TwoPhasePgStatRecord::deleted_pre_truncdrop, get_tabstat_entry(), TwoPhasePgStatRecord::inserted_pre_truncdrop, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, TwoPhasePgStatRecord::t_id, TwoPhasePgStatRecord::t_shared, TwoPhasePgStatRecord::t_truncdropped, PgStat_TableCounts::t_tuples_deleted, PgStat_TableCounts::t_tuples_inserted, PgStat_TableCounts::t_tuples_updated, TwoPhasePgStatRecord::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, TwoPhasePgStatRecord::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 2822 of file pgstat.c.

 {
     TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
     PgStat_TableStatus *pgstat_info;
  
     /* Find or create a tabstat entry for the rel */
     pgstat_info = get_tabstat_entry(rec->t_id, rec->t_shared);
  
     /* Same math as in AtEOXact_PgStat, commit case */
     pgstat_info->t_counts.t_tuples_inserted += rec->tuples_inserted;
     pgstat_info->t_counts.t_tuples_updated += rec->tuples_updated;
     pgstat_info->t_counts.t_tuples_deleted += rec->tuples_deleted;
     pgstat_info->t_counts.t_truncdropped = rec->t_truncdropped;
     if (rec->t_truncdropped)
     {
         /* forget live/dead stats seen by backend thus far */
         pgstat_info->t_counts.t_delta_live_tuples = 0;
         pgstat_info->t_counts.t_delta_dead_tuples = 0;
     }
     pgstat_info->t_counts.t_delta_live_tuples +=
         rec->tuples_inserted - rec->tuples_deleted;

References get_tabstat_entry(), PgStat_TableCounts::t_changed_tuples, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, PgStat_TableCounts::t_delta_live_tuples, TwoPhasePgStatRecord::t_id, TwoPhasePgStatRecord::t_shared, TwoPhasePgStatRecord::t_truncdropped, PgStat_TableCounts::t_truncdropped, PgStat_TableCounts::t_tuples_deleted, PgStat_TableCounts::t_tuples_inserted, PgStat_TableCounts::t_tuples_updated, TwoPhasePgStatRecord::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, and TwoPhasePgStatRecord::tuples_updated.

◆ pgstat_update_heap_dead_tuples()

void pgstat_update_heap_dead_tuples	(	Relation	rel,
		int	delta
	)

Definition at line 2491 of file pgstat.c.

2498 {

References RelationData::pgstat_info, PgStat_TableStatus::t_counts, and PgStat_TableCounts::t_delta_dead_tuples.

Referenced by heap_page_prune_opt().

◆ pgstat_vacuum_stat()

void pgstat_vacuum_stat ( void )

Definition at line 1121 of file pgstat.c.

 {
     HTAB       *htab;
     PgStat_MsgTabpurge msg;
     PgStat_MsgFuncpurge f_msg;
     HASH_SEQ_STATUS hstat;
     PgStat_StatDBEntry *dbentry;
     PgStat_StatTabEntry *tabentry;
     PgStat_StatFuncEntry *funcentry;
     int         len;
  
     if (pgStatSock == PGINVALID_SOCKET)
         return;
  
     /*
      * If not done for this transaction, read the statistics collector stats
      * file into some hash tables.
      */
     backend_read_statsfile();
  
     /*
      * Read pg_database and make a list of OIDs of all existing databases
      */
     htab = pgstat_collect_oids(DatabaseRelationId, Anum_pg_database_oid);
  
     /*
      * Search the database hash table for dead databases and tell the
      * collector to drop them.
      */
     hash_seq_init(&hstat, pgStatDBHash);
     while ((dbentry = (PgStat_StatDBEntry *) hash_seq_search(&hstat)) != NULL)
     {
         Oid         dbid = dbentry->databaseid;
  
         CHECK_FOR_INTERRUPTS();
  
         /* the DB entry for shared tables (with InvalidOid) is never dropped */
         if (OidIsValid(dbid) &&
             hash_search(htab, (void *) &dbid, HASH_FIND, NULL) == NULL)
             pgstat_drop_database(dbid);
     }
  
     /* Clean up */
     hash_destroy(htab);
  
     /*
      * Search for all the dead replication slots in stats hashtable and tell
      * the stats collector to drop them.
      */
     if (replSlotStatHash)
     {
         PgStat_StatReplSlotEntry *slotentry;
  
         hash_seq_init(&hstat, replSlotStatHash);
         while ((slotentry = (PgStat_StatReplSlotEntry *) hash_seq_search(&hstat)) != NULL)
         {
             CHECK_FOR_INTERRUPTS();
  
             if (SearchNamedReplicationSlot(NameStr(slotentry->slotname), true) == NULL)
                 pgstat_report_replslot_drop(NameStr(slotentry->slotname));
         }
     }
  
     /*
      * Lookup our own database entry; if not found, nothing more to do.
      */
     dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
                                                  (void *) &MyDatabaseId,
                                                  HASH_FIND, NULL);
     if (dbentry == NULL || dbentry->tables == NULL)
         return;
  
     /*
      * Similarly to above, make a list of all known relations in this DB.
      */
     htab = pgstat_collect_oids(RelationRelationId, Anum_pg_class_oid);
  
     /*
      * Initialize our messages table counter to zero
      */
     msg.m_nentries = 0;
  
     /*
      * Check for all tables listed in stats hashtable if they still exist.
      */
     hash_seq_init(&hstat, dbentry->tables);
     while ((tabentry = (PgStat_StatTabEntry *) hash_seq_search(&hstat)) != NULL)
     {
         Oid         tabid = tabentry->tableid;
  
         CHECK_FOR_INTERRUPTS();
  
         if (hash_search(htab, (void *) &tabid, HASH_FIND, NULL) != NULL)
             continue;
  
         /*
          * Not there, so add this table's Oid to the message
          */
         msg.m_tableid[msg.m_nentries++] = tabid;
  
         /*
          * If the message is full, send it out and reinitialize to empty
          */
         if (msg.m_nentries >= PGSTAT_NUM_TABPURGE)
         {
             len = offsetof(PgStat_MsgTabpurge, m_tableid[0])
                 + msg.m_nentries * sizeof(Oid);
  
             pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
             msg.m_databaseid = MyDatabaseId;
             pgstat_send(&msg, len);
  
             msg.m_nentries = 0;
         }
     }
  
     /*
      * Send the rest
      */
     if (msg.m_nentries > 0)
     {
         len = offsetof(PgStat_MsgTabpurge, m_tableid[0])
             + msg.m_nentries * sizeof(Oid);
  
         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
         msg.m_databaseid = MyDatabaseId;
         pgstat_send(&msg, len);
     }
  
     /* Clean up */
     hash_destroy(htab);
  
     /*
      * Now repeat the above steps for functions.  However, we needn't bother
      * in the common case where no function stats are being collected.
      */
     if (dbentry->functions != NULL &&
         hash_get_num_entries(dbentry->functions) > 0)
     {
         htab = pgstat_collect_oids(ProcedureRelationId, Anum_pg_proc_oid);
  
         pgstat_setheader(&f_msg.m_hdr, PGSTAT_MTYPE_FUNCPURGE);
         f_msg.m_databaseid = MyDatabaseId;
         f_msg.m_nentries = 0;
  
         hash_seq_init(&hstat, dbentry->functions);
         while ((funcentry = (PgStat_StatFuncEntry *) hash_seq_search(&hstat)) != NULL)
         {
             Oid         funcid = funcentry->functionid;
  
             CHECK_FOR_INTERRUPTS();
  
             if (hash_search(htab, (void *) &funcid, HASH_FIND, NULL) != NULL)
                 continue;
  
             /*
              * Not there, so add this function's Oid to the message
              */
             f_msg.m_functionid[f_msg.m_nentries++] = funcid;
  
             /*
              * If the message is full, send it out and reinitialize to empty
              */
             if (f_msg.m_nentries >= PGSTAT_NUM_FUNCPURGE)
             {
                 len = offsetof(PgStat_MsgFuncpurge, m_functionid[0])
                     + f_msg.m_nentries * sizeof(Oid);
  
                 pgstat_send(&f_msg, len);
  
                 f_msg.m_nentries = 0;
             }
         }
  
         /*
          * Send the rest
          */
         if (f_msg.m_nentries > 0)
         {
             len = offsetof(PgStat_MsgFuncpurge, m_functionid[0])
                 + f_msg.m_nentries * sizeof(Oid);
  
             pgstat_send(&f_msg, len);
         }
  
         hash_destroy(htab);
     }
  
     /*
      * Repeat for subscription workers.  Similarly, we needn't bother in the
      * common case where no subscription workers' stats are being collected.
      */
     if (dbentry->subworkers != NULL &&
         hash_get_num_entries(dbentry->subworkers) > 0)
     {
         PgStat_StatSubWorkerEntry *subwentry;
         PgStat_MsgSubscriptionPurge spmsg;
  
         /*
          * Read pg_subscription and make a list of OIDs of all existing
          * subscriptions
          */
         htab = pgstat_collect_oids(SubscriptionRelationId, Anum_pg_subscription_oid);
  
         spmsg.m_databaseid = MyDatabaseId;
         spmsg.m_nentries = 0;
  
         hash_seq_init(&hstat, dbentry->subworkers);
         while ((subwentry = (PgStat_StatSubWorkerEntry *) hash_seq_search(&hstat)) != NULL)
         {
             bool        exists = false;
             Oid         subid = subwentry->key.subid;
  
             CHECK_FOR_INTERRUPTS();
  
             if (hash_search(htab, (void *) &subid, HASH_FIND, NULL) != NULL)
                 continue;
  
             /*
              * It is possible that we have multiple entries for the
              * subscription corresponding to apply worker and tablesync
              * workers. In such cases, we don't need to add the same subid
              * again.
              */
             for (int i = 0; i < spmsg.m_nentries; i++)
             {
                 if (spmsg.m_subids[i] == subid)
                 {
                     exists = true;
                     break;
                 }
             }
  
             if (exists)
                 continue;
  
             /* This subscription is dead, add the subid to the message */
             spmsg.m_subids[spmsg.m_nentries++] = subid;
  
             /*
              * If the message is full, send it out and reinitialize to empty
              */
             if (spmsg.m_nentries >= PGSTAT_NUM_SUBSCRIPTIONPURGE)
             {
                 pgstat_send_subscription_purge(&spmsg);
                 spmsg.m_nentries = 0;
             }
         }
  
         /* Send the rest of dead subscriptions */

References backend_read_statsfile(), CHECK_FOR_INTERRUPTS, PgStat_StatDBEntry::databaseid, PgStat_StatFuncEntry::functionid, PgStat_StatDBEntry::functions, hash_destroy(), HASH_FIND, hash_get_num_entries(), hash_search(), hash_seq_init(), hash_seq_search(), i, PgStat_StatSubWorkerEntry::key, len, PgStat_MsgTabpurge::m_databaseid, PgStat_MsgSubscriptionPurge::m_databaseid, PgStat_MsgFuncpurge::m_databaseid, PgStat_MsgFuncpurge::m_functionid, PgStat_MsgTabpurge::m_hdr, PgStat_MsgFuncpurge::m_hdr, PgStat_MsgTabpurge::m_nentries, PgStat_MsgSubscriptionPurge::m_nentries, PgStat_MsgFuncpurge::m_nentries, PgStat_MsgSubscriptionPurge::m_subids, PgStat_MsgTabpurge::m_tableid, MyDatabaseId, NameStr, offsetof, OidIsValid, PGINVALID_SOCKET, pgstat_collect_oids(), pgstat_drop_database(), PGSTAT_MTYPE_FUNCPURGE, PGSTAT_MTYPE_TABPURGE, PGSTAT_NUM_FUNCPURGE, PGSTAT_NUM_SUBSCRIPTIONPURGE, PGSTAT_NUM_TABPURGE, pgstat_report_replslot_drop(), pgstat_send(), pgstat_send_subscription_purge(), pgstat_setheader(), pgStatDBHash, pgStatSock, replSlotStatHash, SearchNamedReplicationSlot(), PgStat_StatReplSlotEntry::slotname, PgStat_StatSubWorkerKey::subid, PgStat_StatDBEntry::subworkers, PgStat_StatTabEntry::tableid, and PgStat_StatDBEntry::tables.

Referenced by do_autovacuum(), and vacuum().

◆ PostPrepare_PgStat()

void PostPrepare_PgStat ( void )

Definition at line 2794 of file pgstat.c.

        : AtEOXact_PgStat is not called during PREPARE.
  */
 void
 PostPrepare_PgStat(void)
 {
     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);

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

Referenced by PrepareTransaction().

Variable Documentation

◆ PendingBgWriterStats

PgStat_MsgBgWriter PendingBgWriterStats

extern

Definition at line 127 of file pgstat.c.

Referenced by BgBufferSync(), and pgstat_send_bgwriter().

◆ PendingCheckpointerStats

PgStat_MsgCheckpointer PendingCheckpointerStats

extern

Definition at line 128 of file pgstat.c.

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

◆ pgstat_stat_directory

char* pgstat_stat_directory

extern

Definition at line 118 of file pgstat.c.

Referenced by assign_pgstat_temp_directory(), get_dbstat_filename(), perform_base_backup(), and pgstat_reset_all().

◆ pgstat_stat_filename

char* pgstat_stat_filename

extern

Definition at line 119 of file pgstat.c.

Referenced by assign_pgstat_temp_directory(), pgstat_read_db_statsfile_timestamp(), pgstat_read_statsfiles(), and pgstat_write_statsfiles().

◆ pgstat_stat_tmpname

char* pgstat_stat_tmpname

extern

Definition at line 120 of file pgstat.c.

Referenced by assign_pgstat_temp_directory(), and pgstat_write_statsfiles().

◆ pgstat_track_counts

PGDLLIMPORT bool pgstat_track_counts

extern

Definition at line 111 of file pgstat.c.

Referenced by autovac_init(), AutoVacuumingActive(), pgstat_initstats(), 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 112 of file pgstat.c.

◆ pgStatActiveTime

PgStat_Counter pgStatActiveTime

extern

Definition at line 246 of file pgstat.c.

◆ pgStatBlockReadTime

PgStat_Counter pgStatBlockReadTime

extern

Definition at line 243 of file pgstat.c.

Referenced by do_analyze_rel(), and heap_vacuum_rel().

◆ pgStatBlockWriteTime

PgStat_Counter pgStatBlockWriteTime

extern

Definition at line 244 of file pgstat.c.

Referenced by do_analyze_rel(), and heap_vacuum_rel().

◆ pgStatSessionEndCause

SessionEndType pgStatSessionEndCause

extern

Definition at line 248 of file pgstat.c.

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

◆ pgStatTransactionIdleTime

PgStat_Counter pgStatTransactionIdleTime

extern

Definition at line 247 of file pgstat.c.

◆ WalStats

PgStat_MsgWal WalStats

extern

Definition at line 129 of file pgstat.c.

Referenced by AdvanceXLInsertBuffer(), issue_xlog_fsync(), pgstat_report_stat(), pgstat_send_wal(), and XLogWrite().

Variables
PGDLLIMPORT bool	pgstat_track_counts

PGDLLIMPORT int	pgstat_track_functions

char *	pgstat_stat_directory

char *	pgstat_stat_tmpname

char *	pgstat_stat_filename

PgStat_MsgBgWriter	PendingBgWriterStats

PgStat_MsgCheckpointer	PendingCheckpointerStats

PgStat_MsgWal	WalStats

PgStat_Counter	pgStatBlockReadTime

PgStat_Counter	pgStatBlockWriteTime

PgStat_Counter	pgStatActiveTime

PgStat_Counter	pgStatTransactionIdleTime

SessionEndType	pgStatSessionEndCause

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ 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_MAX_MSG_SIZE

◆ PGSTAT_MSG_PAYLOAD

◆ PGSTAT_NUM_FUNCENTRIES

◆ PGSTAT_NUM_FUNCPURGE

◆ PGSTAT_NUM_SUBSCRIPTIONPURGE

◆ PGSTAT_NUM_TABENTRIES

◆ PGSTAT_NUM_TABPURGE

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

◆ PGSTAT_STAT_PERMANENT_FILENAME

◆ PGSTAT_STAT_PERMANENT_TMPFILE

◆ PGSTAT_SUBWORKERERROR_MSGLEN

Typedef Documentation

◆ PgStat_ArchiverStats

◆ PgStat_BackendFunctionEntry

◆ PgStat_BgWriterStats

◆ PgStat_CheckpointerStats

◆ PgStat_Counter

◆ PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

◆ PgStat_FunctionEntry

◆ PgStat_GlobalStats

◆ PgStat_Msg

◆ PgStat_MsgAnalyze

◆ PgStat_MsgArchiver

◆ PgStat_MsgAutovacStart

◆ PgStat_MsgBgWriter

◆ PgStat_MsgCheckpointer

◆ PgStat_MsgChecksumFailure

◆ PgStat_MsgConnect

◆ PgStat_MsgDeadlock

◆ PgStat_MsgDisconnect

◆ PgStat_MsgDropdb

◆ PgStat_MsgDummy

◆ PgStat_MsgFuncpurge

◆ PgStat_MsgFuncstat

◆ PgStat_MsgHdr

◆ PgStat_MsgInquiry

◆ PgStat_MsgRecoveryConflict

◆ PgStat_MsgReplSlot

◆ PgStat_MsgResetcounter

◆ PgStat_MsgResetreplslotcounter

◆ PgStat_MsgResetsharedcounter

◆ PgStat_MsgResetsinglecounter

◆ PgStat_MsgResetslrucounter

◆ PgStat_MsgSLRU

◆ PgStat_MsgSubscriptionPurge

◆ PgStat_MsgSubWorkerError

◆ PgStat_MsgTabpurge

◆ PgStat_MsgTabstat

◆ PgStat_MsgTempFile

◆ PgStat_MsgVacuum

◆ PgStat_MsgWal

◆ PgStat_Shared_Reset_Target

◆ PgStat_Single_Reset_Type

◆ PgStat_SLRUStats

◆ PgStat_StatDBEntry

◆ PgStat_StatFuncEntry

◆ PgStat_StatReplSlotEntry

◆ PgStat_StatSubWorkerEntry

◆ PgStat_StatSubWorkerKey