pgstatfuncs.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/xlog.h"
#include "access/xlogprefetcher.h"
#include "catalog/catalog.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_type.h"
#include "common/ip.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/bgworker.h"
#include "replication/logicallauncher.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/timestamp.h"

Include dependency graph for pgstatfuncs.c:

Go to the source code of this file.

Macros
#define	UINT32_ACCESS_ONCE(var)   ((uint32)(*((volatile uint32 *)&(var))))
#define	HAS_PGSTAT_PERMISSIONS(role)   (has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_STATS) || has_privs_of_role(GetUserId(), role))
#define	PG_STAT_GET_RELENTRY_INT64(stat)
#define	PG_STAT_GET_RELENTRY_FLOAT8(stat)
#define	PG_STAT_GET_RELENTRY_TIMESTAMPTZ(stat)
#define	PG_STAT_GET_FUNCENTRY_FLOAT8_MS(stat)
#define	PG_STAT_GET_PROGRESS_COLS   PGSTAT_NUM_PROGRESS_PARAM + 3
#define	PG_STAT_GET_ACTIVITY_COLS   31
#define	PG_STAT_GET_SUBXACT_COLS   2
#define	PG_STAT_GET_DBENTRY_INT64(stat)
#define	PG_STAT_GET_DBENTRY_FLOAT8_MS(stat)
#define	PG_STAT_WAL_COLS   5
#define	PG_STAT_GET_SLRU_COLS   9
#define	PG_STAT_GET_XACT_RELENTRY_INT64(stat)
#define	PG_STAT_GET_XACT_FUNCENTRY_FLOAT8_MS(stat)
#define	PG_STAT_GET_REPLICATION_SLOT_COLS   10
#define	PG_STAT_GET_SUBSCRIPTION_STATS_COLS   11

Typedefs
typedef enum io_stat_col	io_stat_col

Enumerations
enum	io_stat_col {   IO_COL_INVALID = -1 , IO_COL_BACKEND_TYPE , IO_COL_OBJECT , IO_COL_CONTEXT ,   IO_COL_READS , IO_COL_READ_BYTES , IO_COL_READ_TIME , IO_COL_WRITES ,   IO_COL_WRITE_BYTES , IO_COL_WRITE_TIME , IO_COL_WRITEBACKS , IO_COL_WRITEBACK_TIME ,   IO_COL_EXTENDS , IO_COL_EXTEND_BYTES , IO_COL_EXTEND_TIME , IO_COL_HITS ,   IO_COL_EVICTIONS , IO_COL_REUSES , IO_COL_FSYNCS , IO_COL_FSYNC_TIME ,   IO_COL_RESET_TIME , IO_NUM_COLUMNS }

Functions
Datum	pg_stat_get_function_calls (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_idset (PG_FUNCTION_ARGS)
Datum	pg_stat_get_progress_info (PG_FUNCTION_ARGS)
Datum	pg_stat_get_activity (PG_FUNCTION_ARGS)
Datum	pg_backend_pid (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_pid (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_dbid (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_userid (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_subxact (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_activity (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_wait_event_type (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_wait_event (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_activity_start (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_xact_start (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_start (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_client_addr (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_client_port (PG_FUNCTION_ARGS)
Datum	pg_stat_get_db_numbackends (PG_FUNCTION_ARGS)
Datum	pg_stat_get_db_stat_reset_time (PG_FUNCTION_ARGS)
Datum	pg_stat_get_db_conflict_all (PG_FUNCTION_ARGS)
Datum	pg_stat_get_db_checksum_failures (PG_FUNCTION_ARGS)
Datum	pg_stat_get_db_checksum_last_failure (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_num_timed (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_num_requested (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_num_performed (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_restartpoints_timed (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_restartpoints_requested (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_restartpoints_performed (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_buffers_written (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_slru_written (PG_FUNCTION_ARGS)
Datum	pg_stat_get_bgwriter_buf_written_clean (PG_FUNCTION_ARGS)
Datum	pg_stat_get_bgwriter_maxwritten_clean (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_write_time (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_sync_time (PG_FUNCTION_ARGS)
Datum	pg_stat_get_checkpointer_stat_reset_time (PG_FUNCTION_ARGS)
Datum	pg_stat_get_bgwriter_stat_reset_time (PG_FUNCTION_ARGS)
Datum	pg_stat_get_buf_alloc (PG_FUNCTION_ARGS)
static io_stat_col	pgstat_get_io_op_index (IOOp io_op)
static io_stat_col	pgstat_get_io_byte_index (IOOp io_op)
static io_stat_col	pgstat_get_io_time_index (IOOp io_op)
static double	pg_stat_us_to_ms (PgStat_Counter val_ms)
static void	pg_stat_io_build_tuples (ReturnSetInfo *rsinfo, PgStat_BktypeIO *bktype_stats, BackendType bktype, TimestampTz stat_reset_timestamp)
Datum	pg_stat_get_io (PG_FUNCTION_ARGS)
Datum	pg_stat_get_backend_io (PG_FUNCTION_ARGS)
static Datum	pg_stat_wal_build_tuple (PgStat_WalCounters wal_counters, TimestampTz stat_reset_timestamp)
Datum	pg_stat_get_backend_wal (PG_FUNCTION_ARGS)
Datum	pg_stat_get_wal (PG_FUNCTION_ARGS)
Datum	pg_stat_get_slru (PG_FUNCTION_ARGS)
Datum	pg_stat_get_xact_function_calls (PG_FUNCTION_ARGS)
Datum	pg_stat_get_snapshot_timestamp (PG_FUNCTION_ARGS)
Datum	pg_stat_clear_snapshot (PG_FUNCTION_ARGS)
Datum	pg_stat_force_next_flush (PG_FUNCTION_ARGS)
Datum	pg_stat_reset (PG_FUNCTION_ARGS)
Datum	pg_stat_reset_shared (PG_FUNCTION_ARGS)
Datum	pg_stat_reset_single_table_counters (PG_FUNCTION_ARGS)
Datum	pg_stat_reset_single_function_counters (PG_FUNCTION_ARGS)
Datum	pg_stat_reset_backend_stats (PG_FUNCTION_ARGS)
Datum	pg_stat_reset_slru (PG_FUNCTION_ARGS)
Datum	pg_stat_reset_replication_slot (PG_FUNCTION_ARGS)
Datum	pg_stat_reset_subscription_stats (PG_FUNCTION_ARGS)
Datum	pg_stat_get_archiver (PG_FUNCTION_ARGS)
Datum	pg_stat_get_replication_slot (PG_FUNCTION_ARGS)
Datum	pg_stat_get_subscription_stats (PG_FUNCTION_ARGS)
Datum	pg_stat_have_stats (PG_FUNCTION_ARGS)

Macro Definition Documentation

HAS_PGSTAT_PERMISSIONS

#define HAS_PGSTAT_PERMISSIONS

(

role

)

(has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_STATS) || has_privs_of_role(GetUserId(), role))

Definition at line 37 of file pgstatfuncs.c.

PG_STAT_GET_ACTIVITY_COLS

#define PG_STAT_GET_ACTIVITY_COLS   31

PG_STAT_GET_DBENTRY_FLOAT8_MS

#define PG_STAT_GET_DBENTRY_FLOAT8_MS

(

stat

)

Value:

Datum															\
CppConcat(pg_stat_get_db_,stat)(PG_FUNCTION_ARGS)               \
{                                                               \
    Oid         dbid = PG_GETARG_OID(0);                        \
    double      result;                                         \
    PgStat_StatDBEntry *dbentry;                                \
																\
	if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)   \
        result = 0;                                             \
    else                                                        \
        result = ((double) dbentry->stat) / 1000.0;             \
																\
	PG_RETURN_FLOAT8(result);                                  \
}

Definition at line 1182 of file pgstatfuncs.c.

PG_STAT_GET_DBENTRY_INT64

#define PG_STAT_GET_DBENTRY_INT64

(

stat

)

Value:

Datum															\
CppConcat(pg_stat_get_db_,stat)(PG_FUNCTION_ARGS)               \
{                                                               \
    Oid         dbid = PG_GETARG_OID(0);                        \
    int64       result;                                         \
    PgStat_StatDBEntry *dbentry;                                \
																\
	if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)   \
        result = 0;                                             \
    else                                                        \
        result = (int64) (dbentry->stat);                       \
																\
	PG_RETURN_INT64(result);                                   \
}

Definition at line 1015 of file pgstatfuncs.c.

PG_STAT_GET_FUNCENTRY_FLOAT8_MS

#define PG_STAT_GET_FUNCENTRY_FLOAT8_MS

(

stat

)

Value:

Datum																\
CppConcat(pg_stat_get_function_,stat)(PG_FUNCTION_ARGS)             \
{                                                                   \
    Oid         funcid = PG_GETARG_OID(0);                          \
    double      result;                                             \
    PgStat_StatFuncEntry *funcentry;                                \
																	\
	if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL) \
        PG_RETURN_NULL();                                           \
    result = ((double) funcentry->stat) / 1000.0;                   \
    PG_RETURN_FLOAT8(result);                                       \
}

Definition at line 183 of file pgstatfuncs.c.

PG_STAT_GET_PROGRESS_COLS

#define PG_STAT_GET_PROGRESS_COLS   PGSTAT_NUM_PROGRESS_PARAM + 3

PG_STAT_GET_RELENTRY_FLOAT8

#define PG_STAT_GET_RELENTRY_FLOAT8

(

stat

)

Value:

Datum															\
CppConcat(pg_stat_get_,stat)(PG_FUNCTION_ARGS)                  \
{                                                               \
    Oid         relid = PG_GETARG_OID(0);                       \
    double      result;                                         \
    PgStat_StatTabEntry *tabentry;                              \
																\
	if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL)    \
        result = 0;                                             \
    else                                                        \
        result = (double) (tabentry->stat);                     \
																\
	PG_RETURN_FLOAT8(result);                                  \
}

Definition at line 109 of file pgstatfuncs.c.

PG_STAT_GET_RELENTRY_INT64

#define PG_STAT_GET_RELENTRY_INT64

(

stat

)

Value:

Datum															\
CppConcat(pg_stat_get_,stat)(PG_FUNCTION_ARGS)                  \
{                                                               \
    Oid         relid = PG_GETARG_OID(0);                       \
    int64       result;                                         \
    PgStat_StatTabEntry *tabentry;                              \
																\
	if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL)    \
        result = 0;                                             \
    else                                                        \
        result = (int64) (tabentry->stat);                      \
																\
	PG_RETURN_INT64(result);                                   \
}

Definition at line 39 of file pgstatfuncs.c.

PG_STAT_GET_RELENTRY_TIMESTAMPTZ

#define PG_STAT_GET_RELENTRY_TIMESTAMPTZ

(

stat

)

Value:

Datum															\
CppConcat(pg_stat_get_,stat)(PG_FUNCTION_ARGS)                  \
{                                                               \
    Oid         relid = PG_GETARG_OID(0);                       \
    TimestampTz result;                                         \
    PgStat_StatTabEntry *tabentry;                              \
																\
	if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL)    \
        result = 0;                                             \
    else                                                        \
        result = tabentry->stat;                                \
																\
	if (result == 0)                                           \
        PG_RETURN_NULL();                                       \
	else														\
		PG_RETURN_TIMESTAMPTZ(result);                            \
}

Definition at line 137 of file pgstatfuncs.c.

PG_STAT_GET_REPLICATION_SLOT_COLS

#define PG_STAT_GET_REPLICATION_SLOT_COLS   10

PG_STAT_GET_SLRU_COLS

#define PG_STAT_GET_SLRU_COLS   9

PG_STAT_GET_SUBSCRIPTION_STATS_COLS

#define PG_STAT_GET_SUBSCRIPTION_STATS_COLS   11

PG_STAT_GET_SUBXACT_COLS

#define PG_STAT_GET_SUBXACT_COLS   2

PG_STAT_GET_XACT_FUNCENTRY_FLOAT8_MS

#define PG_STAT_GET_XACT_FUNCENTRY_FLOAT8_MS

(

stat

)

Value:

Datum															\
CppConcat(pg_stat_get_xact_function_,stat)(PG_FUNCTION_ARGS)    \
{                                                               \
    Oid         funcid = PG_GETARG_OID(0);                      \
    PgStat_FunctionCounts *funcentry;                           \
																\
	if ((funcentry = find_funcstat_entry(funcid)) == NULL)     \
        PG_RETURN_NULL();                                       \
    PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->stat)); \
}

Definition at line 1803 of file pgstatfuncs.c.

PG_STAT_GET_XACT_RELENTRY_INT64

#define PG_STAT_GET_XACT_RELENTRY_INT64

(

stat

)

Value:

Datum													\
CppConcat(pg_stat_get_xact_,stat)(PG_FUNCTION_ARGS)     \
{                                                       \
    Oid         relid = PG_GETARG_OID(0);               \
    int64       result;                                 \
    PgStat_TableStatus *tabentry;                       \
														\
	if ((tabentry = find_tabstat_entry(relid)) == NULL)    \
        result = 0;                                     \
    else                                                \
        result = (int64) (tabentry->counts.stat);       \
														\
	PG_RETURN_INT64(result);                           \
}

Definition at line 1746 of file pgstatfuncs.c.

PG_STAT_WAL_COLS

#define PG_STAT_WAL_COLS   5

UINT32_ACCESS_ONCE

#define UINT32_ACCESS_ONCE

(

var

)

((uint32)(*((volatile uint32 *)&(var))))

Definition at line 35 of file pgstatfuncs.c.

Typedef Documentation

io_stat_col

typedef enum io_stat_col io_stat_col

Enumeration Type Documentation

io_stat_col

enum io_stat_col

Enumerator
IO_COL_INVALID
IO_COL_BACKEND_TYPE
IO_COL_OBJECT
IO_COL_CONTEXT
IO_COL_READS
IO_COL_READ_BYTES
IO_COL_READ_TIME
IO_COL_WRITES
IO_COL_WRITE_BYTES
IO_COL_WRITE_TIME
IO_COL_WRITEBACKS
IO_COL_WRITEBACK_TIME
IO_COL_EXTENDS
IO_COL_EXTEND_BYTES
IO_COL_EXTEND_TIME
IO_COL_HITS
IO_COL_EVICTIONS
IO_COL_REUSES
IO_COL_FSYNCS
IO_COL_FSYNC_TIME
IO_COL_RESET_TIME
IO_NUM_COLUMNS

Definition at line 1312 of file pgstatfuncs.c.

{
    IO_COL_INVALID = -1,
    IO_COL_BACKEND_TYPE,
    IO_COL_OBJECT,
    IO_COL_CONTEXT,
    IO_COL_READS,
    IO_COL_READ_BYTES,
    IO_COL_READ_TIME,
    IO_COL_WRITES,
    IO_COL_WRITE_BYTES,
    IO_COL_WRITE_TIME,
    IO_COL_WRITEBACKS,
    IO_COL_WRITEBACK_TIME,
    IO_COL_EXTENDS,
    IO_COL_EXTEND_BYTES,
    IO_COL_EXTEND_TIME,
    IO_COL_HITS,
    IO_COL_EVICTIONS,
    IO_COL_REUSES,
    IO_COL_FSYNCS,
    IO_COL_FSYNC_TIME,
    IO_COL_RESET_TIME,
    IO_NUM_COLUMNS,
} io_stat_col;

Function Documentation

pg_backend_pid()

Datum pg_backend_pid

(

PG_FUNCTION_ARGS

)

Definition at line 690 of file pgstatfuncs.c.

{
    PG_RETURN_INT32(MyProcPid);
}

References MyProcPid, and PG_RETURN_INT32.

pg_stat_clear_snapshot()

Datum pg_stat_clear_snapshot

(

PG_FUNCTION_ARGS

)

Definition at line 1838 of file pgstatfuncs.c.

{
    pgstat_clear_snapshot();
 
    PG_RETURN_VOID();
}

References PG_RETURN_VOID, and pgstat_clear_snapshot().

pg_stat_force_next_flush()

Datum pg_stat_force_next_flush

(

PG_FUNCTION_ARGS

)

Definition at line 1848 of file pgstatfuncs.c.

{
    pgstat_force_next_flush();
 
    PG_RETURN_VOID();
}

References PG_RETURN_VOID, and pgstat_force_next_flush().

pg_stat_get_activity()

Datum pg_stat_get_activity

(

PG_FUNCTION_ARGS

)

Definition at line 331 of file pgstatfuncs.c.

{
#define PG_STAT_GET_ACTIVITY_COLS   31
    int         num_backends = pgstat_fetch_stat_numbackends();
    int         curr_backend;
    int         pid = PG_ARGISNULL(0) ? -1 : PG_GETARG_INT32(0);
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 
    InitMaterializedSRF(fcinfo, 0);
 
    /* 1-based index */
    for (curr_backend = 1; curr_backend <= num_backends; curr_backend++)
    {
        /* for each row */
        Datum       values[PG_STAT_GET_ACTIVITY_COLS] = {0};
        bool        nulls[PG_STAT_GET_ACTIVITY_COLS] = {0};
        LocalPgBackendStatus *local_beentry;
        PgBackendStatus *beentry;
        PGPROC     *proc;
        const char *wait_event_type = NULL;
        const char *wait_event = NULL;
 
        /* Get the next one in the list */
        local_beentry = pgstat_get_local_beentry_by_index(curr_backend);
        beentry = &local_beentry->backendStatus;
 
        /* If looking for specific PID, ignore all the others */
        if (pid != -1 && beentry->st_procpid != pid)
            continue;
 
        /* Values available to all callers */
        if (beentry->st_databaseid != InvalidOid)
            values[0] = ObjectIdGetDatum(beentry->st_databaseid);
        else
            nulls[0] = true;
 
        values[1] = Int32GetDatum(beentry->st_procpid);
 
        if (beentry->st_userid != InvalidOid)
            values[2] = ObjectIdGetDatum(beentry->st_userid);
        else
            nulls[2] = true;
 
        if (beentry->st_appname)
            values[3] = CStringGetTextDatum(beentry->st_appname);
        else
            nulls[3] = true;
 
        if (TransactionIdIsValid(local_beentry->backend_xid))
            values[15] = TransactionIdGetDatum(local_beentry->backend_xid);
        else
            nulls[15] = true;
 
        if (TransactionIdIsValid(local_beentry->backend_xmin))
            values[16] = TransactionIdGetDatum(local_beentry->backend_xmin);
        else
            nulls[16] = true;
 
        /* Values only available to role member or pg_read_all_stats */
        if (HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        {
            char       *clipped_activity;
 
            switch (beentry->st_state)
            {
                case STATE_STARTING:
                    values[4] = CStringGetTextDatum("starting");
                    break;
                case STATE_IDLE:
                    values[4] = CStringGetTextDatum("idle");
                    break;
                case STATE_RUNNING:
                    values[4] = CStringGetTextDatum("active");
                    break;
                case STATE_IDLEINTRANSACTION:
                    values[4] = CStringGetTextDatum("idle in transaction");
                    break;
                case STATE_FASTPATH:
                    values[4] = CStringGetTextDatum("fastpath function call");
                    break;
                case STATE_IDLEINTRANSACTION_ABORTED:
                    values[4] = CStringGetTextDatum("idle in transaction (aborted)");
                    break;
                case STATE_DISABLED:
                    values[4] = CStringGetTextDatum("disabled");
                    break;
                case STATE_UNDEFINED:
                    nulls[4] = true;
                    break;
            }
 
            clipped_activity = pgstat_clip_activity(beentry->st_activity_raw);
            values[5] = CStringGetTextDatum(clipped_activity);
            pfree(clipped_activity);
 
            /* leader_pid */
            nulls[29] = true;
 
            proc = BackendPidGetProc(beentry->st_procpid);
 
            if (proc == NULL && (beentry->st_backendType != B_BACKEND))
            {
                /*
                 * For an auxiliary process, retrieve process info from
                 * AuxiliaryProcs stored in shared-memory.
                 */
                proc = AuxiliaryPidGetProc(beentry->st_procpid);
            }
 
            /*
             * If a PGPROC entry was retrieved, display wait events and lock
             * group leader or apply leader information if any.  To avoid
             * extra overhead, no extra lock is being held, so there is no
             * guarantee of consistency across multiple rows.
             */
            if (proc != NULL)
            {
                uint32      raw_wait_event;
                PGPROC     *leader;
 
                raw_wait_event = UINT32_ACCESS_ONCE(proc->wait_event_info);
                wait_event_type = pgstat_get_wait_event_type(raw_wait_event);
                wait_event = pgstat_get_wait_event(raw_wait_event);
 
                leader = proc->lockGroupLeader;
 
                /*
                 * Show the leader only for active parallel workers.  This
                 * leaves the field as NULL for the leader of a parallel group
                 * or the leader of parallel apply workers.
                 */
                if (leader && leader->pid != beentry->st_procpid)
                {
                    values[29] = Int32GetDatum(leader->pid);
                    nulls[29] = false;
                }
                else if (beentry->st_backendType == B_BG_WORKER)
                {
                    int         leader_pid = GetLeaderApplyWorkerPid(beentry->st_procpid);
 
                    if (leader_pid != InvalidPid)
                    {
                        values[29] = Int32GetDatum(leader_pid);
                        nulls[29] = false;
                    }
                }
            }
 
            if (wait_event_type)
                values[6] = CStringGetTextDatum(wait_event_type);
            else
                nulls[6] = true;
 
            if (wait_event)
                values[7] = CStringGetTextDatum(wait_event);
            else
                nulls[7] = true;
 
            /*
             * Don't expose transaction time for walsenders; it confuses
             * monitoring, particularly because we don't keep the time up-to-
             * date.
             */
            if (beentry->st_xact_start_timestamp != 0 &&
                beentry->st_backendType != B_WAL_SENDER)
                values[8] = TimestampTzGetDatum(beentry->st_xact_start_timestamp);
            else
                nulls[8] = true;
 
            if (beentry->st_activity_start_timestamp != 0)
                values[9] = TimestampTzGetDatum(beentry->st_activity_start_timestamp);
            else
                nulls[9] = true;
 
            if (beentry->st_proc_start_timestamp != 0)
                values[10] = TimestampTzGetDatum(beentry->st_proc_start_timestamp);
            else
                nulls[10] = true;
 
            if (beentry->st_state_start_timestamp != 0)
                values[11] = TimestampTzGetDatum(beentry->st_state_start_timestamp);
            else
                nulls[11] = true;
 
            /* A zeroed client addr means we don't know */
            if (pg_memory_is_all_zeros(&beentry->st_clientaddr,
                                       sizeof(beentry->st_clientaddr)))
            {
                nulls[12] = true;
                nulls[13] = true;
                nulls[14] = true;
            }
            else
            {
                if (beentry->st_clientaddr.addr.ss_family == AF_INET ||
                    beentry->st_clientaddr.addr.ss_family == AF_INET6)
                {
                    char        remote_host[NI_MAXHOST];
                    char        remote_port[NI_MAXSERV];
                    int         ret;
 
                    remote_host[0] = '\0';
                    remote_port[0] = '\0';
                    ret = pg_getnameinfo_all(&beentry->st_clientaddr.addr,
                                             beentry->st_clientaddr.salen,
                                             remote_host, sizeof(remote_host),
                                             remote_port, sizeof(remote_port),
                                             NI_NUMERICHOST | NI_NUMERICSERV);
                    if (ret == 0)
                    {
                        clean_ipv6_addr(beentry->st_clientaddr.addr.ss_family, remote_host);
                        values[12] = DirectFunctionCall1(inet_in,
                                                         CStringGetDatum(remote_host));
                        if (beentry->st_clienthostname &&
                            beentry->st_clienthostname[0])
                            values[13] = CStringGetTextDatum(beentry->st_clienthostname);
                        else
                            nulls[13] = true;
                        values[14] = Int32GetDatum(atoi(remote_port));
                    }
                    else
                    {
                        nulls[12] = true;
                        nulls[13] = true;
                        nulls[14] = true;
                    }
                }
                else if (beentry->st_clientaddr.addr.ss_family == AF_UNIX)
                {
                    /*
                     * Unix sockets always reports NULL for host and -1 for
                     * port, so it's possible to tell the difference to
                     * connections we have no permissions to view, or with
                     * errors.
                     */
                    nulls[12] = true;
                    nulls[13] = true;
                    values[14] = Int32GetDatum(-1);
                }
                else
                {
                    /* Unknown address type, should never happen */
                    nulls[12] = true;
                    nulls[13] = true;
                    nulls[14] = true;
                }
            }
            /* Add backend type */
            if (beentry->st_backendType == B_BG_WORKER)
            {
                const char *bgw_type;
 
                bgw_type = GetBackgroundWorkerTypeByPid(beentry->st_procpid);
                if (bgw_type)
                    values[17] = CStringGetTextDatum(bgw_type);
                else
                    nulls[17] = true;
            }
            else
                values[17] =
                    CStringGetTextDatum(GetBackendTypeDesc(beentry->st_backendType));
 
            /* SSL information */
            if (beentry->st_ssl)
            {
                values[18] = BoolGetDatum(true);    /* ssl */
                values[19] = CStringGetTextDatum(beentry->st_sslstatus->ssl_version);
                values[20] = CStringGetTextDatum(beentry->st_sslstatus->ssl_cipher);
                values[21] = Int32GetDatum(beentry->st_sslstatus->ssl_bits);
 
                if (beentry->st_sslstatus->ssl_client_dn[0])
                    values[22] = CStringGetTextDatum(beentry->st_sslstatus->ssl_client_dn);
                else
                    nulls[22] = true;
 
                if (beentry->st_sslstatus->ssl_client_serial[0])
                    values[23] = DirectFunctionCall3(numeric_in,
                                                     CStringGetDatum(beentry->st_sslstatus->ssl_client_serial),
                                                     ObjectIdGetDatum(InvalidOid),
                                                     Int32GetDatum(-1));
                else
                    nulls[23] = true;
 
                if (beentry->st_sslstatus->ssl_issuer_dn[0])
                    values[24] = CStringGetTextDatum(beentry->st_sslstatus->ssl_issuer_dn);
                else
                    nulls[24] = true;
            }
            else
            {
                values[18] = BoolGetDatum(false);   /* ssl */
                nulls[19] = nulls[20] = nulls[21] = nulls[22] = nulls[23] = nulls[24] = true;
            }
 
            /* GSSAPI information */
            if (beentry->st_gss)
            {
                values[25] = BoolGetDatum(beentry->st_gssstatus->gss_auth); /* gss_auth */
                values[26] = CStringGetTextDatum(beentry->st_gssstatus->gss_princ);
                values[27] = BoolGetDatum(beentry->st_gssstatus->gss_enc);  /* GSS Encryption in use */
                values[28] = BoolGetDatum(beentry->st_gssstatus->gss_delegation);   /* GSS credentials
                                                                                     * delegated */
            }
            else
            {
                values[25] = BoolGetDatum(false);   /* gss_auth */
                nulls[26] = true;   /* No GSS principal */
                values[27] = BoolGetDatum(false);   /* GSS Encryption not in
                                                     * use */
                values[28] = BoolGetDatum(false);   /* GSS credentials not
                                                     * delegated */
            }
            if (beentry->st_query_id == 0)
                nulls[30] = true;
            else
                values[30] = UInt64GetDatum(beentry->st_query_id);
        }
        else
        {
            /* No permissions to view data about this session */
            values[5] = CStringGetTextDatum("<insufficient privilege>");
            nulls[4] = true;
            nulls[6] = true;
            nulls[7] = true;
            nulls[8] = true;
            nulls[9] = true;
            nulls[10] = true;
            nulls[11] = true;
            nulls[12] = true;
            nulls[13] = true;
            nulls[14] = true;
            nulls[17] = true;
            nulls[18] = true;
            nulls[19] = true;
            nulls[20] = true;
            nulls[21] = true;
            nulls[22] = true;
            nulls[23] = true;
            nulls[24] = true;
            nulls[25] = true;
            nulls[26] = true;
            nulls[27] = true;
            nulls[28] = true;
            nulls[29] = true;
            nulls[30] = true;
        }
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
 
        /* If only a single backend was requested, and we found it, break. */
        if (pid != -1)
            break;
    }
 
    return (Datum) 0;
}

References SockAddr::addr, AuxiliaryPidGetProc(), B_BACKEND, B_BG_WORKER, B_WAL_SENDER, LocalPgBackendStatus::backend_xid, LocalPgBackendStatus::backend_xmin, BackendPidGetProc(), LocalPgBackendStatus::backendStatus, BoolGetDatum(), clean_ipv6_addr(), CStringGetDatum(), CStringGetTextDatum, DirectFunctionCall1, DirectFunctionCall3, GetBackendTypeDesc(), GetBackgroundWorkerTypeByPid(), GetLeaderApplyWorkerPid(), PgBackendGSSStatus::gss_auth, PgBackendGSSStatus::gss_delegation, PgBackendGSSStatus::gss_enc, PgBackendGSSStatus::gss_princ, HAS_PGSTAT_PERMISSIONS, inet_in(), InitMaterializedSRF(), Int32GetDatum(), InvalidOid, InvalidPid, PGPROC::lockGroupLeader, numeric_in(), ObjectIdGetDatum(), pfree(), PG_ARGISNULL, PG_GETARG_INT32, pg_getnameinfo_all(), pg_memory_is_all_zeros(), PG_STAT_GET_ACTIVITY_COLS, pgstat_clip_activity(), pgstat_fetch_stat_numbackends(), pgstat_get_local_beentry_by_index(), pgstat_get_wait_event(), pgstat_get_wait_event_type(), PGPROC::pid, SockAddr::salen, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, PgBackendSSLStatus::ssl_bits, PgBackendSSLStatus::ssl_cipher, PgBackendSSLStatus::ssl_client_dn, PgBackendSSLStatus::ssl_client_serial, PgBackendSSLStatus::ssl_issuer_dn, PgBackendSSLStatus::ssl_version, PgBackendStatus::st_activity_raw, PgBackendStatus::st_activity_start_timestamp, PgBackendStatus::st_appname, PgBackendStatus::st_backendType, PgBackendStatus::st_clientaddr, PgBackendStatus::st_clienthostname, PgBackendStatus::st_databaseid, PgBackendStatus::st_gss, PgBackendStatus::st_gssstatus, PgBackendStatus::st_proc_start_timestamp, PgBackendStatus::st_procpid, PgBackendStatus::st_query_id, PgBackendStatus::st_ssl, PgBackendStatus::st_sslstatus, PgBackendStatus::st_state, PgBackendStatus::st_state_start_timestamp, PgBackendStatus::st_userid, PgBackendStatus::st_xact_start_timestamp, STATE_DISABLED, STATE_FASTPATH, STATE_IDLE, STATE_IDLEINTRANSACTION, STATE_IDLEINTRANSACTION_ABORTED, STATE_RUNNING, STATE_STARTING, STATE_UNDEFINED, TimestampTzGetDatum(), TransactionIdGetDatum(), TransactionIdIsValid, tuplestore_putvalues(), UINT32_ACCESS_ONCE, UInt64GetDatum(), values, and PGPROC::wait_event_info.

pg_stat_get_archiver()

Datum pg_stat_get_archiver

(

PG_FUNCTION_ARGS

)

Definition at line 2035 of file pgstatfuncs.c.

{
    TupleDesc   tupdesc;
    Datum       values[7] = {0};
    bool        nulls[7] = {0};
    PgStat_ArchiverStats *archiver_stats;
 
    /* Initialise attributes information in the tuple descriptor */
    tupdesc = CreateTemplateTupleDesc(7);
    TupleDescInitEntry(tupdesc, (AttrNumber) 1, "archived_count",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 2, "last_archived_wal",
                       TEXTOID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 3, "last_archived_time",
                       TIMESTAMPTZOID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 4, "failed_count",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 5, "last_failed_wal",
                       TEXTOID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 6, "last_failed_time",
                       TIMESTAMPTZOID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 7, "stats_reset",
                       TIMESTAMPTZOID, -1, 0);
 
    BlessTupleDesc(tupdesc);
 
    /* Get statistics about the archiver process */
    archiver_stats = pgstat_fetch_stat_archiver();
 
    /* Fill values and NULLs */
    values[0] = Int64GetDatum(archiver_stats->archived_count);
    if (*(archiver_stats->last_archived_wal) == '\0')
        nulls[1] = true;
    else
        values[1] = CStringGetTextDatum(archiver_stats->last_archived_wal);
 
    if (archiver_stats->last_archived_timestamp == 0)
        nulls[2] = true;
    else
        values[2] = TimestampTzGetDatum(archiver_stats->last_archived_timestamp);
 
    values[3] = Int64GetDatum(archiver_stats->failed_count);
    if (*(archiver_stats->last_failed_wal) == '\0')
        nulls[4] = true;
    else
        values[4] = CStringGetTextDatum(archiver_stats->last_failed_wal);
 
    if (archiver_stats->last_failed_timestamp == 0)
        nulls[5] = true;
    else
        values[5] = TimestampTzGetDatum(archiver_stats->last_failed_timestamp);
 
    if (archiver_stats->stat_reset_timestamp == 0)
        nulls[6] = true;
    else
        values[6] = TimestampTzGetDatum(archiver_stats->stat_reset_timestamp);
 
    /* Returns the record as Datum */
    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

References PgStat_ArchiverStats::archived_count, BlessTupleDesc(), CreateTemplateTupleDesc(), CStringGetTextDatum, PgStat_ArchiverStats::failed_count, heap_form_tuple(), HeapTupleGetDatum(), Int64GetDatum(), PgStat_ArchiverStats::last_archived_timestamp, PgStat_ArchiverStats::last_archived_wal, PgStat_ArchiverStats::last_failed_timestamp, PgStat_ArchiverStats::last_failed_wal, PG_RETURN_DATUM, pgstat_fetch_stat_archiver(), PgStat_ArchiverStats::stat_reset_timestamp, TimestampTzGetDatum(), TupleDescInitEntry(), and values.

pg_stat_get_backend_activity()

Datum pg_stat_get_backend_activity

(

PG_FUNCTION_ARGS

)

Definition at line 770 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    PgBackendStatus *beentry;
    const char *activity;
    char       *clipped_activity;
    text       *ret;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        activity = "<backend information not available>";
    else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        activity = "<insufficient privilege>";
    else if (*(beentry->st_activity_raw) == '\0')
        activity = "<command string not enabled>";
    else
        activity = beentry->st_activity_raw;
 
    clipped_activity = pgstat_clip_activity(activity);
    ret = cstring_to_text(activity);
    pfree(clipped_activity);
 
    PG_RETURN_TEXT_P(ret);
}

References cstring_to_text(), HAS_PGSTAT_PERMISSIONS, pfree(), PG_GETARG_INT32, PG_RETURN_TEXT_P, pgstat_clip_activity(), pgstat_get_beentry_by_proc_number(), PgBackendStatus::st_activity_raw, and PgBackendStatus::st_userid.

pg_stat_get_backend_activity_start()

Datum pg_stat_get_backend_activity_start

(

PG_FUNCTION_ARGS

)

Definition at line 838 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    TimestampTz result;
    PgBackendStatus *beentry;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        PG_RETURN_NULL();
 
    else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        PG_RETURN_NULL();
 
    result = beentry->st_activity_start_timestamp;
 
    /*
     * No time recorded for start of current query -- this is the case if the
     * user hasn't enabled query-level stats collection.
     */
    if (result == 0)
        PG_RETURN_NULL();
 
    PG_RETURN_TIMESTAMPTZ(result);
}

References HAS_PGSTAT_PERMISSIONS, PG_GETARG_INT32, PG_RETURN_NULL, PG_RETURN_TIMESTAMPTZ, pgstat_get_beentry_by_proc_number(), PgBackendStatus::st_activity_start_timestamp, and PgBackendStatus::st_userid.

pg_stat_get_backend_client_addr()

Datum pg_stat_get_backend_client_addr

(

PG_FUNCTION_ARGS

)

Definition at line 908 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    PgBackendStatus *beentry;
    char        remote_host[NI_MAXHOST];
    int         ret;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        PG_RETURN_NULL();
 
    else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        PG_RETURN_NULL();
 
    /* A zeroed client addr means we don't know */
    if (pg_memory_is_all_zeros(&beentry->st_clientaddr,
                               sizeof(beentry->st_clientaddr)))
        PG_RETURN_NULL();
 
    switch (beentry->st_clientaddr.addr.ss_family)
    {
        case AF_INET:
        case AF_INET6:
            break;
        default:
            PG_RETURN_NULL();
    }
 
    remote_host[0] = '\0';
    ret = pg_getnameinfo_all(&beentry->st_clientaddr.addr,
                             beentry->st_clientaddr.salen,
                             remote_host, sizeof(remote_host),
                             NULL, 0,
                             NI_NUMERICHOST | NI_NUMERICSERV);
    if (ret != 0)
        PG_RETURN_NULL();
 
    clean_ipv6_addr(beentry->st_clientaddr.addr.ss_family, remote_host);
 
    PG_RETURN_DATUM(DirectFunctionCall1(inet_in,
                                        CStringGetDatum(remote_host)));
}

References SockAddr::addr, clean_ipv6_addr(), CStringGetDatum(), DirectFunctionCall1, HAS_PGSTAT_PERMISSIONS, inet_in(), PG_GETARG_INT32, pg_getnameinfo_all(), pg_memory_is_all_zeros(), PG_RETURN_DATUM, PG_RETURN_NULL, pgstat_get_beentry_by_proc_number(), SockAddr::salen, PgBackendStatus::st_clientaddr, and PgBackendStatus::st_userid.

pg_stat_get_backend_client_port()

Datum pg_stat_get_backend_client_port

(

PG_FUNCTION_ARGS

)

Definition at line 951 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    PgBackendStatus *beentry;
    char        remote_port[NI_MAXSERV];
    int         ret;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        PG_RETURN_NULL();
 
    else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        PG_RETURN_NULL();
 
    /* A zeroed client addr means we don't know */
    if (pg_memory_is_all_zeros(&beentry->st_clientaddr,
                               sizeof(beentry->st_clientaddr)))
        PG_RETURN_NULL();
 
    switch (beentry->st_clientaddr.addr.ss_family)
    {
        case AF_INET:
        case AF_INET6:
            break;
        case AF_UNIX:
            PG_RETURN_INT32(-1);
        default:
            PG_RETURN_NULL();
    }
 
    remote_port[0] = '\0';
    ret = pg_getnameinfo_all(&beentry->st_clientaddr.addr,
                             beentry->st_clientaddr.salen,
                             NULL, 0,
                             remote_port, sizeof(remote_port),
                             NI_NUMERICHOST | NI_NUMERICSERV);
    if (ret != 0)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(DirectFunctionCall1(int4in,
                                        CStringGetDatum(remote_port)));
}

References SockAddr::addr, CStringGetDatum(), DirectFunctionCall1, HAS_PGSTAT_PERMISSIONS, int4in(), PG_GETARG_INT32, pg_getnameinfo_all(), pg_memory_is_all_zeros(), PG_RETURN_DATUM, PG_RETURN_INT32, PG_RETURN_NULL, pgstat_get_beentry_by_proc_number(), SockAddr::salen, PgBackendStatus::st_clientaddr, and PgBackendStatus::st_userid.

pg_stat_get_backend_dbid()

Datum pg_stat_get_backend_dbid

(

PG_FUNCTION_ARGS

)

Definition at line 710 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    PgBackendStatus *beentry;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        PG_RETURN_NULL();
 
    PG_RETURN_OID(beentry->st_databaseid);
}

References PG_GETARG_INT32, PG_RETURN_NULL, PG_RETURN_OID, pgstat_get_beentry_by_proc_number(), and PgBackendStatus::st_databaseid.

pg_stat_get_backend_idset()

Datum pg_stat_get_backend_idset

(

PG_FUNCTION_ARGS

)

Definition at line 204 of file pgstatfuncs.c.

{
    FuncCallContext *funcctx;
    int        *fctx;
 
    /* stuff done only on the first call of the function */
    if (SRF_IS_FIRSTCALL())
    {
        /* create a function context for cross-call persistence */
        funcctx = SRF_FIRSTCALL_INIT();
 
        fctx = MemoryContextAlloc(funcctx->multi_call_memory_ctx,
                                  sizeof(int));
        funcctx->user_fctx = fctx;
 
        fctx[0] = 0;
    }
 
    /* stuff done on every call of the function */
    funcctx = SRF_PERCALL_SETUP();
    fctx = funcctx->user_fctx;
 
    fctx[0] += 1;
 
    /*
     * We recheck pgstat_fetch_stat_numbackends() each time through, just in
     * case the local status data has been refreshed since we started.  It's
     * plenty cheap enough if not.  If a refresh does happen, we'll likely
     * miss or duplicate some backend IDs, but we're content not to crash.
     * (Refreshing midway through such a query would be problematic usage
     * anyway, since the backend IDs we've already returned might no longer
     * refer to extant sessions.)
     */
    if (fctx[0] <= pgstat_fetch_stat_numbackends())
    {
        /* do when there is more left to send */
        LocalPgBackendStatus *local_beentry = pgstat_get_local_beentry_by_index(fctx[0]);
 
        SRF_RETURN_NEXT(funcctx, Int32GetDatum(local_beentry->proc_number));
    }
    else
    {
        /* do when there is no more left */
        SRF_RETURN_DONE(funcctx);
    }
}

References Int32GetDatum(), MemoryContextAlloc(), FuncCallContext::multi_call_memory_ctx, pgstat_fetch_stat_numbackends(), pgstat_get_local_beentry_by_index(), LocalPgBackendStatus::proc_number, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and FuncCallContext::user_fctx.

pg_stat_get_backend_io()

Datum pg_stat_get_backend_io

(

PG_FUNCTION_ARGS

)

Definition at line 1577 of file pgstatfuncs.c.

{
    ReturnSetInfo *rsinfo;
    BackendType bktype;
    int         pid;
    PgStat_Backend *backend_stats;
    PgStat_BktypeIO *bktype_stats;
 
    InitMaterializedSRF(fcinfo, 0);
    rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 
    pid = PG_GETARG_INT32(0);
    backend_stats = pgstat_fetch_stat_backend_by_pid(pid, &bktype);
 
    if (!backend_stats)
        return (Datum) 0;
 
    bktype_stats = &backend_stats->io_stats;
 
    /*
     * In Assert builds, we can afford an extra loop through all of the
     * counters (in pg_stat_io_build_tuples()), checking that only expected
     * stats are non-zero, since it keeps the non-Assert code cleaner.
     */
    Assert(pgstat_bktype_io_stats_valid(bktype_stats, bktype));
 
    /* save tuples with data from this PgStat_BktypeIO */
    pg_stat_io_build_tuples(rsinfo, bktype_stats, bktype,
                            backend_stats->stat_reset_timestamp);
    return (Datum) 0;
}

References Assert(), InitMaterializedSRF(), PgStat_Backend::io_stats, PG_GETARG_INT32, pg_stat_io_build_tuples(), pgstat_bktype_io_stats_valid(), pgstat_fetch_stat_backend_by_pid(), and PgStat_Backend::stat_reset_timestamp.

pg_stat_get_backend_pid()

Datum pg_stat_get_backend_pid

(

PG_FUNCTION_ARGS

)

Definition at line 697 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    PgBackendStatus *beentry;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        PG_RETURN_NULL();
 
    PG_RETURN_INT32(beentry->st_procpid);
}

References PG_GETARG_INT32, PG_RETURN_INT32, PG_RETURN_NULL, pgstat_get_beentry_by_proc_number(), and PgBackendStatus::st_procpid.

pg_stat_get_backend_start()

Datum pg_stat_get_backend_start

(

PG_FUNCTION_ARGS

)

Definition at line 886 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    TimestampTz result;
    PgBackendStatus *beentry;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        PG_RETURN_NULL();
 
    else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        PG_RETURN_NULL();
 
    result = beentry->st_proc_start_timestamp;
 
    if (result == 0)            /* probably can't happen? */
        PG_RETURN_NULL();
 
    PG_RETURN_TIMESTAMPTZ(result);
}

References HAS_PGSTAT_PERMISSIONS, PG_GETARG_INT32, PG_RETURN_NULL, PG_RETURN_TIMESTAMPTZ, pgstat_get_beentry_by_proc_number(), PgBackendStatus::st_proc_start_timestamp, and PgBackendStatus::st_userid.

pg_stat_get_backend_subxact()

Datum pg_stat_get_backend_subxact

(

PG_FUNCTION_ARGS

)

Definition at line 735 of file pgstatfuncs.c.

{
#define PG_STAT_GET_SUBXACT_COLS    2
    TupleDesc   tupdesc;
    Datum       values[PG_STAT_GET_SUBXACT_COLS] = {0};
    bool        nulls[PG_STAT_GET_SUBXACT_COLS] = {0};
    int32       procNumber = PG_GETARG_INT32(0);
    LocalPgBackendStatus *local_beentry;
 
    /* Initialise attributes information in the tuple descriptor */
    tupdesc = CreateTemplateTupleDesc(PG_STAT_GET_SUBXACT_COLS);
    TupleDescInitEntry(tupdesc, (AttrNumber) 1, "subxact_count",
                       INT4OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 2, "subxact_overflow",
                       BOOLOID, -1, 0);
 
    BlessTupleDesc(tupdesc);
 
    if ((local_beentry = pgstat_get_local_beentry_by_proc_number(procNumber)) != NULL)
    {
        /* Fill values and NULLs */
        values[0] = Int32GetDatum(local_beentry->backend_subxact_count);
        values[1] = BoolGetDatum(local_beentry->backend_subxact_overflowed);
    }
    else
    {
        nulls[0] = true;
        nulls[1] = true;
    }
 
    /* Returns the record as Datum */
    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

References LocalPgBackendStatus::backend_subxact_count, LocalPgBackendStatus::backend_subxact_overflowed, BlessTupleDesc(), BoolGetDatum(), CreateTemplateTupleDesc(), heap_form_tuple(), HeapTupleGetDatum(), Int32GetDatum(), PG_GETARG_INT32, PG_RETURN_DATUM, PG_STAT_GET_SUBXACT_COLS, pgstat_get_local_beentry_by_proc_number(), TupleDescInitEntry(), and values.

pg_stat_get_backend_userid()

Datum pg_stat_get_backend_userid

(

PG_FUNCTION_ARGS

)

Definition at line 723 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    PgBackendStatus *beentry;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        PG_RETURN_NULL();
 
    PG_RETURN_OID(beentry->st_userid);
}

References PG_GETARG_INT32, PG_RETURN_NULL, PG_RETURN_OID, pgstat_get_beentry_by_proc_number(), and PgBackendStatus::st_userid.

pg_stat_get_backend_wait_event()

Datum pg_stat_get_backend_wait_event

(

PG_FUNCTION_ARGS

)

Definition at line 816 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    PgBackendStatus *beentry;
    PGPROC     *proc;
    const char *wait_event = NULL;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        wait_event = "<backend information not available>";
    else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        wait_event = "<insufficient privilege>";
    else if ((proc = BackendPidGetProc(beentry->st_procpid)) != NULL)
        wait_event = pgstat_get_wait_event(proc->wait_event_info);
 
    if (!wait_event)
        PG_RETURN_NULL();
 
    PG_RETURN_TEXT_P(cstring_to_text(wait_event));
}

References BackendPidGetProc(), cstring_to_text(), HAS_PGSTAT_PERMISSIONS, PG_GETARG_INT32, PG_RETURN_NULL, PG_RETURN_TEXT_P, pgstat_get_beentry_by_proc_number(), pgstat_get_wait_event(), PgBackendStatus::st_procpid, PgBackendStatus::st_userid, and PGPROC::wait_event_info.

pg_stat_get_backend_wait_event_type()

Datum pg_stat_get_backend_wait_event_type

(

PG_FUNCTION_ARGS

)

Definition at line 795 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    PgBackendStatus *beentry;
    PGPROC     *proc;
    const char *wait_event_type = NULL;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        wait_event_type = "<backend information not available>";
    else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        wait_event_type = "<insufficient privilege>";
    else if ((proc = BackendPidGetProc(beentry->st_procpid)) != NULL)
        wait_event_type = pgstat_get_wait_event_type(proc->wait_event_info);
 
    if (!wait_event_type)
        PG_RETURN_NULL();
 
    PG_RETURN_TEXT_P(cstring_to_text(wait_event_type));
}

References BackendPidGetProc(), cstring_to_text(), HAS_PGSTAT_PERMISSIONS, PG_GETARG_INT32, PG_RETURN_NULL, PG_RETURN_TEXT_P, pgstat_get_beentry_by_proc_number(), pgstat_get_wait_event_type(), PgBackendStatus::st_procpid, PgBackendStatus::st_userid, and PGPROC::wait_event_info.

pg_stat_get_backend_wal()

Datum pg_stat_get_backend_wal

(

PG_FUNCTION_ARGS

)

Definition at line 1666 of file pgstatfuncs.c.

{
    int         pid;
    PgStat_Backend *backend_stats;
    PgStat_WalCounters bktype_stats;
 
    pid = PG_GETARG_INT32(0);
    backend_stats = pgstat_fetch_stat_backend_by_pid(pid, NULL);
 
    if (!backend_stats)
        PG_RETURN_NULL();
 
    bktype_stats = backend_stats->wal_counters;
 
    /* save tuples with data from this PgStat_WalCounters */
    return (pg_stat_wal_build_tuple(bktype_stats, backend_stats->stat_reset_timestamp));
}

References PG_GETARG_INT32, PG_RETURN_NULL, pg_stat_wal_build_tuple(), pgstat_fetch_stat_backend_by_pid(), PgStat_Backend::stat_reset_timestamp, and PgStat_Backend::wal_counters.

pg_stat_get_backend_xact_start()

Datum pg_stat_get_backend_xact_start

(

PG_FUNCTION_ARGS

)

Definition at line 864 of file pgstatfuncs.c.

{
    int32       procNumber = PG_GETARG_INT32(0);
    TimestampTz result;
    PgBackendStatus *beentry;
 
    if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
        PG_RETURN_NULL();
 
    else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        PG_RETURN_NULL();
 
    result = beentry->st_xact_start_timestamp;
 
    if (result == 0)            /* not in a transaction */
        PG_RETURN_NULL();
 
    PG_RETURN_TIMESTAMPTZ(result);
}

References HAS_PGSTAT_PERMISSIONS, PG_GETARG_INT32, PG_RETURN_NULL, PG_RETURN_TIMESTAMPTZ, pgstat_get_beentry_by_proc_number(), PgBackendStatus::st_userid, and PgBackendStatus::st_xact_start_timestamp.

pg_stat_get_bgwriter_buf_written_clean()

Datum pg_stat_get_bgwriter_buf_written_clean

(

PG_FUNCTION_ARGS

)

Definition at line 1262 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_bgwriter()->buf_written_clean);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_bgwriter().

pg_stat_get_bgwriter_maxwritten_clean()

Datum pg_stat_get_bgwriter_maxwritten_clean

(

PG_FUNCTION_ARGS

)

Definition at line 1268 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_bgwriter()->maxwritten_clean);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_bgwriter().

pg_stat_get_bgwriter_stat_reset_time()

Datum pg_stat_get_bgwriter_stat_reset_time

(

PG_FUNCTION_ARGS

)

Definition at line 1296 of file pgstatfuncs.c.

{
    PG_RETURN_TIMESTAMPTZ(pgstat_fetch_stat_bgwriter()->stat_reset_timestamp);
}

References PG_RETURN_TIMESTAMPTZ, and pgstat_fetch_stat_bgwriter().

pg_stat_get_buf_alloc()

Datum pg_stat_get_buf_alloc

(

PG_FUNCTION_ARGS

)

Definition at line 1302 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_bgwriter()->buf_alloc);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_bgwriter().

pg_stat_get_checkpointer_buffers_written()

Datum pg_stat_get_checkpointer_buffers_written

(

PG_FUNCTION_ARGS

)

Definition at line 1250 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->buffers_written);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_num_performed()

Datum pg_stat_get_checkpointer_num_performed

(

PG_FUNCTION_ARGS

)

Definition at line 1226 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->num_performed);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_num_requested()

Datum pg_stat_get_checkpointer_num_requested

(

PG_FUNCTION_ARGS

)

Definition at line 1220 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->num_requested);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_num_timed()

Datum pg_stat_get_checkpointer_num_timed

(

PG_FUNCTION_ARGS

)

Definition at line 1214 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->num_timed);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_restartpoints_performed()

Datum pg_stat_get_checkpointer_restartpoints_performed

(

PG_FUNCTION_ARGS

)

Definition at line 1244 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->restartpoints_performed);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_restartpoints_requested()

Datum pg_stat_get_checkpointer_restartpoints_requested

(

PG_FUNCTION_ARGS

)

Definition at line 1238 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->restartpoints_requested);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_restartpoints_timed()

Datum pg_stat_get_checkpointer_restartpoints_timed

(

PG_FUNCTION_ARGS

)

Definition at line 1232 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->restartpoints_timed);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_slru_written()

Datum pg_stat_get_checkpointer_slru_written

(

PG_FUNCTION_ARGS

)

Definition at line 1256 of file pgstatfuncs.c.

{
    PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->slru_written);
}

References PG_RETURN_INT64, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_stat_reset_time()

Datum pg_stat_get_checkpointer_stat_reset_time

(

PG_FUNCTION_ARGS

)

Definition at line 1290 of file pgstatfuncs.c.

{
    PG_RETURN_TIMESTAMPTZ(pgstat_fetch_stat_checkpointer()->stat_reset_timestamp);
}

References PG_RETURN_TIMESTAMPTZ, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_sync_time()

Datum pg_stat_get_checkpointer_sync_time

(

PG_FUNCTION_ARGS

)

Definition at line 1282 of file pgstatfuncs.c.

{
    /* time is already in msec, just convert to double for presentation */
    PG_RETURN_FLOAT8((double)
                     pgstat_fetch_stat_checkpointer()->sync_time);
}

References PG_RETURN_FLOAT8, and pgstat_fetch_stat_checkpointer().

pg_stat_get_checkpointer_write_time()

Datum pg_stat_get_checkpointer_write_time

(

PG_FUNCTION_ARGS

)

Definition at line 1274 of file pgstatfuncs.c.

{
    /* time is already in msec, just convert to double for presentation */
    PG_RETURN_FLOAT8((double)
                     pgstat_fetch_stat_checkpointer()->write_time);
}

References PG_RETURN_FLOAT8, and pgstat_fetch_stat_checkpointer().

pg_stat_get_db_checksum_failures()

Datum pg_stat_get_db_checksum_failures

(

PG_FUNCTION_ARGS

)

Definition at line 1143 of file pgstatfuncs.c.

{
    Oid         dbid = PG_GETARG_OID(0);
    int64       result;
    PgStat_StatDBEntry *dbentry;
 
    if (!DataChecksumsEnabled())
        PG_RETURN_NULL();
 
    if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
        result = 0;
    else
        result = (int64) (dbentry->checksum_failures);
 
    PG_RETURN_INT64(result);
}

References PgStat_StatDBEntry::checksum_failures, DataChecksumsEnabled(), PG_GETARG_OID, PG_RETURN_INT64, PG_RETURN_NULL, and pgstat_fetch_stat_dbentry().

pg_stat_get_db_checksum_last_failure()

Datum pg_stat_get_db_checksum_last_failure

(

PG_FUNCTION_ARGS

)

Definition at line 1161 of file pgstatfuncs.c.

{
    Oid         dbid = PG_GETARG_OID(0);
    TimestampTz result;
    PgStat_StatDBEntry *dbentry;
 
    if (!DataChecksumsEnabled())
        PG_RETURN_NULL();
 
    if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
        result = 0;
    else
        result = dbentry->last_checksum_failure;
 
    if (result == 0)
        PG_RETURN_NULL();
    else
        PG_RETURN_TIMESTAMPTZ(result);
}

References DataChecksumsEnabled(), PgStat_StatDBEntry::last_checksum_failure, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TIMESTAMPTZ, and pgstat_fetch_stat_dbentry().

pg_stat_get_db_conflict_all()

Datum pg_stat_get_db_conflict_all

(

PG_FUNCTION_ARGS

)

Definition at line 1123 of file pgstatfuncs.c.

{
    Oid         dbid = PG_GETARG_OID(0);
    int64       result;
    PgStat_StatDBEntry *dbentry;
 
    if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
        result = 0;
    else
        result = (int64) (dbentry->conflict_tablespace +
                          dbentry->conflict_lock +
                          dbentry->conflict_snapshot +
                          dbentry->conflict_logicalslot +
                          dbentry->conflict_bufferpin +
                          dbentry->conflict_startup_deadlock);
 
    PG_RETURN_INT64(result);
}

References 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, PG_GETARG_OID, PG_RETURN_INT64, and pgstat_fetch_stat_dbentry().

pg_stat_get_db_numbackends()

Datum pg_stat_get_db_numbackends

(

PG_FUNCTION_ARGS

)

Definition at line 995 of file pgstatfuncs.c.

{
    Oid         dbid = PG_GETARG_OID(0);
    int32       result;
    int         tot_backends = pgstat_fetch_stat_numbackends();
    int         idx;
 
    result = 0;
    for (idx = 1; idx <= tot_backends; idx++)
    {
        LocalPgBackendStatus *local_beentry = pgstat_get_local_beentry_by_index(idx);
 
        if (local_beentry->backendStatus.st_databaseid == dbid)
            result++;
    }
 
    PG_RETURN_INT32(result);
}

References LocalPgBackendStatus::backendStatus, idx(), PG_GETARG_OID, PG_RETURN_INT32, pgstat_fetch_stat_numbackends(), pgstat_get_local_beentry_by_index(), and PgBackendStatus::st_databaseid.

pg_stat_get_db_stat_reset_time()

Datum pg_stat_get_db_stat_reset_time

(

PG_FUNCTION_ARGS

)

Definition at line 1104 of file pgstatfuncs.c.

{
    Oid         dbid = PG_GETARG_OID(0);
    TimestampTz result;
    PgStat_StatDBEntry *dbentry;
 
    if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
        result = 0;
    else
        result = dbentry->stat_reset_timestamp;
 
    if (result == 0)
        PG_RETURN_NULL();
    else
        PG_RETURN_TIMESTAMPTZ(result);
}

References PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TIMESTAMPTZ, pgstat_fetch_stat_dbentry(), and PgStat_StatDBEntry::stat_reset_timestamp.

pg_stat_get_function_calls()

Datum pg_stat_get_function_calls

(

PG_FUNCTION_ARGS

)

Definition at line 172 of file pgstatfuncs.c.

{
    Oid         funcid = PG_GETARG_OID(0);
    PgStat_StatFuncEntry *funcentry;
 
    if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
        PG_RETURN_NULL();
    PG_RETURN_INT64(funcentry->numcalls);
}

References PgStat_StatFuncEntry::numcalls, PG_GETARG_OID, PG_RETURN_INT64, PG_RETURN_NULL, and pgstat_fetch_stat_funcentry().

pg_stat_get_io()

Datum pg_stat_get_io

(

PG_FUNCTION_ARGS

)

Definition at line 1536 of file pgstatfuncs.c.

{
    ReturnSetInfo *rsinfo;
    PgStat_IO  *backends_io_stats;
 
    InitMaterializedSRF(fcinfo, 0);
    rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 
    backends_io_stats = pgstat_fetch_stat_io();
 
    for (int bktype = 0; bktype < BACKEND_NUM_TYPES; bktype++)
    {
        PgStat_BktypeIO *bktype_stats = &backends_io_stats->stats[bktype];
 
        /*
         * In Assert builds, we can afford an extra loop through all of the
         * counters (in pg_stat_io_build_tuples()), checking that only
         * expected stats are non-zero, since it keeps the non-Assert code
         * cleaner.
         */
        Assert(pgstat_bktype_io_stats_valid(bktype_stats, bktype));
 
        /*
         * For those BackendTypes without IO Operation stats, skip
         * representing them in the view altogether.
         */
        if (!pgstat_tracks_io_bktype(bktype))
            continue;
 
        /* save tuples with data from this PgStat_BktypeIO */
        pg_stat_io_build_tuples(rsinfo, bktype_stats, bktype,
                                backends_io_stats->stat_reset_timestamp);
    }
 
    return (Datum) 0;
}

References Assert(), BACKEND_NUM_TYPES, InitMaterializedSRF(), pg_stat_io_build_tuples(), pgstat_bktype_io_stats_valid(), pgstat_fetch_stat_io(), pgstat_tracks_io_bktype(), PgStat_IO::stat_reset_timestamp, and PgStat_IO::stats.

pg_stat_get_progress_info()

Datum pg_stat_get_progress_info

(

PG_FUNCTION_ARGS

)

Definition at line 255 of file pgstatfuncs.c.

{
#define PG_STAT_GET_PROGRESS_COLS   PGSTAT_NUM_PROGRESS_PARAM + 3
    int         num_backends = pgstat_fetch_stat_numbackends();
    int         curr_backend;
    char       *cmd = text_to_cstring(PG_GETARG_TEXT_PP(0));
    ProgressCommandType cmdtype;
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 
    /* Translate command name into command type code. */
    if (pg_strcasecmp(cmd, "VACUUM") == 0)
        cmdtype = PROGRESS_COMMAND_VACUUM;
    else if (pg_strcasecmp(cmd, "ANALYZE") == 0)
        cmdtype = PROGRESS_COMMAND_ANALYZE;
    else if (pg_strcasecmp(cmd, "CLUSTER") == 0)
        cmdtype = PROGRESS_COMMAND_CLUSTER;
    else if (pg_strcasecmp(cmd, "CREATE INDEX") == 0)
        cmdtype = PROGRESS_COMMAND_CREATE_INDEX;
    else if (pg_strcasecmp(cmd, "BASEBACKUP") == 0)
        cmdtype = PROGRESS_COMMAND_BASEBACKUP;
    else if (pg_strcasecmp(cmd, "COPY") == 0)
        cmdtype = PROGRESS_COMMAND_COPY;
    else
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid command name: \"%s\"", cmd)));
 
    InitMaterializedSRF(fcinfo, 0);
 
    /* 1-based index */
    for (curr_backend = 1; curr_backend <= num_backends; curr_backend++)
    {
        LocalPgBackendStatus *local_beentry;
        PgBackendStatus *beentry;
        Datum       values[PG_STAT_GET_PROGRESS_COLS] = {0};
        bool        nulls[PG_STAT_GET_PROGRESS_COLS] = {0};
        int         i;
 
        local_beentry = pgstat_get_local_beentry_by_index(curr_backend);
        beentry = &local_beentry->backendStatus;
 
        /*
         * Report values for only those backends which are running the given
         * command.
         */
        if (beentry->st_progress_command != cmdtype)
            continue;
 
        /* Value available to all callers */
        values[0] = Int32GetDatum(beentry->st_procpid);
        values[1] = ObjectIdGetDatum(beentry->st_databaseid);
 
        /* show rest of the values including relid only to role members */
        if (HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
        {
            values[2] = ObjectIdGetDatum(beentry->st_progress_command_target);
            for (i = 0; i < PGSTAT_NUM_PROGRESS_PARAM; i++)
                values[i + 3] = Int64GetDatum(beentry->st_progress_param[i]);
        }
        else
        {
            nulls[2] = true;
            for (i = 0; i < PGSTAT_NUM_PROGRESS_PARAM; i++)
                nulls[i + 3] = true;
        }
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
    }
 
    return (Datum) 0;
}

References LocalPgBackendStatus::backendStatus, ereport, errcode(), errmsg(), ERROR, HAS_PGSTAT_PERMISSIONS, i, if(), InitMaterializedSRF(), Int32GetDatum(), Int64GetDatum(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_STAT_GET_PROGRESS_COLS, pg_strcasecmp(), pgstat_fetch_stat_numbackends(), pgstat_get_local_beentry_by_index(), PGSTAT_NUM_PROGRESS_PARAM, PROGRESS_COMMAND_ANALYZE, PROGRESS_COMMAND_BASEBACKUP, PROGRESS_COMMAND_CLUSTER, PROGRESS_COMMAND_COPY, PROGRESS_COMMAND_CREATE_INDEX, PROGRESS_COMMAND_VACUUM, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, PgBackendStatus::st_databaseid, PgBackendStatus::st_procpid, PgBackendStatus::st_progress_command, PgBackendStatus::st_progress_command_target, PgBackendStatus::st_progress_param, PgBackendStatus::st_userid, text_to_cstring(), tuplestore_putvalues(), and values.

pg_stat_get_replication_slot()

Datum pg_stat_get_replication_slot

(

PG_FUNCTION_ARGS

)

Definition at line 2101 of file pgstatfuncs.c.

{
#define PG_STAT_GET_REPLICATION_SLOT_COLS 10
    text       *slotname_text = PG_GETARG_TEXT_P(0);
    NameData    slotname;
    TupleDesc   tupdesc;
    Datum       values[PG_STAT_GET_REPLICATION_SLOT_COLS] = {0};
    bool        nulls[PG_STAT_GET_REPLICATION_SLOT_COLS] = {0};
    PgStat_StatReplSlotEntry *slotent;
    PgStat_StatReplSlotEntry allzero;
 
    /* Initialise attributes information in the tuple descriptor */
    tupdesc = CreateTemplateTupleDesc(PG_STAT_GET_REPLICATION_SLOT_COLS);
    TupleDescInitEntry(tupdesc, (AttrNumber) 1, "slot_name",
                       TEXTOID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 2, "spill_txns",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 3, "spill_count",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 4, "spill_bytes",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 5, "stream_txns",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 6, "stream_count",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 7, "stream_bytes",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 8, "total_txns",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 9, "total_bytes",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 10, "stats_reset",
                       TIMESTAMPTZOID, -1, 0);
    BlessTupleDesc(tupdesc);
 
    namestrcpy(&slotname, text_to_cstring(slotname_text));
    slotent = pgstat_fetch_replslot(slotname);
    if (!slotent)
    {
        /*
         * If the slot is not found, initialise its stats. This is possible if
         * the create slot message is lost.
         */
        memset(&allzero, 0, sizeof(PgStat_StatReplSlotEntry));
        slotent = &allzero;
    }
 
    values[0] = CStringGetTextDatum(NameStr(slotname));
    values[1] = Int64GetDatum(slotent->spill_txns);
    values[2] = Int64GetDatum(slotent->spill_count);
    values[3] = Int64GetDatum(slotent->spill_bytes);
    values[4] = Int64GetDatum(slotent->stream_txns);
    values[5] = Int64GetDatum(slotent->stream_count);
    values[6] = Int64GetDatum(slotent->stream_bytes);
    values[7] = Int64GetDatum(slotent->total_txns);
    values[8] = Int64GetDatum(slotent->total_bytes);
 
    if (slotent->stat_reset_timestamp == 0)
        nulls[9] = true;
    else
        values[9] = TimestampTzGetDatum(slotent->stat_reset_timestamp);
 
    /* Returns the record as Datum */
    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

References BlessTupleDesc(), CreateTemplateTupleDesc(), CStringGetTextDatum, heap_form_tuple(), HeapTupleGetDatum(), Int64GetDatum(), NameStr, namestrcpy(), PG_GETARG_TEXT_P, PG_RETURN_DATUM, PG_STAT_GET_REPLICATION_SLOT_COLS, pgstat_fetch_replslot(), PgStat_StatReplSlotEntry::spill_bytes, PgStat_StatReplSlotEntry::spill_count, PgStat_StatReplSlotEntry::spill_txns, PgStat_StatReplSlotEntry::stat_reset_timestamp, PgStat_StatReplSlotEntry::stream_bytes, PgStat_StatReplSlotEntry::stream_count, PgStat_StatReplSlotEntry::stream_txns, text_to_cstring(), TimestampTzGetDatum(), PgStat_StatReplSlotEntry::total_bytes, PgStat_StatReplSlotEntry::total_txns, TupleDescInitEntry(), and values.

pg_stat_get_slru()

Datum pg_stat_get_slru

(

PG_FUNCTION_ARGS

)

Definition at line 1703 of file pgstatfuncs.c.

{
#define PG_STAT_GET_SLRU_COLS   9
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    int         i;
    PgStat_SLRUStats *stats;
 
    InitMaterializedSRF(fcinfo, 0);
 
    /* request SLRU stats from the cumulative stats system */
    stats = pgstat_fetch_slru();
 
    for (i = 0;; i++)
    {
        /* for each row */
        Datum       values[PG_STAT_GET_SLRU_COLS] = {0};
        bool        nulls[PG_STAT_GET_SLRU_COLS] = {0};
        PgStat_SLRUStats stat;
        const char *name;
 
        name = pgstat_get_slru_name(i);
 
        if (!name)
            break;
 
        stat = stats[i];
 
        values[0] = PointerGetDatum(cstring_to_text(name));
        values[1] = Int64GetDatum(stat.blocks_zeroed);
        values[2] = Int64GetDatum(stat.blocks_hit);
        values[3] = Int64GetDatum(stat.blocks_read);
        values[4] = Int64GetDatum(stat.blocks_written);
        values[5] = Int64GetDatum(stat.blocks_exists);
        values[6] = Int64GetDatum(stat.flush);
        values[7] = Int64GetDatum(stat.truncate);
        values[8] = TimestampTzGetDatum(stat.stat_reset_timestamp);
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
    }
 
    return (Datum) 0;
}

References cstring_to_text(), i, InitMaterializedSRF(), Int64GetDatum(), name, PG_STAT_GET_SLRU_COLS, pgstat_fetch_slru(), pgstat_get_slru_name(), PointerGetDatum(), ReturnSetInfo::setDesc, ReturnSetInfo::setResult, stat, TimestampTzGetDatum(), tuplestore_putvalues(), and values.

pg_stat_get_snapshot_timestamp()

Datum pg_stat_get_snapshot_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 1823 of file pgstatfuncs.c.

{
    bool        have_snapshot;
    TimestampTz ts;
 
    ts = pgstat_get_stat_snapshot_timestamp(&have_snapshot);
 
    if (!have_snapshot)
        PG_RETURN_NULL();
 
    PG_RETURN_TIMESTAMPTZ(ts);
}

References PG_RETURN_NULL, PG_RETURN_TIMESTAMPTZ, and pgstat_get_stat_snapshot_timestamp().

pg_stat_get_subscription_stats()

Datum pg_stat_get_subscription_stats

(

PG_FUNCTION_ARGS

)

Definition at line 2172 of file pgstatfuncs.c.

{
#define PG_STAT_GET_SUBSCRIPTION_STATS_COLS 11
    Oid         subid = PG_GETARG_OID(0);
    TupleDesc   tupdesc;
    Datum       values[PG_STAT_GET_SUBSCRIPTION_STATS_COLS] = {0};
    bool        nulls[PG_STAT_GET_SUBSCRIPTION_STATS_COLS] = {0};
    PgStat_StatSubEntry *subentry;
    PgStat_StatSubEntry allzero;
    int         i = 0;
 
    /* Get subscription stats */
    subentry = pgstat_fetch_stat_subscription(subid);
 
    /* Initialise attributes information in the tuple descriptor */
    tupdesc = CreateTemplateTupleDesc(PG_STAT_GET_SUBSCRIPTION_STATS_COLS);
    TupleDescInitEntry(tupdesc, (AttrNumber) 1, "subid",
                       OIDOID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 2, "apply_error_count",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 3, "sync_error_count",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 4, "confl_insert_exists",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 5, "confl_update_origin_differs",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 6, "confl_update_exists",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 7, "confl_update_missing",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 8, "confl_delete_origin_differs",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 9, "confl_delete_missing",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 10, "confl_multiple_unique_conflicts",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 11, "stats_reset",
                       TIMESTAMPTZOID, -1, 0);
    BlessTupleDesc(tupdesc);
 
    if (!subentry)
    {
        /* If the subscription is not found, initialise its stats */
        memset(&allzero, 0, sizeof(PgStat_StatSubEntry));
        subentry = &allzero;
    }
 
    /* subid */
    values[i++] = ObjectIdGetDatum(subid);
 
    /* apply_error_count */
    values[i++] = Int64GetDatum(subentry->apply_error_count);
 
    /* sync_error_count */
    values[i++] = Int64GetDatum(subentry->sync_error_count);
 
    /* conflict count */
    for (int nconflict = 0; nconflict < CONFLICT_NUM_TYPES; nconflict++)
        values[i++] = Int64GetDatum(subentry->conflict_count[nconflict]);
 
    /* stats_reset */
    if (subentry->stat_reset_timestamp == 0)
        nulls[i] = true;
    else
        values[i] = TimestampTzGetDatum(subentry->stat_reset_timestamp);
 
    Assert(i + 1 == PG_STAT_GET_SUBSCRIPTION_STATS_COLS);
 
    /* Returns the record as Datum */
    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

References PgStat_StatSubEntry::apply_error_count, Assert(), BlessTupleDesc(), PgStat_StatSubEntry::conflict_count, CONFLICT_NUM_TYPES, CreateTemplateTupleDesc(), heap_form_tuple(), HeapTupleGetDatum(), i, Int64GetDatum(), ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_DATUM, PG_STAT_GET_SUBSCRIPTION_STATS_COLS, pgstat_fetch_stat_subscription(), PgStat_StatSubEntry::stat_reset_timestamp, PgStat_StatSubEntry::sync_error_count, TimestampTzGetDatum(), TupleDescInitEntry(), and values.

pg_stat_get_wal()

Datum pg_stat_get_wal

(

PG_FUNCTION_ARGS

)

Definition at line 1688 of file pgstatfuncs.c.

{
    PgStat_WalStats *wal_stats;
 
    /* Get statistics about WAL activity */
    wal_stats = pgstat_fetch_stat_wal();
 
    return (pg_stat_wal_build_tuple(wal_stats->wal_counters,
                                    wal_stats->stat_reset_timestamp));
}

References pg_stat_wal_build_tuple(), pgstat_fetch_stat_wal(), PgStat_WalStats::stat_reset_timestamp, and PgStat_WalStats::wal_counters.

pg_stat_get_xact_function_calls()

Datum pg_stat_get_xact_function_calls

(

PG_FUNCTION_ARGS

)

Definition at line 1793 of file pgstatfuncs.c.

{
    Oid         funcid = PG_GETARG_OID(0);
    PgStat_FunctionCounts *funcentry;
 
    if ((funcentry = find_funcstat_entry(funcid)) == NULL)
        PG_RETURN_NULL();
    PG_RETURN_INT64(funcentry->numcalls);
}

References find_funcstat_entry(), PgStat_FunctionCounts::numcalls, PG_GETARG_OID, PG_RETURN_INT64, and PG_RETURN_NULL.

pg_stat_have_stats()

Datum pg_stat_have_stats

(

PG_FUNCTION_ARGS

)

Definition at line 2252 of file pgstatfuncs.c.

{
    char       *stats_type = text_to_cstring(PG_GETARG_TEXT_P(0));
    Oid         dboid = PG_GETARG_OID(1);
    uint64      objid = PG_GETARG_INT64(2);
    PgStat_Kind kind = pgstat_get_kind_from_str(stats_type);
 
    PG_RETURN_BOOL(pgstat_have_entry(kind, dboid, objid));
}

References PG_GETARG_INT64, PG_GETARG_OID, PG_GETARG_TEXT_P, PG_RETURN_BOOL, pgstat_get_kind_from_str(), pgstat_have_entry(), PgStat_Kind, and text_to_cstring().

pg_stat_io_build_tuples()

static void pg_stat_io_build_tuples ( ReturnSetInfo *  rsinfo, PgStat_BktypeIO *  bktype_stats, BackendType  bktype, TimestampTz  stat_reset_timestamp  )

static

Definition at line 1439 of file pgstatfuncs.c.

{
    Datum       bktype_desc = CStringGetTextDatum(GetBackendTypeDesc(bktype));
 
    for (int io_obj = 0; io_obj < IOOBJECT_NUM_TYPES; io_obj++)
    {
        const char *obj_name = pgstat_get_io_object_name(io_obj);
 
        for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
        {
            const char *context_name = pgstat_get_io_context_name(io_context);
 
            Datum       values[IO_NUM_COLUMNS] = {0};
            bool        nulls[IO_NUM_COLUMNS] = {0};
 
            /*
             * Some combinations of BackendType, IOObject, and IOContext are
             * not valid for any type of IOOp. In such cases, omit the entire
             * row from the view.
             */
            if (!pgstat_tracks_io_object(bktype, io_obj, io_context))
                continue;
 
            values[IO_COL_BACKEND_TYPE] = bktype_desc;
            values[IO_COL_CONTEXT] = CStringGetTextDatum(context_name);
            values[IO_COL_OBJECT] = CStringGetTextDatum(obj_name);
            if (stat_reset_timestamp != 0)
                values[IO_COL_RESET_TIME] = TimestampTzGetDatum(stat_reset_timestamp);
            else
                nulls[IO_COL_RESET_TIME] = true;
 
            for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
            {
                int         op_idx = pgstat_get_io_op_index(io_op);
                int         time_idx = pgstat_get_io_time_index(io_op);
                int         byte_idx = pgstat_get_io_byte_index(io_op);
 
                /*
                 * Some combinations of BackendType and IOOp, of IOContext and
                 * IOOp, and of IOObject and IOOp are not tracked. Set these
                 * cells in the view NULL.
                 */
                if (pgstat_tracks_io_op(bktype, io_obj, io_context, io_op))
                {
                    PgStat_Counter count =
                        bktype_stats->counts[io_obj][io_context][io_op];
 
                    values[op_idx] = Int64GetDatum(count);
                }
                else
                    nulls[op_idx] = true;
 
                if (!nulls[op_idx])
                {
                    /* not every operation is timed */
                    if (time_idx != IO_COL_INVALID)
                    {
                        PgStat_Counter time =
                            bktype_stats->times[io_obj][io_context][io_op];
 
                        values[time_idx] = Float8GetDatum(pg_stat_us_to_ms(time));
                    }
 
                    /* not every IO is tracked in bytes */
                    if (byte_idx != IO_COL_INVALID)
                    {
                        char        buf[256];
                        PgStat_Counter byte =
                            bktype_stats->bytes[io_obj][io_context][io_op];
 
                        /* Convert to numeric */
                        snprintf(buf, sizeof buf, UINT64_FORMAT, byte);
                        values[byte_idx] = DirectFunctionCall3(numeric_in,
                                                               CStringGetDatum(buf),
                                                               ObjectIdGetDatum(0),
                                                               Int32GetDatum(-1));
                    }
                }
                else
                {
                    if (time_idx != IO_COL_INVALID)
                        nulls[time_idx] = true;
                    if (byte_idx != IO_COL_INVALID)
                        nulls[byte_idx] = true;
                }
            }
 
            tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                                 values, nulls);
        }
    }
}

References buf, PgStat_BktypeIO::bytes, PgStat_BktypeIO::counts, CStringGetDatum(), CStringGetTextDatum, DirectFunctionCall3, Float8GetDatum(), GetBackendTypeDesc(), Int32GetDatum(), Int64GetDatum(), IO_COL_BACKEND_TYPE, IO_COL_CONTEXT, IO_COL_INVALID, IO_COL_OBJECT, IO_COL_RESET_TIME, IO_NUM_COLUMNS, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, numeric_in(), ObjectIdGetDatum(), pg_stat_us_to_ms(), pgstat_get_io_byte_index(), pgstat_get_io_context_name(), pgstat_get_io_object_name(), pgstat_get_io_op_index(), pgstat_get_io_time_index(), pgstat_tracks_io_object(), pgstat_tracks_io_op(), ReturnSetInfo::setDesc, ReturnSetInfo::setResult, snprintf, PgStat_BktypeIO::times, TimestampTzGetDatum(), tuplestore_putvalues(), UINT64_FORMAT, and values.

Referenced by pg_stat_get_backend_io(), and pg_stat_get_io().

pg_stat_reset()

Datum pg_stat_reset

(

PG_FUNCTION_ARGS

)

Definition at line 1858 of file pgstatfuncs.c.

{
    pgstat_reset_counters();
 
    PG_RETURN_VOID();
}

References PG_RETURN_VOID, and pgstat_reset_counters().

pg_stat_reset_backend_stats()

Datum pg_stat_reset_backend_stats

(

PG_FUNCTION_ARGS

)

Definition at line 1944 of file pgstatfuncs.c.

{
    PGPROC     *proc;
    PgBackendStatus *beentry;
    ProcNumber  procNumber;
    int         backend_pid = PG_GETARG_INT32(0);
 
    proc = BackendPidGetProc(backend_pid);
 
    /* This could be an auxiliary process */
    if (!proc)
        proc = AuxiliaryPidGetProc(backend_pid);
 
    if (!proc)
        PG_RETURN_VOID();
 
    procNumber = GetNumberFromPGProc(proc);
 
    beentry = pgstat_get_beentry_by_proc_number(procNumber);
    if (!beentry)
        PG_RETURN_VOID();
 
    /* Check if the backend type tracks statistics */
    if (!pgstat_tracks_backend_bktype(beentry->st_backendType))
        PG_RETURN_VOID();
 
    pgstat_reset(PGSTAT_KIND_BACKEND, InvalidOid, procNumber);
 
    PG_RETURN_VOID();
}

References AuxiliaryPidGetProc(), BackendPidGetProc(), GetNumberFromPGProc, InvalidOid, PG_GETARG_INT32, PG_RETURN_VOID, pgstat_get_beentry_by_proc_number(), PGSTAT_KIND_BACKEND, pgstat_reset(), pgstat_tracks_backend_bktype(), and PgBackendStatus::st_backendType.

pg_stat_reset_replication_slot()

Datum pg_stat_reset_replication_slot

(

PG_FUNCTION_ARGS

)

Definition at line 1994 of file pgstatfuncs.c.

{
    char       *target = NULL;
 
    if (PG_ARGISNULL(0))
        pgstat_reset_of_kind(PGSTAT_KIND_REPLSLOT);
    else
    {
        target = text_to_cstring(PG_GETARG_TEXT_PP(0));
        pgstat_reset_replslot(target);
    }
 
    PG_RETURN_VOID();
}

References PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_RETURN_VOID, PGSTAT_KIND_REPLSLOT, pgstat_reset_of_kind(), pgstat_reset_replslot(), and text_to_cstring().

pg_stat_reset_shared()

Datum pg_stat_reset_shared

(

PG_FUNCTION_ARGS

)

Definition at line 1872 of file pgstatfuncs.c.

{
    char       *target = NULL;
 
    if (PG_ARGISNULL(0))
    {
        /* Reset all the statistics when nothing is specified */
        pgstat_reset_of_kind(PGSTAT_KIND_ARCHIVER);
        pgstat_reset_of_kind(PGSTAT_KIND_BGWRITER);
        pgstat_reset_of_kind(PGSTAT_KIND_CHECKPOINTER);
        pgstat_reset_of_kind(PGSTAT_KIND_IO);
        XLogPrefetchResetStats();
        pgstat_reset_of_kind(PGSTAT_KIND_SLRU);
        pgstat_reset_of_kind(PGSTAT_KIND_WAL);
 
        PG_RETURN_VOID();
    }
 
    target = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    if (strcmp(target, "archiver") == 0)
        pgstat_reset_of_kind(PGSTAT_KIND_ARCHIVER);
    else if (strcmp(target, "bgwriter") == 0)
        pgstat_reset_of_kind(PGSTAT_KIND_BGWRITER);
    else if (strcmp(target, "checkpointer") == 0)
        pgstat_reset_of_kind(PGSTAT_KIND_CHECKPOINTER);
    else if (strcmp(target, "io") == 0)
        pgstat_reset_of_kind(PGSTAT_KIND_IO);
    else if (strcmp(target, "recovery_prefetch") == 0)
        XLogPrefetchResetStats();
    else if (strcmp(target, "slru") == 0)
        pgstat_reset_of_kind(PGSTAT_KIND_SLRU);
    else if (strcmp(target, "wal") == 0)
        pgstat_reset_of_kind(PGSTAT_KIND_WAL);
    else
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("unrecognized reset target: \"%s\"", target),
                 errhint("Target must be \"archiver\", \"bgwriter\", \"checkpointer\", \"io\", \"recovery_prefetch\", \"slru\", or \"wal\".")));
 
    PG_RETURN_VOID();
}

References ereport, errcode(), errhint(), errmsg(), ERROR, PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_RETURN_VOID, PGSTAT_KIND_ARCHIVER, PGSTAT_KIND_BGWRITER, PGSTAT_KIND_CHECKPOINTER, PGSTAT_KIND_IO, PGSTAT_KIND_SLRU, PGSTAT_KIND_WAL, pgstat_reset_of_kind(), text_to_cstring(), and XLogPrefetchResetStats().

pg_stat_reset_single_function_counters()

Datum pg_stat_reset_single_function_counters

(

PG_FUNCTION_ARGS

)

Definition at line 1931 of file pgstatfuncs.c.

{
    Oid         funcoid = PG_GETARG_OID(0);
 
    pgstat_reset(PGSTAT_KIND_FUNCTION, MyDatabaseId, funcoid);
 
    PG_RETURN_VOID();
}

References MyDatabaseId, PG_GETARG_OID, PG_RETURN_VOID, PGSTAT_KIND_FUNCTION, and pgstat_reset().

pg_stat_reset_single_table_counters()

Datum pg_stat_reset_single_table_counters

(

PG_FUNCTION_ARGS

)

Definition at line 1920 of file pgstatfuncs.c.

{
    Oid         taboid = PG_GETARG_OID(0);
    Oid         dboid = (IsSharedRelation(taboid) ? InvalidOid : MyDatabaseId);
 
    pgstat_reset(PGSTAT_KIND_RELATION, dboid, taboid);
 
    PG_RETURN_VOID();
}

References InvalidOid, IsSharedRelation(), MyDatabaseId, PG_GETARG_OID, PG_RETURN_VOID, PGSTAT_KIND_RELATION, and pgstat_reset().

pg_stat_reset_slru()

Datum pg_stat_reset_slru

(

PG_FUNCTION_ARGS

)

Definition at line 1977 of file pgstatfuncs.c.

{
    char       *target = NULL;
 
    if (PG_ARGISNULL(0))
        pgstat_reset_of_kind(PGSTAT_KIND_SLRU);
    else
    {
        target = text_to_cstring(PG_GETARG_TEXT_PP(0));
        pgstat_reset_slru(target);
    }
 
    PG_RETURN_VOID();
}

References PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_RETURN_VOID, PGSTAT_KIND_SLRU, pgstat_reset_of_kind(), pgstat_reset_slru(), and text_to_cstring().

pg_stat_reset_subscription_stats()

Datum pg_stat_reset_subscription_stats

(

PG_FUNCTION_ARGS

)

Definition at line 2011 of file pgstatfuncs.c.

{
    Oid         subid;
 
    if (PG_ARGISNULL(0))
    {
        /* Clear all subscription stats */
        pgstat_reset_of_kind(PGSTAT_KIND_SUBSCRIPTION);
    }
    else
    {
        subid = PG_GETARG_OID(0);
 
        if (!OidIsValid(subid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid subscription OID %u", subid)));
        pgstat_reset(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid);
    }
 
    PG_RETURN_VOID();
}

References ereport, errcode(), errmsg(), ERROR, InvalidOid, OidIsValid, PG_ARGISNULL, PG_GETARG_OID, PG_RETURN_VOID, PGSTAT_KIND_SUBSCRIPTION, pgstat_reset(), and pgstat_reset_of_kind().

pg_stat_us_to_ms()

static double pg_stat_us_to_ms ( PgStat_Counter  val_ms )

inlinestatic

Definition at line 1426 of file pgstatfuncs.c.

{
    return val_ms * (double) 0.001;
}

Referenced by pg_stat_io_build_tuples().

pg_stat_wal_build_tuple()

static Datum pg_stat_wal_build_tuple ( PgStat_WalCounters  wal_counters, TimestampTz  stat_reset_timestamp  )

static

Definition at line 1616 of file pgstatfuncs.c.

{
#define PG_STAT_WAL_COLS    5
    TupleDesc   tupdesc;
    Datum       values[PG_STAT_WAL_COLS] = {0};
    bool        nulls[PG_STAT_WAL_COLS] = {0};
    char        buf[256];
 
    /* Initialise attributes information in the tuple descriptor */
    tupdesc = CreateTemplateTupleDesc(PG_STAT_WAL_COLS);
    TupleDescInitEntry(tupdesc, (AttrNumber) 1, "wal_records",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 2, "wal_fpi",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 3, "wal_bytes",
                       NUMERICOID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 4, "wal_buffers_full",
                       INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, (AttrNumber) 5, "stats_reset",
                       TIMESTAMPTZOID, -1, 0);
 
    BlessTupleDesc(tupdesc);
 
    /* Fill values and NULLs */
    values[0] = Int64GetDatum(wal_counters.wal_records);
    values[1] = Int64GetDatum(wal_counters.wal_fpi);
 
    /* Convert to numeric. */
    snprintf(buf, sizeof buf, UINT64_FORMAT, wal_counters.wal_bytes);
    values[2] = DirectFunctionCall3(numeric_in,
                                    CStringGetDatum(buf),
                                    ObjectIdGetDatum(0),
                                    Int32GetDatum(-1));
 
    values[3] = Int64GetDatum(wal_counters.wal_buffers_full);
 
    if (stat_reset_timestamp != 0)
        values[4] = TimestampTzGetDatum(stat_reset_timestamp);
    else
        nulls[4] = true;
 
    /* Returns the record as Datum */
    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

References BlessTupleDesc(), buf, CreateTemplateTupleDesc(), CStringGetDatum(), DirectFunctionCall3, heap_form_tuple(), HeapTupleGetDatum(), Int32GetDatum(), Int64GetDatum(), numeric_in(), ObjectIdGetDatum(), PG_RETURN_DATUM, PG_STAT_WAL_COLS, snprintf, TimestampTzGetDatum(), TupleDescInitEntry(), UINT64_FORMAT, values, PgStat_WalCounters::wal_buffers_full, PgStat_WalCounters::wal_bytes, PgStat_WalCounters::wal_fpi, and PgStat_WalCounters::wal_records.

Referenced by pg_stat_get_backend_wal(), and pg_stat_get_wal().

pgstat_get_io_byte_index()

static io_stat_col pgstat_get_io_byte_index ( IOOp  io_op )

static

Definition at line 1374 of file pgstatfuncs.c.

{
    switch (io_op)
    {
        case IOOP_EXTEND:
            return IO_COL_EXTEND_BYTES;
        case IOOP_READ:
            return IO_COL_READ_BYTES;
        case IOOP_WRITE:
            return IO_COL_WRITE_BYTES;
        case IOOP_EVICT:
        case IOOP_FSYNC:
        case IOOP_HIT:
        case IOOP_REUSE:
        case IOOP_WRITEBACK:
            return IO_COL_INVALID;
    }
 
    elog(ERROR, "unrecognized IOOp value: %d", io_op);
    pg_unreachable();
}

References elog, ERROR, IO_COL_EXTEND_BYTES, IO_COL_INVALID, IO_COL_READ_BYTES, IO_COL_WRITE_BYTES, IOOP_EVICT, IOOP_EXTEND, IOOP_FSYNC, IOOP_HIT, IOOP_READ, IOOP_REUSE, IOOP_WRITE, IOOP_WRITEBACK, and pg_unreachable.

Referenced by pg_stat_io_build_tuples().

pgstat_get_io_op_index()

static io_stat_col pgstat_get_io_op_index ( IOOp  io_op )

static

Definition at line 1343 of file pgstatfuncs.c.

{
    switch (io_op)
    {
        case IOOP_EVICT:
            return IO_COL_EVICTIONS;
        case IOOP_EXTEND:
            return IO_COL_EXTENDS;
        case IOOP_FSYNC:
            return IO_COL_FSYNCS;
        case IOOP_HIT:
            return IO_COL_HITS;
        case IOOP_READ:
            return IO_COL_READS;
        case IOOP_REUSE:
            return IO_COL_REUSES;
        case IOOP_WRITE:
            return IO_COL_WRITES;
        case IOOP_WRITEBACK:
            return IO_COL_WRITEBACKS;
    }
 
    elog(ERROR, "unrecognized IOOp value: %d", io_op);
    pg_unreachable();
}

References elog, ERROR, IO_COL_EVICTIONS, IO_COL_EXTENDS, IO_COL_FSYNCS, IO_COL_HITS, IO_COL_READS, IO_COL_REUSES, IO_COL_WRITEBACKS, IO_COL_WRITES, IOOP_EVICT, IOOP_EXTEND, IOOP_FSYNC, IOOP_HIT, IOOP_READ, IOOP_REUSE, IOOP_WRITE, IOOP_WRITEBACK, and pg_unreachable.

Referenced by pg_stat_io_build_tuples().

pgstat_get_io_time_index()

static io_stat_col pgstat_get_io_time_index ( IOOp  io_op )

static

Definition at line 1401 of file pgstatfuncs.c.

{
    switch (io_op)
    {
        case IOOP_READ:
            return IO_COL_READ_TIME;
        case IOOP_WRITE:
            return IO_COL_WRITE_TIME;
        case IOOP_WRITEBACK:
            return IO_COL_WRITEBACK_TIME;
        case IOOP_EXTEND:
            return IO_COL_EXTEND_TIME;
        case IOOP_FSYNC:
            return IO_COL_FSYNC_TIME;
        case IOOP_EVICT:
        case IOOP_HIT:
        case IOOP_REUSE:
            return IO_COL_INVALID;
    }
 
    elog(ERROR, "unrecognized IOOp value: %d", io_op);
    pg_unreachable();
}

References elog, ERROR, IO_COL_EXTEND_TIME, IO_COL_FSYNC_TIME, IO_COL_INVALID, IO_COL_READ_TIME, IO_COL_WRITE_TIME, IO_COL_WRITEBACK_TIME, IOOP_EVICT, IOOP_EXTEND, IOOP_FSYNC, IOOP_HIT, IOOP_READ, IOOP_REUSE, IOOP_WRITE, IOOP_WRITEBACK, and pg_unreachable.

Referenced by pg_stat_io_build_tuples().