#include "postgres.h"
#include "utils/pgstat_internal.h"
#include "utils/timestamp.h"
#include "storage/procsignal.h"

Include dependency graph for pgstat_database.c:

Macros
#define	PGSTAT_ACCUM_DBCOUNT(item) (sharedent)->stats.item += (pendingent)->item

Functions
static bool	pgstat_should_report_connstat (void)

void	pgstat_drop_database (Oid databaseid)

void	pgstat_report_autovac (Oid dboid)

void	pgstat_report_recovery_conflict (int reason)

void	pgstat_report_deadlock (void)

void	pgstat_report_checksum_failures_in_db (Oid dboid, int failurecount)

void	pgstat_report_checksum_failure (void)

void	pgstat_report_tempfile (size_t filesize)

void	pgstat_report_connect (Oid dboid)

void	pgstat_report_disconnect (Oid dboid)

PgStat_StatDBEntry *	pgstat_fetch_stat_dbentry (Oid dboid)

void	AtEOXact_PgStat_Database (bool isCommit, bool parallel)

void	pgstat_update_dbstats (TimestampTz ts)

PgStat_StatDBEntry *	pgstat_prep_database_pending (Oid dboid)

void	pgstat_reset_database_timestamp (Oid dboid, TimestampTz ts)

bool	pgstat_database_flush_cb (PgStat_EntryRef *entry_ref, bool nowait)

void	pgstat_database_reset_timestamp_cb (PgStatShared_Common *header, TimestampTz ts)

Variables
PgStat_Counter	pgStatBlockReadTime = 0

PgStat_Counter	pgStatBlockWriteTime = 0

PgStat_Counter	pgStatActiveTime = 0

PgStat_Counter	pgStatTransactionIdleTime = 0

SessionEndType	pgStatSessionEndCause = DISCONNECT_NORMAL

static int	pgStatXactCommit = 0

static int	pgStatXactRollback = 0

static PgStat_Counter	pgLastSessionReportTime = 0

Macro Definition Documentation

◆ PGSTAT_ACCUM_DBCOUNT

#define PGSTAT_ACCUM_DBCOUNT ( item ) (sharedent)->stats.item += (pendingent)->item

Function Documentation

◆ AtEOXact_PgStat_Database()

void AtEOXact_PgStat_Database	(	bool	isCommit,
		bool	parallel
	)

Definition at line 249 of file pgstat_database.c.

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

References pgStatXactCommit, and pgStatXactRollback.

Referenced by AtEOXact_PgStat().

◆ pgstat_database_flush_cb()

bool pgstat_database_flush_cb	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 375 of file pgstat_database.c.

 {
     PgStatShared_Database *sharedent;
     PgStat_StatDBEntry *pendingent;
  
     pendingent = (PgStat_StatDBEntry *) entry_ref->pending;
     sharedent = (PgStatShared_Database *) entry_ref->shared_stats;
  
     if (!pgstat_lock_entry(entry_ref, nowait))
         return false;
  
 #define PGSTAT_ACCUM_DBCOUNT(item)      \
     (sharedent)->stats.item += (pendingent)->item
  
     PGSTAT_ACCUM_DBCOUNT(xact_commit);
     PGSTAT_ACCUM_DBCOUNT(xact_rollback);
     PGSTAT_ACCUM_DBCOUNT(blocks_fetched);
     PGSTAT_ACCUM_DBCOUNT(blocks_hit);
  
     PGSTAT_ACCUM_DBCOUNT(tuples_returned);
     PGSTAT_ACCUM_DBCOUNT(tuples_fetched);
     PGSTAT_ACCUM_DBCOUNT(tuples_inserted);
     PGSTAT_ACCUM_DBCOUNT(tuples_updated);
     PGSTAT_ACCUM_DBCOUNT(tuples_deleted);
  
     /* last_autovac_time is reported immediately */
     Assert(pendingent->last_autovac_time == 0);
  
     PGSTAT_ACCUM_DBCOUNT(conflict_tablespace);
     PGSTAT_ACCUM_DBCOUNT(conflict_lock);
     PGSTAT_ACCUM_DBCOUNT(conflict_snapshot);
     PGSTAT_ACCUM_DBCOUNT(conflict_logicalslot);
     PGSTAT_ACCUM_DBCOUNT(conflict_bufferpin);
     PGSTAT_ACCUM_DBCOUNT(conflict_startup_deadlock);
  
     PGSTAT_ACCUM_DBCOUNT(temp_bytes);
     PGSTAT_ACCUM_DBCOUNT(temp_files);
     PGSTAT_ACCUM_DBCOUNT(deadlocks);
  
     /* checksum failures are reported immediately */
     Assert(pendingent->checksum_failures == 0);
     Assert(pendingent->last_checksum_failure == 0);
  
     PGSTAT_ACCUM_DBCOUNT(blk_read_time);
     PGSTAT_ACCUM_DBCOUNT(blk_write_time);
  
     PGSTAT_ACCUM_DBCOUNT(sessions);
     PGSTAT_ACCUM_DBCOUNT(session_time);
     PGSTAT_ACCUM_DBCOUNT(active_time);
     PGSTAT_ACCUM_DBCOUNT(idle_in_transaction_time);
     PGSTAT_ACCUM_DBCOUNT(sessions_abandoned);
     PGSTAT_ACCUM_DBCOUNT(sessions_fatal);
     PGSTAT_ACCUM_DBCOUNT(sessions_killed);
 #undef PGSTAT_ACCUM_DBCOUNT
  
     pgstat_unlock_entry(entry_ref);
  
     memset(pendingent, 0, sizeof(*pendingent));
  
     return true;
 }

References Assert(), PgStat_StatDBEntry::checksum_failures, PgStat_StatDBEntry::last_autovac_time, PgStat_StatDBEntry::last_checksum_failure, PgStat_EntryRef::pending, PGSTAT_ACCUM_DBCOUNT, pgstat_lock_entry(), pgstat_unlock_entry(), and PgStat_EntryRef::shared_stats.

◆ pgstat_database_reset_timestamp_cb()

void pgstat_database_reset_timestamp_cb	(	PgStatShared_Common *	header,
		TimestampTz	ts
	)

Definition at line 438 of file pgstat_database.c.

 {
     ((PgStatShared_Database *) header)->stats.stat_reset_timestamp = ts;
 }

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid databaseid )

Definition at line 44 of file pgstat_database.c.

 {
     pgstat_drop_transactional(PGSTAT_KIND_DATABASE, databaseid, InvalidOid);
 }

References InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_DATABASE.

Referenced by dropdb().

◆ pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry ( Oid dboid )

Definition at line 242 of file pgstat_database.c.

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

References InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_DATABASE.

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

◆ pgstat_prep_database_pending()

PgStat_StatDBEntry* pgstat_prep_database_pending ( Oid dboid )

Definition at line 333 of file pgstat_database.c.

 {
     PgStat_EntryRef *entry_ref;
  
     /*
      * This should not report stats on database objects before having
      * connected to a database.
      */
     Assert(!OidIsValid(dboid) || OidIsValid(MyDatabaseId));
  
     entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_DATABASE, dboid, InvalidOid,
                                           NULL);
  
     return entry_ref->pending;
 }

References Assert(), InvalidOid, MyDatabaseId, OidIsValid, PgStat_EntryRef::pending, PGSTAT_KIND_DATABASE, and pgstat_prep_pending_entry().

Referenced by pgstat_relation_flush_cb(), pgstat_report_connect(), pgstat_report_deadlock(), pgstat_report_disconnect(), pgstat_report_recovery_conflict(), pgstat_report_tempfile(), and pgstat_update_dbstats().

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid dboid )

Definition at line 55 of file pgstat_database.c.

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

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

Referenced by AutoVacWorkerMain().

◆ pgstat_report_checksum_failure()

void pgstat_report_checksum_failure ( void )

Definition at line 166 of file pgstat_database.c.

 {
     pgstat_report_checksum_failures_in_db(MyDatabaseId, 1);
 }

References MyDatabaseId, and pgstat_report_checksum_failures_in_db().

Referenced by PageIsVerifiedExtended().

◆ pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db	(	Oid	dboid,
		int	failurecount
	)

Definition at line 140 of file pgstat_database.c.

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

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

Referenced by pgstat_report_checksum_failure(), and sendFile().

◆ pgstat_report_connect()

void pgstat_report_connect ( Oid dboid )

Definition at line 191 of file pgstat_database.c.

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

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

Referenced by PostgresMain().

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void )

Definition at line 125 of file pgstat_database.c.

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

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

Referenced by DeadLockReport().

◆ pgstat_report_disconnect()

void pgstat_report_disconnect ( Oid dboid )

Definition at line 208 of file pgstat_database.c.

 {
     PgStat_StatDBEntry *dbentry;
  
     if (!pgstat_should_report_connstat())
         return;
  
     dbentry = pgstat_prep_database_pending(MyDatabaseId);
  
     switch (pgStatSessionEndCause)
     {
         case DISCONNECT_NOT_YET:
         case DISCONNECT_NORMAL:
             /* we don't collect these */
             break;
         case DISCONNECT_CLIENT_EOF:
             dbentry->sessions_abandoned++;
             break;
         case DISCONNECT_FATAL:
             dbentry->sessions_fatal++;
             break;
         case DISCONNECT_KILLED:
             dbentry->sessions_killed++;
             break;
     }
 }

References DISCONNECT_CLIENT_EOF, DISCONNECT_FATAL, DISCONNECT_KILLED, DISCONNECT_NORMAL, DISCONNECT_NOT_YET, MyDatabaseId, pgstat_prep_database_pending(), pgstat_should_report_connstat(), pgStatSessionEndCause, PgStat_StatDBEntry::sessions_abandoned, PgStat_StatDBEntry::sessions_fatal, and PgStat_StatDBEntry::sessions_killed.

Referenced by pgstat_shutdown_hook().

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int reason )

Definition at line 81 of file pgstat_database.c.

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

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

Referenced by ProcessRecoveryConflictInterrupt().

◆ pgstat_report_tempfile()

void pgstat_report_tempfile ( size_t filesize )

Definition at line 175 of file pgstat_database.c.

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

References MyDatabaseId, pgstat_prep_database_pending(), pgstat_track_counts, PgStat_StatDBEntry::temp_bytes, and PgStat_StatDBEntry::temp_files.

Referenced by ReportTemporaryFileUsage().

◆ pgstat_reset_database_timestamp()

void pgstat_reset_database_timestamp	(	Oid	dboid,
		TimestampTz	ts
	)

Definition at line 354 of file pgstat_database.c.

 {
     PgStat_EntryRef *dbref;
     PgStatShared_Database *dbentry;
  
     dbref = pgstat_get_entry_ref_locked(PGSTAT_KIND_DATABASE, MyDatabaseId, InvalidOid,
                                         false);
  
     dbentry = (PgStatShared_Database *) dbref->shared_stats;
     dbentry->stats.stat_reset_timestamp = ts;
  
     pgstat_unlock_entry(dbref);
 }

References InvalidOid, MyDatabaseId, pgstat_get_entry_ref_locked(), PGSTAT_KIND_DATABASE, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, PgStat_StatDBEntry::stat_reset_timestamp, and PgStatShared_Database::stats.

Referenced by pgstat_reset().

◆ pgstat_should_report_connstat()

static bool pgstat_should_report_connstat ( void )

static

Definition at line 324 of file pgstat_database.c.

 {
     return MyBackendType == B_BACKEND;
 }

References B_BACKEND, and MyBackendType.

Referenced by pgstat_report_connect(), pgstat_report_disconnect(), and pgstat_update_dbstats().

◆ pgstat_update_dbstats()

void pgstat_update_dbstats ( TimestampTz ts )

Definition at line 270 of file pgstat_database.c.

 {
     PgStat_StatDBEntry *dbentry;
  
     /*
      * If not connected to a database yet, don't attribute time to "shared
      * state" (InvalidOid is used to track stats for shared relations, etc.).
      */
     if (!OidIsValid(MyDatabaseId))
         return;
  
     dbentry = pgstat_prep_database_pending(MyDatabaseId);
  
     /*
      * Accumulate xact commit/rollback and I/O timings to stats entry of the
      * current database.
      */
     dbentry->xact_commit += pgStatXactCommit;
     dbentry->xact_rollback += pgStatXactRollback;
     dbentry->blk_read_time += pgStatBlockReadTime;
     dbentry->blk_write_time += pgStatBlockWriteTime;
  
     if (pgstat_should_report_connstat())
     {
         long        secs;
         int         usecs;
  
         /*
          * pgLastSessionReportTime is initialized to MyStartTimestamp by
          * pgstat_report_connect().
          */
         TimestampDifference(pgLastSessionReportTime, ts, &secs, &usecs);
         pgLastSessionReportTime = ts;
         dbentry->session_time += (PgStat_Counter) secs * 1000000 + usecs;
         dbentry->active_time += pgStatActiveTime;
         dbentry->idle_in_transaction_time += pgStatTransactionIdleTime;
     }
  
     pgStatXactCommit = 0;
     pgStatXactRollback = 0;
     pgStatBlockReadTime = 0;
     pgStatBlockWriteTime = 0;
     pgStatActiveTime = 0;
     pgStatTransactionIdleTime = 0;
 }