pgstat.h File Reference

#include "datatype/timestamp.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "utils/backend_progress.h"
#include "utils/backend_status.h"
#include "utils/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_MsgAnlAncestors
struct	PgStat_MsgArchiver
struct	PgStat_MsgBgWriter
struct	PgStat_MsgWal
struct	PgStat_MsgSLRU
struct	PgStat_MsgReplSlot
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_MsgConn
union	PgStat_Msg
struct	PgStat_StatDBEntry
struct	PgStat_StatTabEntry
struct	PgStat_StatFuncEntry
struct	PgStat_ArchiverStats
struct	PgStat_GlobalStats
struct	PgStat_WalStats
struct	PgStat_SLRUStats
struct	PgStat_StatReplSlotEntry
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_ANCESTORENTRIES
#define	PGSTAT_NUM_FUNCENTRIES
#define	PGSTAT_NUM_FUNCPURGE
#define	PGSTAT_FILE_FORMAT_ID   0x01A5BCA2
#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_MsgAnlAncestors	PgStat_MsgAnlAncestors
typedef struct PgStat_MsgArchiver	PgStat_MsgArchiver
typedef struct PgStat_MsgBgWriter	PgStat_MsgBgWriter
typedef struct PgStat_MsgWal	PgStat_MsgWal
typedef struct PgStat_MsgSLRU	PgStat_MsgSLRU
typedef struct PgStat_MsgReplSlot	PgStat_MsgReplSlot
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_MsgConn	PgStat_MsgConn
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_GlobalStats	PgStat_GlobalStats
typedef struct PgStat_WalStats	PgStat_WalStats
typedef struct PgStat_SLRUStats	PgStat_SLRUStats
typedef struct PgStat_StatReplSlotEntry	PgStat_StatReplSlotEntry
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_ANL_ANCESTORS, PGSTAT_MTYPE_ARCHIVER, PGSTAT_MTYPE_BGWRITER,   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_CONNECTION }
enum	PgStat_Shared_Reset_Target { RESET_ARCHIVER, RESET_BGWRITER, RESET_WAL }
enum	PgStat_Single_Reset_Type { RESET_TABLE, RESET_FUNCTION }

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, PgStat_Single_Reset_Type type)
void	pgstat_reset_slru_counter (const char *)
void	pgstat_reset_replslot_counter (const char *name)
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_anl_ancestors (Oid relid)
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_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_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_ArchiverStats *	pgstat_fetch_stat_archiver (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)

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	BgWriterStats
PgStat_MsgWal	WalStats
PgStat_Counter	pgStatBlockReadTime
PgStat_Counter	pgStatBlockWriteTime
PgStat_Counter	pgStatActiveTime
PgStat_Counter	pgStatTransactionIdleTime
SessionEndType	pgStatSessionEndCause

Macro Definition Documentation

PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR   "pg_stat_tmp"

Definition at line 33 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 1055 of file pgstat.h.

Referenced by ReadBufferExtended().

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 1050 of file pgstat.h.

Referenced by ReadBufferExtended().

pgstat_count_buffer_read_time

#define pgstat_count_buffer_read_time

(

n

)

(pgStatBlockReadTime += (n))

Definition at line 1060 of file pgstat.h.

Referenced by ReadBuffer_common().

pgstat_count_buffer_write_time

#define pgstat_count_buffer_write_time

(

n

)

(pgStatBlockWriteTime += (n))

Definition at line 1062 of file pgstat.h.

Referenced by FlushBuffer().

pgstat_count_conn_active_time

#define pgstat_count_conn_active_time

(

n

)

(pgStatActiveTime += (n))

Definition at line 1064 of file pgstat.h.

Referenced by pgstat_report_activity().

pgstat_count_conn_txn_idle_time

#define pgstat_count_conn_txn_idle_time

(

n

)

(pgStatTransactionIdleTime += (n))

Definition at line 1066 of file pgstat.h.

Referenced by pgstat_report_activity().

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 1035 of file pgstat.h.

Referenced by heapam_scan_bitmap_next_tuple(), and index_fetch_heap().

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 1030 of file pgstat.h.

Referenced by heap_getnext(), heap_getnextslot(), heap_getnextslot_tidrange(), and heapam_scan_sample_next_tuple().

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 1025 of file pgstat.h.

Referenced by initscan().

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 1040 of file pgstat.h.

Referenced by _bt_first(), _hash_first(), bringetbitmap(), gistgetbitmap(), and gistgettuple().

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 1045 of file pgstat.h.

Referenced by index_getbitmap(), and index_getnext_tid().

PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID   0x01A5BCA2

Definition at line 724 of file pgstat.h.

Referenced by pgstat_read_db_statsfile(), pgstat_read_db_statsfile_timestamp(), pgstat_read_statsfiles(), pgstat_write_db_statsfile(), and pgstat_write_statsfiles().

PGSTAT_MAX_MSG_SIZE

#define PGSTAT_MAX_MSG_SIZE   1000

Definition at line 224 of file pgstat.h.

Referenced by pgstat_init().

PGSTAT_MSG_PAYLOAD

#define PGSTAT_MSG_PAYLOAD   (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))

Definition at line 225 of file pgstat.h.

PGSTAT_NUM_ANCESTORENTRIES

#define PGSTAT_NUM_ANCESTORENTRIES

Value:

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

Definition at line 440 of file pgstat.h.

Referenced by pgstat_report_anl_ancestors().

PGSTAT_NUM_FUNCENTRIES

#define PGSTAT_NUM_FUNCENTRIES

Value:

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

Definition at line 611 of file pgstat.h.

Referenced by pgstat_send_funcstats().

PGSTAT_NUM_FUNCPURGE

#define PGSTAT_NUM_FUNCPURGE

Value:

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

Definition at line 628 of file pgstat.h.

Referenced by pgstat_vacuum_stat().

PGSTAT_NUM_TABENTRIES

#define PGSTAT_NUM_TABENTRIES

Value:

((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - 3 * sizeof(int) - 2 * sizeof(PgStat_Counter))  \
     / sizeof(PgStat_TableEntry))

Definition at line 281 of file pgstat.h.

Referenced by pgstat_report_stat().

PGSTAT_NUM_TABPURGE

#define PGSTAT_NUM_TABPURGE

Value:

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

Definition at line 303 of file pgstat.h.

Referenced by pgstat_vacuum_stat().

PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY   "pg_stat"

Definition at line 28 of file pgstat.h.

Referenced by get_dbstat_filename(), and pgstat_reset_all().

PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME   "pg_stat/global.stat"

Definition at line 29 of file pgstat.h.

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

PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE   "pg_stat/global.tmp"

Definition at line 30 of file pgstat.h.

Referenced by pgstat_write_statsfiles().

Typedef Documentation

PgStat_ArchiverStats

typedef struct PgStat_ArchiverStats PgStat_ArchiverStats

PgStat_BackendFunctionEntry

typedef struct PgStat_BackendFunctionEntry PgStat_BackendFunctionEntry

PgStat_Counter

typedef int64 PgStat_Counter

Definition at line 91 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_MsgAnlAncestors

typedef struct PgStat_MsgAnlAncestors PgStat_MsgAnlAncestors

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_MsgChecksumFailure

typedef struct PgStat_MsgChecksumFailure PgStat_MsgChecksumFailure

PgStat_MsgConn

typedef struct PgStat_MsgConn PgStat_MsgConn

PgStat_MsgDeadlock

typedef struct PgStat_MsgDeadlock PgStat_MsgDeadlock

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_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_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 136 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

Definition at line 144 of file pgstat.h.

{
    RESET_TABLE,
    RESET_FUNCTION
} PgStat_Single_Reset_Type;

SessionEndType

enum SessionEndType

Enumerator
DISCONNECT_NOT_YET
DISCONNECT_NORMAL
DISCONNECT_CLIENT_EOF
DISCONNECT_FATAL
DISCONNECT_KILLED

Definition at line 44 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_ANL_ANCESTORS
PGSTAT_MTYPE_ARCHIVER
PGSTAT_MTYPE_BGWRITER
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_CONNECTION

Definition at line 57 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_ANL_ANCESTORS,
    PGSTAT_MTYPE_ARCHIVER,
    PGSTAT_MTYPE_BGWRITER,
    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_CONNECTION,
} StatMsgType;

TrackFunctionsLevel

enum TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF
TRACK_FUNC_PL
TRACK_FUNC_ALL

Definition at line 36 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 817 of file pgstat.c.

References last_pgstat_start_time.

Referenced by HandleChildCrash().

{
    last_pgstat_start_time = 0;
}

AtEOSubXact_PgStat()

void AtEOSubXact_PgStat	(	bool	isCommit,
		int	nestDepth
	)

Definition at line 2462 of file pgstat.c.

References Assert, PgStat_SubXactStatus::first, get_tabstat_stack_level(), PgStat_TableXactStatus::nest_level, PgStat_SubXactStatus::nest_level, PgStat_TableXactStatus::next, PgStat_TableXactStatus::parent, pfree(), pgstat_truncate_restore_counters(), pgstat_truncate_save_counters(), pgStatXactStack, PgStat_SubXactStatus::prev, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, PgStat_TableCounts::t_tuples_deleted, PgStat_TableCounts::t_tuples_inserted, PgStat_TableCounts::t_tuples_updated, PgStat_TableStatus::trans, trans, PgStat_TableXactStatus::truncated, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, PgStat_TableXactStatus::tuples_updated, and PgStat_TableXactStatus::upper.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

{
    PgStat_SubXactStatus *xact_state;

    /*
     * Transfer transactional insert/update counts into the next higher
     * subtransaction state.
     */
    xact_state = pgStatXactStack;
    if (xact_state != NULL &&
        xact_state->nest_level >= nestDepth)
    {
        PgStat_TableXactStatus *trans;
        PgStat_TableXactStatus *next_trans;

        /* delink xact_state from stack immediately to simplify reuse case */
        pgStatXactStack = xact_state->prev;

        for (trans = xact_state->first; trans != NULL; trans = next_trans)
        {
            PgStat_TableStatus *tabstat;

            next_trans = trans->next;
            Assert(trans->nest_level == nestDepth);
            tabstat = trans->parent;
            Assert(tabstat->trans == trans);
            if (isCommit)
            {
                if (trans->upper && trans->upper->nest_level == nestDepth - 1)
                {
                    if (trans->truncated)
                    {
                        /* propagate the truncate status one level up */
                        pgstat_truncate_save_counters(trans->upper);
                        /* replace upper xact stats with ours */
                        trans->upper->tuples_inserted = trans->tuples_inserted;
                        trans->upper->tuples_updated = trans->tuples_updated;
                        trans->upper->tuples_deleted = trans->tuples_deleted;
                    }
                    else
                    {
                        trans->upper->tuples_inserted += trans->tuples_inserted;
                        trans->upper->tuples_updated += trans->tuples_updated;
                        trans->upper->tuples_deleted += trans->tuples_deleted;
                    }
                    tabstat->trans = trans->upper;
                    pfree(trans);
                }
                else
                {
                    /*
                     * When there isn't an immediate parent state, we can just
                     * reuse the record instead of going through a
                     * palloc/pfree pushup (this works since it's all in
                     * TopTransactionContext anyway).  We have to re-link it
                     * into the parent level, though, and that might mean
                     * pushing a new entry into the pgStatXactStack.
                     */
                    PgStat_SubXactStatus *upper_xact_state;

                    upper_xact_state = get_tabstat_stack_level(nestDepth - 1);
                    trans->next = upper_xact_state->first;
                    upper_xact_state->first = trans;
                    trans->nest_level = nestDepth - 1;
                }
            }
            else
            {
                /*
                 * On abort, update top-level tabstat counts, then forget the
                 * subtransaction
                 */

                /* first restore values obliterated by truncate */
                pgstat_truncate_restore_counters(trans);
                /* count attempted actions regardless of commit/abort */
                tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
                tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
                tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
                /* inserted tuples are dead, deleted tuples are unaffected */
                tabstat->t_counts.t_delta_dead_tuples +=
                    trans->tuples_inserted + trans->tuples_updated;
                tabstat->trans = trans->upper;
                pfree(trans);
            }
        }
        pfree(xact_state);
    }
}

AtEOXact_PgStat()

void AtEOXact_PgStat	(	bool	isCommit,
		bool	parallel
	)

Definition at line 2375 of file pgstat.c.

References Assert, PgStat_SubXactStatus::first, PgStat_TableXactStatus::nest_level, PgStat_SubXactStatus::nest_level, PgStat_TableXactStatus::next, PgStat_TableXactStatus::parent, pgstat_clear_snapshot(), pgstat_truncate_restore_counters(), pgStatXactCommit, pgStatXactRollback, pgStatXactStack, PgStat_SubXactStatus::prev, PgStat_TableCounts::t_changed_tuples, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, PgStat_TableCounts::t_delta_live_tuples, PgStat_TableCounts::t_truncated, PgStat_TableCounts::t_tuples_deleted, PgStat_TableCounts::t_tuples_inserted, PgStat_TableCounts::t_tuples_updated, PgStat_TableStatus::trans, trans, PgStat_TableXactStatus::truncated, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, PgStat_TableXactStatus::tuples_updated, and PgStat_TableXactStatus::upper.

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

{
    PgStat_SubXactStatus *xact_state;

    /* Don't count parallel worker transaction stats */
    if (!parallel)
    {
        /*
         * Count transaction commit or abort.  (We use counters, not just
         * bools, in case the reporting message isn't sent right away.)
         */
        if (isCommit)
            pgStatXactCommit++;
        else
            pgStatXactRollback++;
    }

    /*
     * Transfer transactional insert/update counts into the base tabstat
     * entries.  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)
    {
        PgStat_TableXactStatus *trans;

        Assert(xact_state->nest_level == 1);
        Assert(xact_state->prev == NULL);
        for (trans = xact_state->first; trans != NULL; trans = trans->next)
        {
            PgStat_TableStatus *tabstat;

            Assert(trans->nest_level == 1);
            Assert(trans->upper == NULL);
            tabstat = trans->parent;
            Assert(tabstat->trans == trans);
            /* restore pre-truncate stats (if any) in case of aborted xact */
            if (!isCommit)
                pgstat_truncate_restore_counters(trans);
            /* count attempted actions regardless of commit/abort */
            tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
            tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
            tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
            if (isCommit)
            {
                tabstat->t_counts.t_truncated = trans->truncated;
                if (trans->truncated)
                {
                    /* forget live/dead stats seen by backend thus far */
                    tabstat->t_counts.t_delta_live_tuples = 0;
                    tabstat->t_counts.t_delta_dead_tuples = 0;
                }
                /* insert adds a live tuple, delete removes one */
                tabstat->t_counts.t_delta_live_tuples +=
                    trans->tuples_inserted - trans->tuples_deleted;
                /* update and delete each create a dead tuple */
                tabstat->t_counts.t_delta_dead_tuples +=
                    trans->tuples_updated + trans->tuples_deleted;
                /* insert, update, delete each count as one change event */
                tabstat->t_counts.t_changed_tuples +=
                    trans->tuples_inserted + trans->tuples_updated +
                    trans->tuples_deleted;
            }
            else
            {
                /* inserted tuples are dead, deleted tuples are unaffected */
                tabstat->t_counts.t_delta_dead_tuples +=
                    trans->tuples_inserted + trans->tuples_updated;
                /* an aborted xact generates no changed_tuple events */
            }
            tabstat->trans = NULL;
        }
    }
    pgStatXactStack = NULL;

    /* Make sure any stats snapshot is thrown away */
    pgstat_clear_snapshot();
}

AtPrepare_PgStat()

void AtPrepare_PgStat

(

void

)

Definition at line 2561 of file pgstat.c.

References Assert, PgStat_TableXactStatus::deleted_pre_trunc, TwoPhasePgStatRecord::deleted_pre_trunc, PgStat_SubXactStatus::first, PgStat_TableXactStatus::inserted_pre_trunc, TwoPhasePgStatRecord::inserted_pre_trunc, PgStat_TableXactStatus::nest_level, PgStat_SubXactStatus::nest_level, PgStat_TableXactStatus::next, PgStat_TableXactStatus::parent, pgStatXactStack, PgStat_SubXactStatus::prev, RegisterTwoPhaseRecord(), PgStat_TableStatus::t_id, TwoPhasePgStatRecord::t_id, PgStat_TableStatus::t_shared, TwoPhasePgStatRecord::t_shared, TwoPhasePgStatRecord::t_truncated, PgStat_TableStatus::trans, trans, PgStat_TableXactStatus::truncated, PgStat_TableXactStatus::tuples_deleted, TwoPhasePgStatRecord::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, TwoPhasePgStatRecord::tuples_inserted, PgStat_TableXactStatus::tuples_updated, TwoPhasePgStatRecord::tuples_updated, TWOPHASE_RM_PGSTAT_ID, PgStat_TableXactStatus::updated_pre_trunc, TwoPhasePgStatRecord::updated_pre_trunc, and PgStat_TableXactStatus::upper.

Referenced by PrepareTransaction().

{
    PgStat_SubXactStatus *xact_state;

    xact_state = pgStatXactStack;
    if (xact_state != NULL)
    {
        PgStat_TableXactStatus *trans;

        Assert(xact_state->nest_level == 1);
        Assert(xact_state->prev == NULL);
        for (trans = xact_state->first; trans != NULL; trans = trans->next)
        {
            PgStat_TableStatus *tabstat;
            TwoPhasePgStatRecord record;

            Assert(trans->nest_level == 1);
            Assert(trans->upper == NULL);
            tabstat = trans->parent;
            Assert(tabstat->trans == trans);

            record.tuples_inserted = trans->tuples_inserted;
            record.tuples_updated = trans->tuples_updated;
            record.tuples_deleted = trans->tuples_deleted;
            record.inserted_pre_trunc = trans->inserted_pre_trunc;
            record.updated_pre_trunc = trans->updated_pre_trunc;
            record.deleted_pre_trunc = trans->deleted_pre_trunc;
            record.t_id = tabstat->t_id;
            record.t_shared = tabstat->t_shared;
            record.t_truncated = trans->truncated;

            RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
                                   &record, sizeof(TwoPhasePgStatRecord));
        }
    }
}

find_funcstat_entry()

PgStat_BackendFunctionEntry* find_funcstat_entry

(

Oid

func_id

)

Definition at line 1959 of file pgstat.c.

References HASH_FIND, and hash_search().

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

{
    if (pgStatFunctions == NULL)
        return NULL;

    return (PgStat_BackendFunctionEntry *) hash_search(pgStatFunctions,
                                                       (void *) &func_id,
                                                       HASH_FIND, NULL);
}

find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry

(

Oid

rel_id

)

Definition at line 2160 of file pgstat.c.

References HASH_FIND, hash_search(), 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().

{
    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);
    if (!hash_entry)
        return NULL;

    /* Note that this step could also return NULL, but that's correct */
    return hash_entry->tsa_entry;
}

pgstat_clear_snapshot()

void pgstat_clear_snapshot

(

void

)

Definition at line 4709 of file pgstat.c.

References MemoryContextDelete(), and pgstat_clear_backend_activity_snapshot().

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

{
    /* Release memory, if any was allocated */
    if (pgStatLocalContext)
        MemoryContextDelete(pgStatLocalContext);

    /* Reset variables */
    pgStatLocalContext = NULL;
    pgStatDBHash = NULL;
    replSlotStatHash = NULL;

    /*
     * Historically the backend_status.c facilities lived in this file, and
     * were reset with the same function. For now keep it that way, and
     * forward the reset request.
     */
    pgstat_clear_backend_activity_snapshot();
}

pgstat_count_heap_delete()

void pgstat_count_heap_delete

(

Relation

rel

)

Definition at line 2275 of file pgstat.c.

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

Referenced by heap_abort_speculative(), and heap_delete().

{
    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_deleted++;
    }
}

pgstat_count_heap_insert()

void pgstat_count_heap_insert	(	Relation	rel,
		PgStat_Counter	n
	)

Definition at line 2229 of file pgstat.c.

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

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

{
    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_inserted += n;
    }
}

pgstat_count_heap_update()

void pgstat_count_heap_update	(	Relation	rel,
		bool	hot
	)

Definition at line 2250 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_tuples_hot_updated, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_update().

{
    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++;

        /* t_tuples_hot_updated is nontransactional, so just advance it */
        if (hot)
            pgstat_info->t_counts.t_tuples_hot_updated++;
    }
}

pgstat_count_slru_flush()

void pgstat_count_slru_flush

(

int

slru_idx

)

Definition at line 5864 of file pgstat.c.

References PgStat_MsgSLRU::m_flush, and slru_entry().

Referenced by SimpleLruWriteAll().

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

pgstat_count_slru_page_exists()

void pgstat_count_slru_page_exists

(

int

slru_idx

)

Definition at line 5846 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_exists, and slru_entry().

Referenced by SimpleLruDoesPhysicalPageExist().

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

pgstat_count_slru_page_hit()

void pgstat_count_slru_page_hit

(

int

slru_idx

)

Definition at line 5840 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_hit, and slru_entry().

Referenced by SimpleLruReadPage(), and SimpleLruReadPage_ReadOnly().

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

pgstat_count_slru_page_read()

void pgstat_count_slru_page_read

(

int

slru_idx

)

Definition at line 5852 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_read, and slru_entry().

Referenced by SimpleLruReadPage().

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

pgstat_count_slru_page_written()

void pgstat_count_slru_page_written

(

int

slru_idx

)

Definition at line 5858 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_written, and slru_entry().

Referenced by SlruPhysicalWritePage().

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

pgstat_count_slru_page_zeroed()

void pgstat_count_slru_page_zeroed

(

int

slru_idx

)

Definition at line 5834 of file pgstat.c.

References PgStat_MsgSLRU::m_blocks_zeroed, and slru_entry().

Referenced by SimpleLruZeroPage().

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

pgstat_count_slru_truncate()

void pgstat_count_slru_truncate

(

int

slru_idx

)

Definition at line 5870 of file pgstat.c.

References PgStat_MsgSLRU::m_truncate, and slru_entry().

Referenced by SimpleLruTruncate().

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

pgstat_count_truncate()

void pgstat_count_truncate

(

Relation

rel

)

Definition at line 2330 of file pgstat.c.

References add_tabstat_xact_level(), GetCurrentTransactionNestLevel(), PgStat_TableXactStatus::nest_level, RelationData::pgstat_info, pgstat_truncate_save_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by ExecRefreshMatView(), and ExecuteTruncateGuts().

{
    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_truncate_save_counters(pgstat_info->trans);
        pgstat_info->trans->tuples_inserted = 0;
        pgstat_info->trans->tuples_updated = 0;
        pgstat_info->trans->tuples_deleted = 0;
    }
}

pgstat_drop_database()

void pgstat_drop_database

(

Oid

databaseid

)

Definition at line 1323 of file pgstat.c.

References PgStat_MsgTabpurge::m_databaseid, PgStat_MsgDropdb::m_databaseid, PgStat_MsgTabpurge::m_hdr, PgStat_MsgDropdb::m_hdr, PgStat_MsgTabpurge::m_nentries, PgStat_MsgTabpurge::m_tableid, MyDatabaseId, offsetof, PGINVALID_SOCKET, PGSTAT_MTYPE_DROPDB, PGSTAT_MTYPE_TABPURGE, pgstat_send(), pgstat_setheader(), and pgStatSock.

Referenced by dropdb(), and pgstat_vacuum_stat().

{
    PgStat_MsgDropdb msg;

    if (pgStatSock == PGINVALID_SOCKET)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DROPDB);
    msg.m_databaseid = databaseid;
    pgstat_send(&msg, sizeof(msg));
}

pgstat_end_function_usage()

void pgstat_end_function_usage	(	PgStat_FunctionCallUsage *	fcu,
		bool	finalize
	)

Definition at line 1979 of file pgstat.c.

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_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++;
    fs->f_total_time = f_total;
    INSTR_TIME_ADD(fs->f_self_time, f_self);

    /* indicate that we have something to send */
    have_function_stats = true;
}

pgstat_fetch_global()

PgStat_GlobalStats* pgstat_fetch_global

(

void

)

Definition at line 2843 of file pgstat.c.

References backend_read_statsfile(), and globalStats.

Referenced by pg_stat_get_bgwriter_buf_written_checkpoints(), pg_stat_get_bgwriter_buf_written_clean(), pg_stat_get_bgwriter_maxwritten_clean(), pg_stat_get_bgwriter_requested_checkpoints(), pg_stat_get_bgwriter_stat_reset_time(), pg_stat_get_bgwriter_timed_checkpoints(), pg_stat_get_buf_alloc(), pg_stat_get_buf_fsync_backend(), pg_stat_get_buf_written_backend(), pg_stat_get_checkpoint_sync_time(), pg_stat_get_checkpoint_write_time(), and pg_stat_get_snapshot_timestamp().

{
    backend_read_statsfile();

    return &globalStats;
}

pgstat_fetch_replslot()

PgStat_StatReplSlotEntry* pgstat_fetch_replslot

(

NameData

slotname

)

Definition at line 2891 of file pgstat.c.

References backend_read_statsfile(), and pgstat_get_replslot_entry().

Referenced by pg_stat_get_replication_slot().

{
    backend_read_statsfile();

    return pgstat_get_replslot_entry(slotname, false);
}

pgstat_fetch_slru()

PgStat_SLRUStats* pgstat_fetch_slru

(

void

)

Definition at line 2875 of file pgstat.c.

References backend_read_statsfile(), and slruStats.

Referenced by pg_stat_get_slru().

{
    backend_read_statsfile();

    return slruStats;
}

pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver

(

void

)

Definition at line 2826 of file pgstat.c.

References archiverStats, and backend_read_statsfile().

Referenced by pg_stat_get_archiver().

{
    backend_read_statsfile();

    return &archiverStats;
}

pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry

(

Oid

dbid

)

Definition at line 2713 of file pgstat.c.

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

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(), rebuild_database_list(), and recheck_relation_needs_vacanalyze().

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

    /*
     * Lookup the requested database; return NULL if not found
     */
    return (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
                                              (void *) &dbid,
                                              HASH_FIND, NULL);
}

pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry

(

Oid

funcid

)

Definition at line 2796 of file pgstat.c.

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_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,
                                                         (void *) &func_id,
                                                         HASH_FIND, NULL);
    }

    return funcentry;
}

pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry

(

Oid

relid

)

Definition at line 2740 of file pgstat.c.

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

Referenced by do_autovacuum(), 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().

{
    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);
        if (tabentry)
            return tabentry;
    }

    return NULL;
}

pgstat_fetch_stat_wal()

PgStat_WalStats* pgstat_fetch_stat_wal

(

void

)

Definition at line 2859 of file pgstat.c.

References backend_read_statsfile(), and walStats.

Referenced by pg_stat_get_wal().

{
    backend_read_statsfile();

    return &walStats;
}

pgstat_init()

void pgstat_init

(

void

)

Definition at line 377 of file pgstat.c.

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().

{
    ACCEPT_TYPE_ARG3 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;
        ACCEPT_TYPE_ARG3 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
     * purposes (seeing track_counts off is a clue that we failed here). We
     * use PGC_S_OVERRIDE because there is no point in trying to turn it back
     * on from postgresql.conf without a restart.
     */
    SetConfigOption("track_counts", "off", PGC_INTERNAL, PGC_S_OVERRIDE);
}

pgstat_init_function_usage()

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

pgstat_initialize()

void pgstat_initialize

(

void

)

Definition at line 2928 of file pgstat.c.

References on_shmem_exit(), pgstat_shutdown_hook(), and pgWalUsage.

Referenced by AuxiliaryProcessMain(), and InitPostgres().

{
    /*
     * Initialize prevWalUsage with pgWalUsage so that pgstat_send_wal() can
     * calculate how much pgWalUsage counters are increased by substracting
     * prevWalUsage from pgWalUsage.
     */
    prevWalUsage = pgWalUsage;

    /* Set up a process-exit hook to clean up */
    on_shmem_exit(pgstat_shutdown_hook, 0);
}

pgstat_initstats()

void pgstat_initstats

(

Relation

rel

)

Definition at line 2036 of file pgstat.c.

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().

{
    Oid         rel_id = rel->rd_id;
    char        relkind = rel->rd_rel->relkind;

    /* We only count stats for things that have storage */
    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 &&
        rel->pgstat_info->t_id == rel_id)
        return;

    /* Else find or make the PgStat_TableStatus entry, and update link */
    rel->pgstat_info = get_tabstat_entry(rel_id, rel->rd_rel->relisshared);
}

pgstat_ping()

void pgstat_ping

(

void

)

Definition at line 1873 of file pgstat.c.

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

{
    PgStat_MsgDummy msg;

    if (pgStatSock == PGINVALID_SOCKET)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DUMMY);
    pgstat_send(&msg, sizeof(msg));
}

pgstat_report_analyze()

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

Definition at line 1608 of file pgstat.c.

References GetCurrentTimestamp(), InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_MsgAnalyze::m_analyzetime, PgStat_MsgAnalyze::m_autovacuum, PgStat_MsgAnalyze::m_databaseid, PgStat_MsgAnalyze::m_dead_tuples, PgStat_MsgAnalyze::m_hdr, PgStat_MsgAnalyze::m_live_tuples, PgStat_MsgAnalyze::m_resetcounter, PgStat_MsgAnalyze::m_tableoid, Max, MyDatabaseId, PGINVALID_SOCKET, RelationData::pgstat_info, PGSTAT_MTYPE_ANALYZE, pgstat_send(), pgstat_setheader(), pgstat_track_counts, pgStatSock, RelationData::rd_rel, RelationGetRelid, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, PgStat_TableStatus::trans, trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, PgStat_TableXactStatus::tuples_updated, and PgStat_TableXactStatus::upper.

Referenced by do_analyze_rel().

{
    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.)
     *
     * For partitioned tables, we don't report live and dead tuples, because
     * such tables don't have any data.
     */
    if (rel->pgstat_info != NULL)
    {
        PgStat_TableXactStatus *trans;

        if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
            /* If this rel is partitioned, skip modifying */
            livetuples = deadtuples = 0;
        else
        {
            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();
    msg.m_resetcounter = resetcounter;
    msg.m_analyzetime = GetCurrentTimestamp();
    msg.m_live_tuples = livetuples;
    msg.m_dead_tuples = deadtuples;
    pgstat_send(&msg, sizeof(msg));

}

pgstat_report_anl_ancestors()

void pgstat_report_anl_ancestors

(

Oid

relid

)

Definition at line 1674 of file pgstat.c.

References get_partition_ancestors(), lfirst_oid, list_free(), PgStat_MsgAnlAncestors::m_ancestors, PgStat_MsgAnlAncestors::m_databaseid, PgStat_MsgAnlAncestors::m_hdr, PgStat_MsgAnlAncestors::m_nancestors, PgStat_MsgAnlAncestors::m_tableoid, MyDatabaseId, offsetof, PGSTAT_MTYPE_ANL_ANCESTORS, PGSTAT_NUM_ANCESTORENTRIES, pgstat_send(), and pgstat_setheader().

Referenced by do_analyze_rel(), and do_autovacuum().

{
    PgStat_MsgAnlAncestors msg;
    List       *ancestors;
    ListCell   *lc;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ANL_ANCESTORS);
    msg.m_databaseid = MyDatabaseId;
    msg.m_tableoid = relid;
    msg.m_nancestors = 0;

    ancestors = get_partition_ancestors(relid);
    foreach(lc, ancestors)
    {
        Oid         ancestor = lfirst_oid(lc);

        msg.m_ancestors[msg.m_nancestors] = ancestor;
        if (++msg.m_nancestors >= PGSTAT_NUM_ANCESTORENTRIES)
        {
            pgstat_send(&msg, offsetof(PgStat_MsgAnlAncestors, m_ancestors[0]) +
                        msg.m_nancestors * sizeof(Oid));
            msg.m_nancestors = 0;
        }
    }

    if (msg.m_nancestors > 0)
        pgstat_send(&msg, offsetof(PgStat_MsgAnlAncestors, m_ancestors[0]) +
                    msg.m_nancestors * sizeof(Oid));

    list_free(ancestors);
}

pgstat_report_autovac()

void pgstat_report_autovac

(

Oid

dboid

)

Definition at line 1555 of file pgstat.c.

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_MsgAutovacStart msg;

    if (pgStatSock == PGINVALID_SOCKET)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_AUTOVAC_START);
    msg.m_databaseid = dboid;
    msg.m_start_time = GetCurrentTimestamp();

    pgstat_send(&msg, sizeof(msg));
}

pgstat_report_checksum_failure()

void pgstat_report_checksum_failure

(

void

)

Definition at line 1776 of file pgstat.c.

References MyDatabaseId, and pgstat_report_checksum_failures_in_db().

Referenced by PageIsVerifiedExtended().

{
    pgstat_report_checksum_failures_in_db(MyDatabaseId, 1);
}

pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db	(	Oid	dboid,
		int	failurecount
	)

Definition at line 1754 of file pgstat.c.

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_MsgChecksumFailure msg;

    if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_CHECKSUMFAILURE);
    msg.m_databaseid = dboid;
    msg.m_failurecount = failurecount;
    msg.m_failure_time = GetCurrentTimestamp();

    pgstat_send(&msg, sizeof(msg));
}

pgstat_report_deadlock()

void pgstat_report_deadlock

(

void

)

Definition at line 1733 of file pgstat.c.

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_MsgDeadlock msg;

    if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DEADLOCK);
    msg.m_databaseid = MyDatabaseId;
    pgstat_send(&msg, sizeof(msg));
}

pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict

(

int

reason

)

Definition at line 1713 of file pgstat.c.

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_MsgRecoveryConflict msg;

    if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RECOVERYCONFLICT);
    msg.m_databaseid = MyDatabaseId;
    msg.m_reason = reason;
    pgstat_send(&msg, sizeof(msg));
}

pgstat_report_replslot()

void pgstat_report_replslot

(

const PgStat_StatReplSlotEntry *

repSlotStat

)

Definition at line 1808 of file pgstat.c.

References PgStat_MsgReplSlot::m_create, PgStat_MsgReplSlot::m_drop, PgStat_MsgReplSlot::m_hdr, PgStat_MsgReplSlot::m_slotname, PgStat_MsgReplSlot::m_spill_bytes, PgStat_MsgReplSlot::m_spill_count, PgStat_MsgReplSlot::m_spill_txns, PgStat_MsgReplSlot::m_stream_bytes, PgStat_MsgReplSlot::m_stream_count, PgStat_MsgReplSlot::m_stream_txns, PgStat_MsgReplSlot::m_total_bytes, PgStat_MsgReplSlot::m_total_txns, NameStr, namestrcpy(), PGSTAT_MTYPE_REPLSLOT, pgstat_send(), pgstat_setheader(), PgStat_StatReplSlotEntry::slotname, PgStat_StatReplSlotEntry::spill_bytes, PgStat_StatReplSlotEntry::spill_count, PgStat_StatReplSlotEntry::spill_txns, PgStat_StatReplSlotEntry::stream_bytes, PgStat_StatReplSlotEntry::stream_count, PgStat_StatReplSlotEntry::stream_txns, PgStat_StatReplSlotEntry::total_bytes, and PgStat_StatReplSlotEntry::total_txns.

Referenced by UpdateDecodingStats().

{
    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;
    msg.m_stream_count = repSlotStat->stream_count;
    msg.m_stream_bytes = repSlotStat->stream_bytes;
    msg.m_total_txns = repSlotStat->total_txns;
    msg.m_total_bytes = repSlotStat->total_bytes;
    pgstat_send(&msg, sizeof(PgStat_MsgReplSlot));
}

pgstat_report_replslot_create()

void pgstat_report_replslot_create

(

const char *

slotname

)

Definition at line 1837 of file pgstat.c.

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_MsgReplSlot msg;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_REPLSLOT);
    namestrcpy(&msg.m_slotname, slotname);
    msg.m_create = true;
    msg.m_drop = false;
    pgstat_send(&msg, sizeof(PgStat_MsgReplSlot));
}

pgstat_report_replslot_drop()

void pgstat_report_replslot_drop

(

const char *

slotname

)

Definition at line 1855 of file pgstat.c.

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_MsgReplSlot msg;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_REPLSLOT);
    namestrcpy(&msg.m_slotname, slotname);
    msg.m_create = false;
    msg.m_drop = true;
    pgstat_send(&msg, sizeof(PgStat_MsgReplSlot));
}

pgstat_report_stat()

void pgstat_report_stat

(

bool

force

)

Definition at line 843 of file pgstat.c.

References Assert, B_BACKEND, 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, MyBackendType, MyDatabaseId, now(), PGSTAT_NUM_TABENTRIES, pgstat_send_connstats(), pgstat_send_funcstats(), pgstat_send_slru(), pgstat_send_tabstat(), pgstat_send_wal(), PGSTAT_STAT_INTERVAL, pgStatXactCommit, pgStatXactRollback, pgWalUsage, 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, and WalUsage::wal_records.

Referenced by apply_handle_commit_internal(), initialize_worker_spi(), LogicalRepSyncTableStart(), pg_attribute_noreturn(), pgstat_shutdown_hook(), PostgresMain(), and process_syncing_tables_for_apply().

{
    /* 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;

    /*
     * 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;

    /* for backends, send connection statistics */
    if (MyBackendType == B_BACKEND)
        pgstat_send_connstats(disconnect, last_report);

    last_report = now;

    /*
     * 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);
                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
     * gets counted, even if there are no table stats to send.
     */
    if (regular_msg.m_nentries > 0 ||
        pgStatXactCommit > 0 || pgStatXactRollback > 0)
        pgstat_send_tabstat(&regular_msg);
    if (shared_msg.m_nentries > 0)
        pgstat_send_tabstat(&shared_msg);

    /* Now, send function statistics */
    pgstat_send_funcstats();

    /* Send WAL statistics */
    pgstat_send_wal(true);

    /* Finally send SLRU statistics */
    pgstat_send_slru();
}

pgstat_report_vacuum()

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

Definition at line 1577 of file pgstat.c.

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_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;
    msg.m_autovacuum = IsAutoVacuumWorkerProcess();
    msg.m_vacuumtime = GetCurrentTimestamp();
    msg.m_live_tuples = livetuples;
    msg.m_dead_tuples = deadtuples;
    pgstat_send(&msg, sizeof(msg));
}

pgstat_reset_all()

void pgstat_reset_all

(

void

)

Definition at line 712 of file pgstat.c.

References Assert, av, lengthof, pgstat_reset_remove_files(), pgstat_stat_directory, and PGSTAT_STAT_PERMANENT_DIRECTORY.

Referenced by StartupXLOG().

{
    pgstat_reset_remove_files(pgstat_stat_directory);
    pgstat_reset_remove_files(PGSTAT_STAT_PERMANENT_DIRECTORY);
}

pgstat_reset_counters()

void pgstat_reset_counters

(

void

)

Definition at line 1421 of file pgstat.c.

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_MsgResetcounter msg;

    if (pgStatSock == PGINVALID_SOCKET)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETCOUNTER);
    msg.m_databaseid = MyDatabaseId;
    pgstat_send(&msg, sizeof(msg));
}

pgstat_reset_replslot_counter()

void pgstat_reset_replslot_counter

(

const char *

name

)

Definition at line 1526 of file pgstat.c.

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

Referenced by pg_stat_reset_replication_slot().

{
    PgStat_MsgResetreplslotcounter msg;

    if (pgStatSock == PGINVALID_SOCKET)
        return;

    if (name)
    {
        namestrcpy(&msg.m_slotname, name);
        msg.clearall = false;
    }
    else
        msg.clearall = true;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETREPLSLOTCOUNTER);

    pgstat_send(&msg, sizeof(msg));
}

pgstat_reset_shared_counters()

void pgstat_reset_shared_counters

(

const char *

)

Definition at line 1443 of file pgstat.c.

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_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),
                 errmsg("unrecognized reset target: \"%s\"", target),
                 errhint("Target must be \"archiver\", \"bgwriter\" or \"wal\".")));

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSHAREDCOUNTER);
    pgstat_send(&msg, sizeof(msg));
}

pgstat_reset_single_counter()

void pgstat_reset_single_counter	(	Oid	objectid,
		PgStat_Single_Reset_Type	type
	)

Definition at line 1476 of file pgstat.c.

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

Referenced by pg_stat_reset_single_function_counters(), and pg_stat_reset_single_table_counters().

{
    PgStat_MsgResetsinglecounter msg;

    if (pgStatSock == PGINVALID_SOCKET)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSINGLECOUNTER);
    msg.m_databaseid = MyDatabaseId;
    msg.m_resettype = type;
    msg.m_objectid = objoid;

    pgstat_send(&msg, sizeof(msg));
}

pgstat_reset_slru_counter()

void pgstat_reset_slru_counter

(

const char *

)

Definition at line 1502 of file pgstat.c.

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_MsgResetslrucounter msg;

    if (pgStatSock == PGINVALID_SOCKET)
        return;

    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSLRUCOUNTER);
    msg.m_index = (name) ? pgstat_slru_index(name) : -1;

    pgstat_send(&msg, sizeof(msg));
}

pgstat_send_archiver()

void pgstat_send_archiver	(	const char *	xlog,
		bool	failed
	)

Definition at line 2997 of file pgstat.c.

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_MsgArchiver msg;

    /*
     * Prepare and send the message
     */
    pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ARCHIVER);
    msg.m_failed = failed;
    strlcpy(msg.m_xlog, xlog, sizeof(msg.m_xlog));
    msg.m_timestamp = GetCurrentTimestamp();
    pgstat_send(&msg, sizeof(msg));
}

pgstat_send_bgwriter()

void pgstat_send_bgwriter

(

void

)

Definition at line 3018 of file pgstat.c.

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

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

{
    /* We assume this initializes to zeroes */
    static const PgStat_MsgBgWriter 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(&BgWriterStats, &all_zeroes, sizeof(PgStat_MsgBgWriter)) == 0)
        return;

    /*
     * Prepare and send the message
     */
    pgstat_setheader(&BgWriterStats.m_hdr, PGSTAT_MTYPE_BGWRITER);
    pgstat_send(&BgWriterStats, sizeof(BgWriterStats));

    /*
     * Clear out the statistics buffer, so it can be re-used.
     */
    MemSet(&BgWriterStats, 0, sizeof(BgWriterStats));
}

pgstat_send_wal()

void pgstat_send_wal

(

bool

force

)

Definition at line 3053 of file pgstat.c.

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, TimestampDifferenceExceeds(), WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_records, and WalUsageAccumDiff().

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

{
    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
         * substracting 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));

    /*
     * Clear out the statistics buffer, so it can be re-used.
     */
    MemSet(&WalStats, 0, sizeof(WalStats));
}

pgstat_slru_index()

int pgstat_slru_index

(

const char *

name

)

Definition at line 5779 of file pgstat.c.

References i, slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pgstat_reset_slru_counter(), and SimpleLruInit().

{
    int         i;

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

    /* return index of the last entry (which is the "other" one) */
    return (SLRU_NUM_ELEMENTS - 1);
}

pgstat_slru_name()

const char* pgstat_slru_name

(

int

slru_idx

)

Definition at line 5801 of file pgstat.c.

References slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pg_stat_get_slru().

{
    if (slru_idx < 0 || slru_idx >= SLRU_NUM_ELEMENTS)
        return NULL;

    return slru_names[slru_idx];
}

pgstat_start()

int pgstat_start

(

void

)

Definition at line 754 of file pgstat.c.

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().

{
    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:
            return (int) pgStatPid;
    }

    /* shouldn't get here */
    return 0;
}

pgstat_twophase_postabort()

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

Definition at line 2679 of file pgstat.c.

References TwoPhasePgStatRecord::deleted_pre_trunc, get_tabstat_entry(), TwoPhasePgStatRecord::inserted_pre_trunc, PgStat_TableStatus::t_counts, PgStat_TableCounts::t_delta_dead_tuples, TwoPhasePgStatRecord::t_id, TwoPhasePgStatRecord::t_shared, TwoPhasePgStatRecord::t_truncated, 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_trunc.

{
    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_truncated)
    {
        rec->tuples_inserted = rec->inserted_pre_trunc;
        rec->tuples_updated = rec->updated_pre_trunc;
        rec->tuples_deleted = rec->deleted_pre_trunc;
    }
    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_delta_dead_tuples +=
        rec->tuples_inserted + rec->tuples_updated;
}

pgstat_twophase_postcommit()

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

Definition at line 2643 of file pgstat.c.

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, PgStat_TableCounts::t_truncated, TwoPhasePgStatRecord::t_truncated, 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.

{
    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_truncated = rec->t_truncated;
    if (rec->t_truncated)
    {
        /* 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;
    pgstat_info->t_counts.t_delta_dead_tuples +=
        rec->tuples_updated + rec->tuples_deleted;
    pgstat_info->t_counts.t_changed_tuples +=
        rec->tuples_inserted + rec->tuples_updated +
        rec->tuples_deleted;
}

pgstat_update_heap_dead_tuples()

void pgstat_update_heap_dead_tuples	(	Relation	rel,
		int	delta
	)

Definition at line 2359 of file pgstat.c.

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

Referenced by heap_page_prune().

{
    PgStat_TableStatus *pgstat_info = rel->pgstat_info;

    if (pgstat_info != NULL)
        pgstat_info->t_counts.t_delta_dead_tuples -= delta;
}

pgstat_vacuum_stat()

void pgstat_vacuum_stat

(

void

)

Definition at line 1074 of file pgstat.c.

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(), PgStat_MsgTabpurge::m_databaseid, PgStat_MsgFuncpurge::m_databaseid, PgStat_MsgFuncpurge::m_functionid, PgStat_MsgTabpurge::m_hdr, PgStat_MsgFuncpurge::m_hdr, PgStat_MsgTabpurge::m_nentries, PgStat_MsgFuncpurge::m_nentries, 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_TABPURGE, pgstat_report_replslot_drop(), pgstat_send(), pgstat_setheader(), pgStatSock, SearchNamedReplicationSlot(), PgStat_StatReplSlotEntry::slotname, PgStat_StatTabEntry::tableid, and PgStat_StatDBEntry::tables.

Referenced by do_autovacuum(), and vacuum().

{
    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);
    }
}

PostPrepare_PgStat()

void PostPrepare_PgStat

(

void

)

Definition at line 2610 of file pgstat.c.

References PgStat_SubXactStatus::first, PgStat_TableXactStatus::next, PgStat_TableXactStatus::parent, pgstat_clear_snapshot(), pgStatXactStack, PgStat_TableStatus::trans, and trans.

Referenced by PrepareTransaction().

{
    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)
    {
        PgStat_TableXactStatus *trans;

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

            tabstat = trans->parent;
            tabstat->trans = NULL;
        }
    }
    pgStatXactStack = NULL;

    /* Make sure any stats snapshot is thrown away */
    pgstat_clear_snapshot();
}

Variable Documentation

BgWriterStats

PgStat_MsgBgWriter BgWriterStats

Definition at line 131 of file pgstat.c.

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

pgstat_stat_directory

char* pgstat_stat_directory

Definition at line 122 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

Definition at line 123 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

Definition at line 124 of file pgstat.c.

Referenced by assign_pgstat_temp_directory(), and pgstat_write_statsfiles().

pgstat_track_counts

PGDLLIMPORT bool pgstat_track_counts

Definition at line 115 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(), pgstat_report_vacuum(), and pgstat_send_connstats().

pgstat_track_functions

PGDLLIMPORT int pgstat_track_functions

Definition at line 116 of file pgstat.c.

pgStatActiveTime

PgStat_Counter pgStatActiveTime

Definition at line 248 of file pgstat.c.

Referenced by pgstat_send_connstats().

pgStatBlockReadTime

PgStat_Counter pgStatBlockReadTime

Definition at line 246 of file pgstat.c.

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

pgStatBlockWriteTime

PgStat_Counter pgStatBlockWriteTime

Definition at line 247 of file pgstat.c.

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

pgStatSessionEndCause

SessionEndType pgStatSessionEndCause

Definition at line 250 of file pgstat.c.

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

pgStatTransactionIdleTime

PgStat_Counter pgStatTransactionIdleTime

Definition at line 249 of file pgstat.c.

Referenced by pgstat_send_connstats().

WalStats

PgStat_MsgWal WalStats

Definition at line 132 of file pgstat.c.

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