Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * pgstatfuncs.c
4 : : * Functions for accessing various forms of statistics data
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/utils/adt/pgstatfuncs.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : : #include "postgres.h"
16 : :
17 : : #include "access/htup_details.h"
18 : : #include "access/xlog.h"
19 : : #include "access/xlogprefetcher.h"
20 : : #include "catalog/catalog.h"
21 : : #include "catalog/pg_authid.h"
22 : : #include "catalog/pg_type.h"
23 : : #include "common/ip.h"
24 : : #include "funcapi.h"
25 : : #include "miscadmin.h"
26 : : #include "pgstat.h"
27 : : #include "postmaster/bgworker.h"
28 : : #include "replication/logicallauncher.h"
29 : : #include "storage/proc.h"
30 : : #include "storage/procarray.h"
31 : : #include "utils/acl.h"
32 : : #include "utils/builtins.h"
33 : : #include "utils/timestamp.h"
34 : : #include "utils/tuplestore.h"
35 : : #include "utils/wait_event.h"
36 : :
37 : : #define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var))))
38 : :
39 : : #define HAS_PGSTAT_PERMISSIONS(role) (has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_STATS) || has_privs_of_role(GetUserId(), role))
40 : :
41 : : #define PG_STAT_GET_RELENTRY_INT64(stat) \
42 : : Datum \
43 : : CppConcat(pg_stat_get_,stat)(PG_FUNCTION_ARGS) \
44 : : { \
45 : : Oid relid = PG_GETARG_OID(0); \
46 : : int64 result; \
47 : : PgStat_StatTabEntry *tabentry; \
48 : : \
49 : : if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL) \
50 : : result = 0; \
51 : : else \
52 : : result = (int64) (tabentry->stat); \
53 : : \
54 : : PG_RETURN_INT64(result); \
55 : : }
56 : :
57 : : /* pg_stat_get_analyze_count */
58 [ - + ]: 2 : PG_STAT_GET_RELENTRY_INT64(analyze_count)
59 : :
60 : : /* pg_stat_get_autoanalyze_count */
61 [ # # ]: 0 : PG_STAT_GET_RELENTRY_INT64(autoanalyze_count)
62 : :
63 : : /* pg_stat_get_autovacuum_count */
64 [ # # ]: 0 : PG_STAT_GET_RELENTRY_INT64(autovacuum_count)
65 : :
66 : : /* pg_stat_get_blocks_fetched */
67 [ - + ]: 76 : PG_STAT_GET_RELENTRY_INT64(blocks_fetched)
68 : :
69 : : /* pg_stat_get_blocks_hit */
70 [ - + ]: 152 : PG_STAT_GET_RELENTRY_INT64(blocks_hit)
71 : :
72 : : /* pg_stat_get_dead_tuples */
73 [ + + ]: 93 : PG_STAT_GET_RELENTRY_INT64(dead_tuples)
74 : :
75 : : /* pg_stat_get_ins_since_vacuum */
76 [ # # ]: 0 : PG_STAT_GET_RELENTRY_INT64(ins_since_vacuum)
77 : :
78 : : /* pg_stat_get_live_tuples */
79 [ + + ]: 141 : PG_STAT_GET_RELENTRY_INT64(live_tuples)
80 : :
81 : : /* pg_stat_get_mod_since_analyze */
82 [ # # ]: 0 : PG_STAT_GET_RELENTRY_INT64(mod_since_analyze)
83 : :
84 : : /* pg_stat_get_numscans */
85 [ + + ]: 102 : PG_STAT_GET_RELENTRY_INT64(numscans)
86 : :
87 : : /* pg_stat_get_tuples_deleted */
88 [ + + ]: 39 : PG_STAT_GET_RELENTRY_INT64(tuples_deleted)
89 : :
90 : : /* pg_stat_get_tuples_fetched */
91 [ - + ]: 32 : PG_STAT_GET_RELENTRY_INT64(tuples_fetched)
92 : :
93 : : /* pg_stat_get_tuples_hot_updated */
94 [ - + ]: 10 : PG_STAT_GET_RELENTRY_INT64(tuples_hot_updated)
95 : :
96 : : /* pg_stat_get_tuples_newpage_updated */
97 [ # # ]: 0 : PG_STAT_GET_RELENTRY_INT64(tuples_newpage_updated)
98 : :
99 : : /* pg_stat_get_tuples_inserted */
100 [ + + ]: 115 : PG_STAT_GET_RELENTRY_INT64(tuples_inserted)
101 : :
102 : : /* pg_stat_get_tuples_returned */
103 [ + + ]: 27 : PG_STAT_GET_RELENTRY_INT64(tuples_returned)
104 : :
105 : : /* pg_stat_get_tuples_updated */
106 [ + + ]: 47 : PG_STAT_GET_RELENTRY_INT64(tuples_updated)
107 : :
108 : : /* pg_stat_get_vacuum_count */
109 [ + + ]: 5735 : PG_STAT_GET_RELENTRY_INT64(vacuum_count)
110 : :
111 : : #define PG_STAT_GET_RELENTRY_FLOAT8(stat) \
112 : : Datum \
113 : : CppConcat(pg_stat_get_,stat)(PG_FUNCTION_ARGS) \
114 : : { \
115 : : Oid relid = PG_GETARG_OID(0); \
116 : : double result; \
117 : : PgStat_StatTabEntry *tabentry; \
118 : : \
119 : : if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL) \
120 : : result = 0; \
121 : : else \
122 : : result = (double) (tabentry->stat); \
123 : : \
124 : : PG_RETURN_FLOAT8(result); \
125 : : }
126 : :
127 : : /* pg_stat_get_total_vacuum_time */
128 [ # # ]: 0 : PG_STAT_GET_RELENTRY_FLOAT8(total_vacuum_time)
129 : :
130 : : /* pg_stat_get_total_autovacuum_time */
131 [ # # ]: 0 : PG_STAT_GET_RELENTRY_FLOAT8(total_autovacuum_time)
132 : :
133 : : /* pg_stat_get_total_analyze_time */
134 [ # # ]: 0 : PG_STAT_GET_RELENTRY_FLOAT8(total_analyze_time)
135 : :
136 : : /* pg_stat_get_total_autoanalyze_time */
137 [ # # ]: 0 : PG_STAT_GET_RELENTRY_FLOAT8(total_autoanalyze_time)
138 : :
139 : : #define PG_STAT_GET_RELENTRY_TIMESTAMPTZ(stat) \
140 : : Datum \
141 : : CppConcat(pg_stat_get_,stat)(PG_FUNCTION_ARGS) \
142 : : { \
143 : : Oid relid = PG_GETARG_OID(0); \
144 : : TimestampTz result; \
145 : : PgStat_StatTabEntry *tabentry; \
146 : : \
147 : : if ((tabentry = pgstat_fetch_stat_tabentry(relid)) == NULL) \
148 : : result = 0; \
149 : : else \
150 : : result = tabentry->stat; \
151 : : \
152 : : if (result == 0) \
153 : : PG_RETURN_NULL(); \
154 : : else \
155 : : PG_RETURN_TIMESTAMPTZ(result); \
156 : : }
157 : :
158 : : /* pg_stat_get_last_analyze_time */
159 [ - + + + ]: 64 : PG_STAT_GET_RELENTRY_TIMESTAMPTZ(last_analyze_time)
160 : :
161 : : /* pg_stat_get_last_autoanalyze_time */
162 [ # # # # ]: 0 : PG_STAT_GET_RELENTRY_TIMESTAMPTZ(last_autoanalyze_time)
163 : :
164 : : /* pg_stat_get_last_autovacuum_time */
165 [ # # # # ]: 0 : PG_STAT_GET_RELENTRY_TIMESTAMPTZ(last_autovacuum_time)
166 : :
167 : : /* pg_stat_get_last_vacuum_time */
168 [ - + + + ]: 48 : PG_STAT_GET_RELENTRY_TIMESTAMPTZ(last_vacuum_time)
169 : :
170 : : /* pg_stat_get_lastscan */
171 [ - + + + ]: 60 : PG_STAT_GET_RELENTRY_TIMESTAMPTZ(lastscan)
172 : :
173 : : /* pg_stat_get_stat_reset_time */
174 [ - + + + ]: 24 : PG_STAT_GET_RELENTRY_TIMESTAMPTZ(stat_reset_time)
175 : :
176 : : Datum
177 : 157 : pg_stat_get_function_calls(PG_FUNCTION_ARGS)
178 : : {
179 : 157 : Oid funcid = PG_GETARG_OID(0);
180 : : PgStat_StatFuncEntry *funcentry;
181 : :
182 [ + + ]: 157 : if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
183 : 69 : PG_RETURN_NULL();
184 : 88 : PG_RETURN_INT64(funcentry->numcalls);
185 : : }
186 : :
187 : : /* convert counter from microsec to millisec for display */
188 : : #define PG_STAT_GET_FUNCENTRY_FLOAT8_MS(stat) \
189 : : Datum \
190 : : CppConcat(pg_stat_get_function_,stat)(PG_FUNCTION_ARGS) \
191 : : { \
192 : : Oid funcid = PG_GETARG_OID(0); \
193 : : double result; \
194 : : PgStat_StatFuncEntry *funcentry; \
195 : : \
196 : : if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL) \
197 : : PG_RETURN_NULL(); \
198 : : result = ((double) funcentry->stat) / 1000.0; \
199 : : PG_RETURN_FLOAT8(result); \
200 : : }
201 : :
202 : : /* pg_stat_get_function_total_time */
203 [ + + ]: 77 : PG_STAT_GET_FUNCENTRY_FLOAT8_MS(total_time)
204 : :
205 : : /* pg_stat_get_function_self_time */
206 [ + + ]: 77 : PG_STAT_GET_FUNCENTRY_FLOAT8_MS(self_time)
207 : :
208 : : Datum
209 : 2 : pg_stat_get_function_stat_reset_time(PG_FUNCTION_ARGS)
210 : : {
211 : 2 : Oid funcid = PG_GETARG_OID(0);
212 : : TimestampTz result;
213 : : PgStat_StatFuncEntry *funcentry;
214 : :
215 [ - + ]: 2 : if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
216 : 0 : result = 0;
217 : : else
218 : 2 : result = funcentry->stat_reset_timestamp;
219 : :
220 [ + + ]: 2 : if (result == 0)
221 : 1 : PG_RETURN_NULL();
222 : : else
223 : 1 : PG_RETURN_TIMESTAMPTZ(result);
224 : : }
225 : :
226 : : Datum
227 : 70 : pg_stat_get_backend_idset(PG_FUNCTION_ARGS)
228 : : {
229 : : FuncCallContext *funcctx;
230 : : int *fctx;
231 : :
232 : : /* stuff done only on the first call of the function */
233 [ + + ]: 70 : if (SRF_IS_FIRSTCALL())
234 : : {
235 : : /* create a function context for cross-call persistence */
236 : 4 : funcctx = SRF_FIRSTCALL_INIT();
237 : :
238 : 4 : fctx = MemoryContextAlloc(funcctx->multi_call_memory_ctx,
239 : : sizeof(int));
240 : 4 : funcctx->user_fctx = fctx;
241 : :
242 : 4 : fctx[0] = 0;
243 : : }
244 : :
245 : : /* stuff done on every call of the function */
246 : 70 : funcctx = SRF_PERCALL_SETUP();
247 : 70 : fctx = funcctx->user_fctx;
248 : :
249 : 70 : fctx[0] += 1;
250 : :
251 : : /*
252 : : * We recheck pgstat_fetch_stat_numbackends() each time through, just in
253 : : * case the local status data has been refreshed since we started. It's
254 : : * plenty cheap enough if not. If a refresh does happen, we'll likely
255 : : * miss or duplicate some backend IDs, but we're content not to crash.
256 : : * (Refreshing midway through such a query would be problematic usage
257 : : * anyway, since the backend IDs we've already returned might no longer
258 : : * refer to extant sessions.)
259 : : */
260 [ + + ]: 70 : if (fctx[0] <= pgstat_fetch_stat_numbackends())
261 : : {
262 : : /* do when there is more left to send */
263 : 66 : LocalPgBackendStatus *local_beentry = pgstat_get_local_beentry_by_index(fctx[0]);
264 : :
265 : 66 : SRF_RETURN_NEXT(funcctx, Int32GetDatum(local_beentry->proc_number));
266 : : }
267 : : else
268 : : {
269 : : /* do when there is no more left */
270 : 4 : SRF_RETURN_DONE(funcctx);
271 : : }
272 : : }
273 : :
274 : : /*
275 : : * Returns command progress information for the named command.
276 : : */
277 : : Datum
278 : 14 : pg_stat_get_progress_info(PG_FUNCTION_ARGS)
279 : : {
280 : : #define PG_STAT_GET_PROGRESS_COLS PGSTAT_NUM_PROGRESS_PARAM + 3
281 : 14 : int num_backends = pgstat_fetch_stat_numbackends();
282 : : int curr_backend;
283 : 14 : char *cmd = text_to_cstring(PG_GETARG_TEXT_PP(0));
284 : : ProgressCommandType cmdtype;
285 : 14 : ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
286 : :
287 : : /* Translate command name into command type code. */
288 [ + + ]: 14 : if (pg_strcasecmp(cmd, "VACUUM") == 0)
289 : 1 : cmdtype = PROGRESS_COMMAND_VACUUM;
290 [ - + ]: 13 : else if (pg_strcasecmp(cmd, "ANALYZE") == 0)
291 : 0 : cmdtype = PROGRESS_COMMAND_ANALYZE;
292 [ - + ]: 13 : else if (pg_strcasecmp(cmd, "REPACK") == 0)
293 : 0 : cmdtype = PROGRESS_COMMAND_REPACK;
294 [ - + ]: 13 : else if (pg_strcasecmp(cmd, "CREATE INDEX") == 0)
295 : 0 : cmdtype = PROGRESS_COMMAND_CREATE_INDEX;
296 [ + + ]: 13 : else if (pg_strcasecmp(cmd, "BASEBACKUP") == 0)
297 : 1 : cmdtype = PROGRESS_COMMAND_BASEBACKUP;
298 [ + - ]: 12 : else if (pg_strcasecmp(cmd, "COPY") == 0)
299 : 12 : cmdtype = PROGRESS_COMMAND_COPY;
300 [ # # ]: 0 : else if (pg_strcasecmp(cmd, "DATACHECKSUMS") == 0)
301 : 0 : cmdtype = PROGRESS_COMMAND_DATACHECKSUMS;
302 : : else
303 [ # # ]: 0 : ereport(ERROR,
304 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
305 : : errmsg("invalid command name: \"%s\"", cmd)));
306 : :
307 : 14 : InitMaterializedSRF(fcinfo, 0);
308 : :
309 : : /* 1-based index */
310 [ + + ]: 157 : for (curr_backend = 1; curr_backend <= num_backends; curr_backend++)
311 : : {
312 : : LocalPgBackendStatus *local_beentry;
313 : : PgBackendStatus *beentry;
314 : 143 : Datum values[PG_STAT_GET_PROGRESS_COLS] = {0};
315 : 143 : bool nulls[PG_STAT_GET_PROGRESS_COLS] = {0};
316 : : int i;
317 : :
318 : 143 : local_beentry = pgstat_get_local_beentry_by_index(curr_backend);
319 : 143 : beentry = &local_beentry->backendStatus;
320 : :
321 : : /*
322 : : * Report values for only those backends which are running the given
323 : : * command.
324 : : */
325 [ + + ]: 143 : if (beentry->st_progress_command != cmdtype)
326 : 129 : continue;
327 : :
328 : : /* Value available to all callers */
329 : 14 : values[0] = Int32GetDatum(beentry->st_procpid);
330 : 14 : values[1] = ObjectIdGetDatum(beentry->st_databaseid);
331 : :
332 : : /* show rest of the values including relid only to role members */
333 [ - + - - ]: 28 : if (HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
334 : : {
335 : 14 : values[2] = ObjectIdGetDatum(beentry->st_progress_command_target);
336 [ + + ]: 294 : for (i = 0; i < PGSTAT_NUM_PROGRESS_PARAM; i++)
337 : 280 : values[i + 3] = Int64GetDatum(beentry->st_progress_param[i]);
338 : : }
339 : : else
340 : : {
341 : 0 : nulls[2] = true;
342 [ # # ]: 0 : for (i = 0; i < PGSTAT_NUM_PROGRESS_PARAM; i++)
343 : 0 : nulls[i + 3] = true;
344 : : }
345 : :
346 : 14 : tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
347 : : }
348 : :
349 : 14 : return (Datum) 0;
350 : : }
351 : :
352 : : /*
353 : : * Returns activity of PG backends.
354 : : */
355 : : Datum
356 : 770 : pg_stat_get_activity(PG_FUNCTION_ARGS)
357 : : {
358 : : #define PG_STAT_GET_ACTIVITY_COLS 31
359 : 770 : int num_backends = pgstat_fetch_stat_numbackends();
360 : : int curr_backend;
361 [ + + ]: 770 : int pid = PG_ARGISNULL(0) ? -1 : PG_GETARG_INT32(0);
362 : 770 : ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
363 : :
364 : 770 : InitMaterializedSRF(fcinfo, 0);
365 : :
366 : : /* 1-based index */
367 [ + + ]: 8319 : for (curr_backend = 1; curr_backend <= num_backends; curr_backend++)
368 : : {
369 : : /* for each row */
370 : 7550 : Datum values[PG_STAT_GET_ACTIVITY_COLS] = {0};
371 : 7550 : bool nulls[PG_STAT_GET_ACTIVITY_COLS] = {0};
372 : : LocalPgBackendStatus *local_beentry;
373 : : PgBackendStatus *beentry;
374 : : PGPROC *proc;
375 : 7550 : const char *wait_event_type = NULL;
376 : 7550 : const char *wait_event = NULL;
377 : :
378 : : /* Get the next one in the list */
379 : 7550 : local_beentry = pgstat_get_local_beentry_by_index(curr_backend);
380 : 7550 : beentry = &local_beentry->backendStatus;
381 : :
382 : : /* If looking for specific PID, ignore all the others */
383 [ + + - + ]: 7550 : if (pid != -1 && beentry->st_procpid != pid)
384 : 0 : continue;
385 : :
386 : : /* Values available to all callers */
387 [ + + ]: 7550 : if (beentry->st_databaseid != InvalidOid)
388 : 1887 : values[0] = ObjectIdGetDatum(beentry->st_databaseid);
389 : : else
390 : 5663 : nulls[0] = true;
391 : :
392 : 7550 : values[1] = Int32GetDatum(beentry->st_procpid);
393 : :
394 [ + + ]: 7550 : if (beentry->st_userid != InvalidOid)
395 : 2725 : values[2] = ObjectIdGetDatum(beentry->st_userid);
396 : : else
397 : 4825 : nulls[2] = true;
398 : :
399 [ + - ]: 7550 : if (beentry->st_appname)
400 : 7550 : values[3] = CStringGetTextDatum(beentry->st_appname);
401 : : else
402 : 0 : nulls[3] = true;
403 : :
404 [ + + ]: 7550 : if (TransactionIdIsValid(local_beentry->backend_xid))
405 : 66 : values[15] = TransactionIdGetDatum(local_beentry->backend_xid);
406 : : else
407 : 7484 : nulls[15] = true;
408 : :
409 [ + + ]: 7550 : if (TransactionIdIsValid(local_beentry->backend_xmin))
410 : 984 : values[16] = TransactionIdGetDatum(local_beentry->backend_xmin);
411 : : else
412 : 6566 : nulls[16] = true;
413 : :
414 : : /* Values only available to role member or pg_read_all_stats */
415 [ + + + + ]: 7550 : if (HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
416 : 7213 : {
417 : : char *clipped_activity;
418 : :
419 [ + + + + : 7213 : switch (beentry->st_state)
- - + +
- ]
420 : : {
421 : 1 : case STATE_STARTING:
422 : 1 : values[4] = CStringGetTextDatum("starting");
423 : 1 : break;
424 : 265 : case STATE_IDLE:
425 : 265 : values[4] = CStringGetTextDatum("idle");
426 : 265 : break;
427 : 1688 : case STATE_RUNNING:
428 : 1688 : values[4] = CStringGetTextDatum("active");
429 : 1688 : break;
430 : 17 : case STATE_IDLEINTRANSACTION:
431 : 17 : values[4] = CStringGetTextDatum("idle in transaction");
432 : 17 : break;
433 : 0 : case STATE_FASTPATH:
434 : 0 : values[4] = CStringGetTextDatum("fastpath function call");
435 : 0 : break;
436 : 0 : case STATE_IDLEINTRANSACTION_ABORTED:
437 : 0 : values[4] = CStringGetTextDatum("idle in transaction (aborted)");
438 : 0 : break;
439 : 4 : case STATE_DISABLED:
440 : 4 : values[4] = CStringGetTextDatum("disabled");
441 : 4 : break;
442 : 5238 : case STATE_UNDEFINED:
443 : 5238 : nulls[4] = true;
444 : 5238 : break;
445 : : }
446 : :
447 : 7213 : clipped_activity = pgstat_clip_activity(beentry->st_activity_raw);
448 : 7213 : values[5] = CStringGetTextDatum(clipped_activity);
449 : 7213 : pfree(clipped_activity);
450 : :
451 : : /* leader_pid */
452 : 7213 : nulls[29] = true;
453 : :
454 : 7213 : proc = BackendPidGetProc(beentry->st_procpid);
455 : :
456 [ + + + - ]: 7213 : if (proc == NULL && (beentry->st_backendType != B_BACKEND))
457 : : {
458 : : /*
459 : : * For an auxiliary process, retrieve process info from
460 : : * AuxiliaryProcs stored in shared-memory.
461 : : */
462 : 3859 : proc = AuxiliaryPidGetProc(beentry->st_procpid);
463 : : }
464 : :
465 : : /*
466 : : * If a PGPROC entry was retrieved, display wait events and lock
467 : : * group leader or apply leader information if any. To avoid
468 : : * extra overhead, no extra lock is being held, so there is no
469 : : * guarantee of consistency across multiple rows.
470 : : */
471 [ + - ]: 7213 : if (proc != NULL)
472 : : {
473 : : uint32 raw_wait_event;
474 : : PGPROC *leader;
475 : :
476 : 7213 : raw_wait_event = UINT32_ACCESS_ONCE(proc->wait_event_info);
477 : 7213 : wait_event_type = pgstat_get_wait_event_type(raw_wait_event);
478 : 7213 : wait_event = pgstat_get_wait_event(raw_wait_event);
479 : :
480 : 7213 : leader = proc->lockGroupLeader;
481 : :
482 : : /*
483 : : * Show the leader only for active parallel workers. This
484 : : * leaves the field as NULL for the leader of a parallel group
485 : : * or the leader of parallel apply workers.
486 : : */
487 [ + + + + ]: 7213 : if (leader && leader->pid != beentry->st_procpid)
488 : : {
489 : 4 : values[29] = Int32GetDatum(leader->pid);
490 : 4 : nulls[29] = false;
491 : : }
492 [ + + ]: 7209 : else if (beentry->st_backendType == B_BG_WORKER)
493 : : {
494 : 778 : int leader_pid = GetLeaderApplyWorkerPid(beentry->st_procpid);
495 : :
496 [ - + ]: 778 : if (leader_pid != InvalidPid)
497 : : {
498 : 0 : values[29] = Int32GetDatum(leader_pid);
499 : 0 : nulls[29] = false;
500 : : }
501 : : }
502 : : }
503 : :
504 [ + + ]: 7213 : if (wait_event_type)
505 : 6364 : values[6] = CStringGetTextDatum(wait_event_type);
506 : : else
507 : 849 : nulls[6] = true;
508 : :
509 [ + + ]: 7213 : if (wait_event)
510 : 6364 : values[7] = CStringGetTextDatum(wait_event);
511 : : else
512 : 849 : nulls[7] = true;
513 : :
514 : : /*
515 : : * Don't expose transaction time for walsenders; it confuses
516 : : * monitoring, particularly because we don't keep the time up-to-
517 : : * date.
518 : : */
519 [ + + ]: 7213 : if (beentry->st_xact_start_timestamp != 0 &&
520 [ + + ]: 1065 : beentry->st_backendType != B_WAL_SENDER)
521 : 1062 : values[8] = TimestampTzGetDatum(beentry->st_xact_start_timestamp);
522 : : else
523 : 6151 : nulls[8] = true;
524 : :
525 [ + + ]: 7213 : if (beentry->st_activity_start_timestamp != 0)
526 : 1909 : values[9] = TimestampTzGetDatum(beentry->st_activity_start_timestamp);
527 : : else
528 : 5304 : nulls[9] = true;
529 : :
530 [ + - ]: 7213 : if (beentry->st_proc_start_timestamp != 0)
531 : 7213 : values[10] = TimestampTzGetDatum(beentry->st_proc_start_timestamp);
532 : : else
533 : 0 : nulls[10] = true;
534 : :
535 [ + + ]: 7213 : if (beentry->st_state_start_timestamp != 0)
536 : 1970 : values[11] = TimestampTzGetDatum(beentry->st_state_start_timestamp);
537 : : else
538 : 5243 : nulls[11] = true;
539 : :
540 : : /* A zeroed client addr means we don't know */
541 [ + + ]: 7213 : if (pg_memory_is_all_zeros(&beentry->st_clientaddr,
542 : : sizeof(beentry->st_clientaddr)))
543 : : {
544 : 5318 : nulls[12] = true;
545 : 5318 : nulls[13] = true;
546 : 5318 : nulls[14] = true;
547 : : }
548 : : else
549 : : {
550 [ + + ]: 1895 : if (beentry->st_clientaddr.addr.ss_family == AF_INET ||
551 [ - + ]: 1850 : beentry->st_clientaddr.addr.ss_family == AF_INET6)
552 : 45 : {
553 : : char remote_host[NI_MAXHOST];
554 : : char remote_port[NI_MAXSERV];
555 : : int ret;
556 : :
557 : 45 : remote_host[0] = '\0';
558 : 45 : remote_port[0] = '\0';
559 : 45 : ret = pg_getnameinfo_all(&beentry->st_clientaddr.addr,
560 : 45 : beentry->st_clientaddr.salen,
561 : : remote_host, sizeof(remote_host),
562 : : remote_port, sizeof(remote_port),
563 : : NI_NUMERICHOST | NI_NUMERICSERV);
564 [ + - ]: 45 : if (ret == 0)
565 : : {
566 : 45 : clean_ipv6_addr(beentry->st_clientaddr.addr.ss_family, remote_host);
567 : 45 : values[12] = DirectFunctionCall1(inet_in,
568 : : CStringGetDatum(remote_host));
569 [ + - ]: 45 : if (beentry->st_clienthostname &&
570 [ + + ]: 45 : beentry->st_clienthostname[0])
571 : 7 : values[13] = CStringGetTextDatum(beentry->st_clienthostname);
572 : : else
573 : 38 : nulls[13] = true;
574 : 45 : values[14] = Int32GetDatum(atoi(remote_port));
575 : : }
576 : : else
577 : : {
578 : 0 : nulls[12] = true;
579 : 0 : nulls[13] = true;
580 : 0 : nulls[14] = true;
581 : : }
582 : : }
583 [ + - ]: 1850 : else if (beentry->st_clientaddr.addr.ss_family == AF_UNIX)
584 : : {
585 : : /*
586 : : * Unix sockets always reports NULL for host and -1 for
587 : : * port, so it's possible to tell the difference to
588 : : * connections we have no permissions to view, or with
589 : : * errors.
590 : : */
591 : 1850 : nulls[12] = true;
592 : 1850 : nulls[13] = true;
593 : 1850 : values[14] = Int32GetDatum(-1);
594 : : }
595 : : else
596 : : {
597 : : /* Unknown address type, should never happen */
598 : 0 : nulls[12] = true;
599 : 0 : nulls[13] = true;
600 : 0 : nulls[14] = true;
601 : : }
602 : : }
603 : : /* Add backend type */
604 [ + + ]: 7213 : if (beentry->st_backendType == B_BG_WORKER)
605 : : {
606 : : const char *bgw_type;
607 : :
608 : 782 : bgw_type = GetBackgroundWorkerTypeByPid(beentry->st_procpid);
609 [ + - ]: 782 : if (bgw_type)
610 : 782 : values[17] = CStringGetTextDatum(bgw_type);
611 : : else
612 : 0 : nulls[17] = true;
613 : : }
614 : : else
615 : 6431 : values[17] =
616 : 6431 : CStringGetTextDatum(GetBackendTypeDesc(beentry->st_backendType));
617 : :
618 : : /* SSL information */
619 [ + + ]: 7213 : if (beentry->st_ssl)
620 : : {
621 : 21 : values[18] = BoolGetDatum(true); /* ssl */
622 : 21 : values[19] = CStringGetTextDatum(beentry->st_sslstatus->ssl_version);
623 : 21 : values[20] = CStringGetTextDatum(beentry->st_sslstatus->ssl_cipher);
624 : 21 : values[21] = Int32GetDatum(beentry->st_sslstatus->ssl_bits);
625 : :
626 [ + + ]: 21 : if (beentry->st_sslstatus->ssl_client_dn[0])
627 : 6 : values[22] = CStringGetTextDatum(beentry->st_sslstatus->ssl_client_dn);
628 : : else
629 : 15 : nulls[22] = true;
630 : :
631 [ + + ]: 21 : if (beentry->st_sslstatus->ssl_client_serial[0])
632 : 6 : values[23] = DirectFunctionCall3(numeric_in,
633 : : CStringGetDatum(beentry->st_sslstatus->ssl_client_serial),
634 : : ObjectIdGetDatum(InvalidOid),
635 : : Int32GetDatum(-1));
636 : : else
637 : 15 : nulls[23] = true;
638 : :
639 [ + + ]: 21 : if (beentry->st_sslstatus->ssl_issuer_dn[0])
640 : 6 : values[24] = CStringGetTextDatum(beentry->st_sslstatus->ssl_issuer_dn);
641 : : else
642 : 15 : nulls[24] = true;
643 : : }
644 : : else
645 : : {
646 : 7192 : values[18] = BoolGetDatum(false); /* ssl */
647 : 7192 : nulls[19] = nulls[20] = nulls[21] = nulls[22] = nulls[23] = nulls[24] = true;
648 : : }
649 : :
650 : : /* GSSAPI information */
651 [ - + ]: 7213 : if (beentry->st_gss)
652 : : {
653 : 0 : values[25] = BoolGetDatum(beentry->st_gssstatus->gss_auth); /* gss_auth */
654 : 0 : values[26] = CStringGetTextDatum(beentry->st_gssstatus->gss_princ);
655 : 0 : values[27] = BoolGetDatum(beentry->st_gssstatus->gss_enc); /* GSS Encryption in use */
656 : 0 : values[28] = BoolGetDatum(beentry->st_gssstatus->gss_delegation); /* GSS credentials
657 : : * delegated */
658 : : }
659 : : else
660 : : {
661 : 7213 : values[25] = BoolGetDatum(false); /* gss_auth */
662 : 7213 : nulls[26] = true; /* No GSS principal */
663 : 7213 : values[27] = BoolGetDatum(false); /* GSS Encryption not in
664 : : * use */
665 : 7213 : values[28] = BoolGetDatum(false); /* GSS credentials not
666 : : * delegated */
667 : : }
668 [ + + ]: 7213 : if (beentry->st_query_id == INT64CONST(0))
669 : 7155 : nulls[30] = true;
670 : : else
671 : 58 : values[30] = Int64GetDatum(beentry->st_query_id);
672 : : }
673 : : else
674 : : {
675 : : /* No permissions to view data about this session */
676 : 337 : values[5] = CStringGetTextDatum("<insufficient privilege>");
677 : 337 : nulls[4] = true;
678 : 337 : nulls[6] = true;
679 : 337 : nulls[7] = true;
680 : 337 : nulls[8] = true;
681 : 337 : nulls[9] = true;
682 : 337 : nulls[10] = true;
683 : 337 : nulls[11] = true;
684 : 337 : nulls[12] = true;
685 : 337 : nulls[13] = true;
686 : 337 : nulls[14] = true;
687 : 337 : nulls[17] = true;
688 : 337 : nulls[18] = true;
689 : 337 : nulls[19] = true;
690 : 337 : nulls[20] = true;
691 : 337 : nulls[21] = true;
692 : 337 : nulls[22] = true;
693 : 337 : nulls[23] = true;
694 : 337 : nulls[24] = true;
695 : 337 : nulls[25] = true;
696 : 337 : nulls[26] = true;
697 : 337 : nulls[27] = true;
698 : 337 : nulls[28] = true;
699 : 337 : nulls[29] = true;
700 : 337 : nulls[30] = true;
701 : : }
702 : :
703 : 7550 : tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
704 : :
705 : : /* If only a single backend was requested, and we found it, break. */
706 [ + + ]: 7550 : if (pid != -1)
707 : 1 : break;
708 : : }
709 : :
710 : 770 : return (Datum) 0;
711 : : }
712 : :
713 : :
714 : : Datum
715 : 996 : pg_backend_pid(PG_FUNCTION_ARGS)
716 : : {
717 : 996 : PG_RETURN_INT32(MyProcPid);
718 : : }
719 : :
720 : :
721 : : Datum
722 : 66 : pg_stat_get_backend_pid(PG_FUNCTION_ARGS)
723 : : {
724 : 66 : int32 procNumber = PG_GETARG_INT32(0);
725 : : PgBackendStatus *beentry;
726 : :
727 [ - + ]: 66 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
728 : 0 : PG_RETURN_NULL();
729 : :
730 : 66 : PG_RETURN_INT32(beentry->st_procpid);
731 : : }
732 : :
733 : :
734 : : Datum
735 : 0 : pg_stat_get_backend_dbid(PG_FUNCTION_ARGS)
736 : : {
737 : 0 : int32 procNumber = PG_GETARG_INT32(0);
738 : : PgBackendStatus *beentry;
739 : :
740 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
741 : 0 : PG_RETURN_NULL();
742 : :
743 : 0 : PG_RETURN_OID(beentry->st_databaseid);
744 : : }
745 : :
746 : :
747 : : Datum
748 : 0 : pg_stat_get_backend_userid(PG_FUNCTION_ARGS)
749 : : {
750 : 0 : int32 procNumber = PG_GETARG_INT32(0);
751 : : PgBackendStatus *beentry;
752 : :
753 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
754 : 0 : PG_RETURN_NULL();
755 : :
756 : 0 : PG_RETURN_OID(beentry->st_userid);
757 : : }
758 : :
759 : : Datum
760 : 0 : pg_stat_get_backend_subxact(PG_FUNCTION_ARGS)
761 : : {
762 : : #define PG_STAT_GET_SUBXACT_COLS 2
763 : : TupleDesc tupdesc;
764 : 0 : Datum values[PG_STAT_GET_SUBXACT_COLS] = {0};
765 : 0 : bool nulls[PG_STAT_GET_SUBXACT_COLS] = {0};
766 : 0 : int32 procNumber = PG_GETARG_INT32(0);
767 : : LocalPgBackendStatus *local_beentry;
768 : :
769 : : /* Initialise attributes information in the tuple descriptor */
770 : 0 : tupdesc = CreateTemplateTupleDesc(PG_STAT_GET_SUBXACT_COLS);
771 : 0 : TupleDescInitEntry(tupdesc, (AttrNumber) 1, "subxact_count",
772 : : INT4OID, -1, 0);
773 : 0 : TupleDescInitEntry(tupdesc, (AttrNumber) 2, "subxact_overflow",
774 : : BOOLOID, -1, 0);
775 : :
776 : 0 : TupleDescFinalize(tupdesc);
777 : 0 : BlessTupleDesc(tupdesc);
778 : :
779 [ # # ]: 0 : if ((local_beentry = pgstat_get_local_beentry_by_proc_number(procNumber)) != NULL)
780 : : {
781 : : /* Fill values and NULLs */
782 : 0 : values[0] = Int32GetDatum(local_beentry->backend_subxact_count);
783 : 0 : values[1] = BoolGetDatum(local_beentry->backend_subxact_overflowed);
784 : : }
785 : : else
786 : : {
787 : 0 : nulls[0] = true;
788 : 0 : nulls[1] = true;
789 : : }
790 : :
791 : : /* Returns the record as Datum */
792 : 0 : PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
793 : : }
794 : :
795 : : Datum
796 : 0 : pg_stat_get_backend_activity(PG_FUNCTION_ARGS)
797 : : {
798 : 0 : int32 procNumber = PG_GETARG_INT32(0);
799 : : PgBackendStatus *beentry;
800 : : const char *activity;
801 : : char *clipped_activity;
802 : : text *ret;
803 : :
804 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
805 : 0 : activity = "<backend information not available>";
806 [ # # # # ]: 0 : else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
807 : 0 : activity = "<insufficient privilege>";
808 [ # # ]: 0 : else if (*(beentry->st_activity_raw) == '\0')
809 : 0 : activity = "<command string not enabled>";
810 : : else
811 : 0 : activity = beentry->st_activity_raw;
812 : :
813 : 0 : clipped_activity = pgstat_clip_activity(activity);
814 : 0 : ret = cstring_to_text(clipped_activity);
815 : 0 : pfree(clipped_activity);
816 : :
817 : 0 : PG_RETURN_TEXT_P(ret);
818 : : }
819 : :
820 : : Datum
821 : 0 : pg_stat_get_backend_wait_event_type(PG_FUNCTION_ARGS)
822 : : {
823 : 0 : int32 procNumber = PG_GETARG_INT32(0);
824 : : PgBackendStatus *beentry;
825 : : PGPROC *proc;
826 : 0 : const char *wait_event_type = NULL;
827 : :
828 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
829 : 0 : wait_event_type = "<backend information not available>";
830 [ # # # # ]: 0 : else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
831 : 0 : wait_event_type = "<insufficient privilege>";
832 : : else
833 : : {
834 : 0 : proc = BackendPidGetProc(beentry->st_procpid);
835 [ # # ]: 0 : if (!proc)
836 : 0 : proc = AuxiliaryPidGetProc(beentry->st_procpid);
837 [ # # ]: 0 : if (proc)
838 : 0 : wait_event_type = pgstat_get_wait_event_type(proc->wait_event_info);
839 : : }
840 : :
841 [ # # ]: 0 : if (!wait_event_type)
842 : 0 : PG_RETURN_NULL();
843 : :
844 : 0 : PG_RETURN_TEXT_P(cstring_to_text(wait_event_type));
845 : : }
846 : :
847 : : Datum
848 : 0 : pg_stat_get_backend_wait_event(PG_FUNCTION_ARGS)
849 : : {
850 : 0 : int32 procNumber = PG_GETARG_INT32(0);
851 : : PgBackendStatus *beentry;
852 : : PGPROC *proc;
853 : 0 : const char *wait_event = NULL;
854 : :
855 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
856 : 0 : wait_event = "<backend information not available>";
857 [ # # # # ]: 0 : else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
858 : 0 : wait_event = "<insufficient privilege>";
859 : : else
860 : : {
861 : 0 : proc = BackendPidGetProc(beentry->st_procpid);
862 [ # # ]: 0 : if (!proc)
863 : 0 : proc = AuxiliaryPidGetProc(beentry->st_procpid);
864 [ # # ]: 0 : if (proc)
865 : 0 : wait_event = pgstat_get_wait_event(proc->wait_event_info);
866 : : }
867 : :
868 [ # # ]: 0 : if (!wait_event)
869 : 0 : PG_RETURN_NULL();
870 : :
871 : 0 : PG_RETURN_TEXT_P(cstring_to_text(wait_event));
872 : : }
873 : :
874 : :
875 : : Datum
876 : 0 : pg_stat_get_backend_activity_start(PG_FUNCTION_ARGS)
877 : : {
878 : 0 : int32 procNumber = PG_GETARG_INT32(0);
879 : : TimestampTz result;
880 : : PgBackendStatus *beentry;
881 : :
882 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
883 : 0 : PG_RETURN_NULL();
884 : :
885 [ # # # # ]: 0 : else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
886 : 0 : PG_RETURN_NULL();
887 : :
888 : 0 : result = beentry->st_activity_start_timestamp;
889 : :
890 : : /*
891 : : * No time recorded for start of current query -- this is the case if the
892 : : * user hasn't enabled query-level stats collection.
893 : : */
894 [ # # ]: 0 : if (result == 0)
895 : 0 : PG_RETURN_NULL();
896 : :
897 : 0 : PG_RETURN_TIMESTAMPTZ(result);
898 : : }
899 : :
900 : :
901 : : Datum
902 : 0 : pg_stat_get_backend_xact_start(PG_FUNCTION_ARGS)
903 : : {
904 : 0 : int32 procNumber = PG_GETARG_INT32(0);
905 : : TimestampTz result;
906 : : PgBackendStatus *beentry;
907 : :
908 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
909 : 0 : PG_RETURN_NULL();
910 : :
911 [ # # # # ]: 0 : else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
912 : 0 : PG_RETURN_NULL();
913 : :
914 : 0 : result = beentry->st_xact_start_timestamp;
915 : :
916 [ # # ]: 0 : if (result == 0) /* not in a transaction */
917 : 0 : PG_RETURN_NULL();
918 : :
919 : 0 : PG_RETURN_TIMESTAMPTZ(result);
920 : : }
921 : :
922 : :
923 : : Datum
924 : 0 : pg_stat_get_backend_start(PG_FUNCTION_ARGS)
925 : : {
926 : 0 : int32 procNumber = PG_GETARG_INT32(0);
927 : : TimestampTz result;
928 : : PgBackendStatus *beentry;
929 : :
930 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
931 : 0 : PG_RETURN_NULL();
932 : :
933 [ # # # # ]: 0 : else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
934 : 0 : PG_RETURN_NULL();
935 : :
936 : 0 : result = beentry->st_proc_start_timestamp;
937 : :
938 [ # # ]: 0 : if (result == 0) /* probably can't happen? */
939 : 0 : PG_RETURN_NULL();
940 : :
941 : 0 : PG_RETURN_TIMESTAMPTZ(result);
942 : : }
943 : :
944 : :
945 : : Datum
946 : 0 : pg_stat_get_backend_client_addr(PG_FUNCTION_ARGS)
947 : : {
948 : 0 : int32 procNumber = PG_GETARG_INT32(0);
949 : : PgBackendStatus *beentry;
950 : : char remote_host[NI_MAXHOST];
951 : : int ret;
952 : :
953 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
954 : 0 : PG_RETURN_NULL();
955 : :
956 [ # # # # ]: 0 : else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
957 : 0 : PG_RETURN_NULL();
958 : :
959 : : /* A zeroed client addr means we don't know */
960 [ # # ]: 0 : if (pg_memory_is_all_zeros(&beentry->st_clientaddr,
961 : : sizeof(beentry->st_clientaddr)))
962 : 0 : PG_RETURN_NULL();
963 : :
964 [ # # ]: 0 : switch (beentry->st_clientaddr.addr.ss_family)
965 : : {
966 : 0 : case AF_INET:
967 : : case AF_INET6:
968 : 0 : break;
969 : 0 : default:
970 : 0 : PG_RETURN_NULL();
971 : : }
972 : :
973 : 0 : remote_host[0] = '\0';
974 : 0 : ret = pg_getnameinfo_all(&beentry->st_clientaddr.addr,
975 : 0 : beentry->st_clientaddr.salen,
976 : : remote_host, sizeof(remote_host),
977 : : NULL, 0,
978 : : NI_NUMERICHOST | NI_NUMERICSERV);
979 [ # # ]: 0 : if (ret != 0)
980 : 0 : PG_RETURN_NULL();
981 : :
982 : 0 : clean_ipv6_addr(beentry->st_clientaddr.addr.ss_family, remote_host);
983 : :
984 : 0 : PG_RETURN_DATUM(DirectFunctionCall1(inet_in,
985 : : CStringGetDatum(remote_host)));
986 : : }
987 : :
988 : : Datum
989 : 0 : pg_stat_get_backend_client_port(PG_FUNCTION_ARGS)
990 : : {
991 : 0 : int32 procNumber = PG_GETARG_INT32(0);
992 : : PgBackendStatus *beentry;
993 : : char remote_port[NI_MAXSERV];
994 : : int ret;
995 : :
996 [ # # ]: 0 : if ((beentry = pgstat_get_beentry_by_proc_number(procNumber)) == NULL)
997 : 0 : PG_RETURN_NULL();
998 : :
999 [ # # # # ]: 0 : else if (!HAS_PGSTAT_PERMISSIONS(beentry->st_userid))
1000 : 0 : PG_RETURN_NULL();
1001 : :
1002 : : /* A zeroed client addr means we don't know */
1003 [ # # ]: 0 : if (pg_memory_is_all_zeros(&beentry->st_clientaddr,
1004 : : sizeof(beentry->st_clientaddr)))
1005 : 0 : PG_RETURN_NULL();
1006 : :
1007 [ # # # ]: 0 : switch (beentry->st_clientaddr.addr.ss_family)
1008 : : {
1009 : 0 : case AF_INET:
1010 : : case AF_INET6:
1011 : 0 : break;
1012 : 0 : case AF_UNIX:
1013 : 0 : PG_RETURN_INT32(-1);
1014 : 0 : default:
1015 : 0 : PG_RETURN_NULL();
1016 : : }
1017 : :
1018 : 0 : remote_port[0] = '\0';
1019 : 0 : ret = pg_getnameinfo_all(&beentry->st_clientaddr.addr,
1020 : 0 : beentry->st_clientaddr.salen,
1021 : : NULL, 0,
1022 : : remote_port, sizeof(remote_port),
1023 : : NI_NUMERICHOST | NI_NUMERICSERV);
1024 [ # # ]: 0 : if (ret != 0)
1025 : 0 : PG_RETURN_NULL();
1026 : :
1027 : 0 : PG_RETURN_DATUM(DirectFunctionCall1(int4in,
1028 : : CStringGetDatum(remote_port)));
1029 : : }
1030 : :
1031 : :
1032 : : Datum
1033 : 0 : pg_stat_get_db_numbackends(PG_FUNCTION_ARGS)
1034 : : {
1035 : 0 : Oid dbid = PG_GETARG_OID(0);
1036 : : int32 result;
1037 : 0 : int tot_backends = pgstat_fetch_stat_numbackends();
1038 : : int idx;
1039 : :
1040 : 0 : result = 0;
1041 [ # # ]: 0 : for (idx = 1; idx <= tot_backends; idx++)
1042 : : {
1043 : 0 : LocalPgBackendStatus *local_beentry = pgstat_get_local_beentry_by_index(idx);
1044 : :
1045 [ # # ]: 0 : if (local_beentry->backendStatus.st_databaseid == dbid)
1046 : 0 : result++;
1047 : : }
1048 : :
1049 : 0 : PG_RETURN_INT32(result);
1050 : : }
1051 : :
1052 : :
1053 : : #define PG_STAT_GET_DBENTRY_INT64(stat) \
1054 : : Datum \
1055 : : CppConcat(pg_stat_get_db_,stat)(PG_FUNCTION_ARGS) \
1056 : : { \
1057 : : Oid dbid = PG_GETARG_OID(0); \
1058 : : int64 result; \
1059 : : PgStat_StatDBEntry *dbentry; \
1060 : : \
1061 : : if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL) \
1062 : : result = 0; \
1063 : : else \
1064 : : result = (int64) (dbentry->stat); \
1065 : : \
1066 : : PG_RETURN_INT64(result); \
1067 : : }
1068 : :
1069 : : /* pg_stat_get_db_blocks_fetched */
1070 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(blocks_fetched)
1071 : :
1072 : : /* pg_stat_get_db_blocks_hit */
1073 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(blocks_hit)
1074 : :
1075 : : /* pg_stat_get_db_conflict_bufferpin */
1076 [ - + ]: 1 : PG_STAT_GET_DBENTRY_INT64(conflict_bufferpin)
1077 : :
1078 : : /* pg_stat_get_db_conflict_lock */
1079 [ - + ]: 1 : PG_STAT_GET_DBENTRY_INT64(conflict_lock)
1080 : :
1081 : : /* pg_stat_get_db_conflict_snapshot */
1082 [ - + ]: 1 : PG_STAT_GET_DBENTRY_INT64(conflict_snapshot)
1083 : :
1084 : : /* pg_stat_get_db_conflict_startup_deadlock */
1085 [ - + ]: 1 : PG_STAT_GET_DBENTRY_INT64(conflict_startup_deadlock)
1086 : :
1087 : : /* pg_stat_get_db_conflict_tablespace */
1088 [ - + ]: 1 : PG_STAT_GET_DBENTRY_INT64(conflict_tablespace)
1089 : :
1090 : : /* pg_stat_get_db_deadlocks */
1091 [ - + ]: 1 : PG_STAT_GET_DBENTRY_INT64(deadlocks)
1092 : :
1093 : : /* pg_stat_get_db_sessions */
1094 [ - + ]: 8 : PG_STAT_GET_DBENTRY_INT64(sessions)
1095 : :
1096 : : /* pg_stat_get_db_sessions_abandoned */
1097 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(sessions_abandoned)
1098 : :
1099 : : /* pg_stat_get_db_sessions_fatal */
1100 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(sessions_fatal)
1101 : :
1102 : : /* pg_stat_get_db_sessions_killed */
1103 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(sessions_killed)
1104 : :
1105 : : /* pg_stat_get_db_parallel_workers_to_launch */
1106 [ - + ]: 8 : PG_STAT_GET_DBENTRY_INT64(parallel_workers_to_launch)
1107 : :
1108 : : /* pg_stat_get_db_parallel_workers_launched */
1109 [ - + ]: 8 : PG_STAT_GET_DBENTRY_INT64(parallel_workers_launched)
1110 : :
1111 : : /* pg_stat_get_db_temp_bytes */
1112 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(temp_bytes)
1113 : :
1114 : : /* pg_stat_get_db_temp_files */
1115 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(temp_files)
1116 : :
1117 : : /* pg_stat_get_db_tuples_deleted */
1118 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(tuples_deleted)
1119 : :
1120 : : /* pg_stat_get_db_tuples_fetched */
1121 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(tuples_fetched)
1122 : :
1123 : : /* pg_stat_get_db_tuples_inserted */
1124 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(tuples_inserted)
1125 : :
1126 : : /* pg_stat_get_db_tuples_returned */
1127 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(tuples_returned)
1128 : :
1129 : : /* pg_stat_get_db_tuples_updated */
1130 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(tuples_updated)
1131 : :
1132 : : /* pg_stat_get_db_xact_commit */
1133 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(xact_commit)
1134 : :
1135 : : /* pg_stat_get_db_xact_rollback */
1136 [ # # ]: 0 : PG_STAT_GET_DBENTRY_INT64(xact_rollback)
1137 : :
1138 : : /* pg_stat_get_db_conflict_logicalslot */
1139 [ - + ]: 6 : PG_STAT_GET_DBENTRY_INT64(conflict_logicalslot)
1140 : :
1141 : : Datum
1142 : 24 : pg_stat_get_db_stat_reset_time(PG_FUNCTION_ARGS)
1143 : : {
1144 : 24 : Oid dbid = PG_GETARG_OID(0);
1145 : : TimestampTz result;
1146 : : PgStat_StatDBEntry *dbentry;
1147 : :
1148 [ - + ]: 24 : if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
1149 : 0 : result = 0;
1150 : : else
1151 : 24 : result = dbentry->stat_reset_timestamp;
1152 : :
1153 [ - + ]: 24 : if (result == 0)
1154 : 0 : PG_RETURN_NULL();
1155 : : else
1156 : 24 : PG_RETURN_TIMESTAMPTZ(result);
1157 : : }
1158 : :
1159 : :
1160 : : Datum
1161 : 1 : pg_stat_get_db_conflict_all(PG_FUNCTION_ARGS)
1162 : : {
1163 : 1 : Oid dbid = PG_GETARG_OID(0);
1164 : : int64 result;
1165 : : PgStat_StatDBEntry *dbentry;
1166 : :
1167 [ - + ]: 1 : if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
1168 : 0 : result = 0;
1169 : : else
1170 : 1 : result = (int64) (dbentry->conflict_tablespace +
1171 : 1 : dbentry->conflict_lock +
1172 : 1 : dbentry->conflict_snapshot +
1173 : 1 : dbentry->conflict_logicalslot +
1174 : 1 : dbentry->conflict_bufferpin +
1175 : 1 : dbentry->conflict_startup_deadlock);
1176 : :
1177 : 1 : PG_RETURN_INT64(result);
1178 : : }
1179 : :
1180 : : Datum
1181 : 16 : pg_stat_get_db_checksum_failures(PG_FUNCTION_ARGS)
1182 : : {
1183 : 16 : Oid dbid = PG_GETARG_OID(0);
1184 : : int64 result;
1185 : : PgStat_StatDBEntry *dbentry;
1186 : :
1187 [ - + ]: 16 : if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
1188 : 0 : result = 0;
1189 : : else
1190 : 16 : result = (int64) (dbentry->checksum_failures);
1191 : :
1192 : 16 : PG_RETURN_INT64(result);
1193 : : }
1194 : :
1195 : : Datum
1196 : 16 : pg_stat_get_db_checksum_last_failure(PG_FUNCTION_ARGS)
1197 : : {
1198 : 16 : Oid dbid = PG_GETARG_OID(0);
1199 : : TimestampTz result;
1200 : : PgStat_StatDBEntry *dbentry;
1201 : :
1202 [ - + ]: 16 : if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL)
1203 : 0 : result = 0;
1204 : : else
1205 : 16 : result = dbentry->last_checksum_failure;
1206 : :
1207 [ + + ]: 16 : if (result == 0)
1208 : 6 : PG_RETURN_NULL();
1209 : : else
1210 : 10 : PG_RETURN_TIMESTAMPTZ(result);
1211 : : }
1212 : :
1213 : : /* convert counter from microsec to millisec for display */
1214 : : #define PG_STAT_GET_DBENTRY_FLOAT8_MS(stat) \
1215 : : Datum \
1216 : : CppConcat(pg_stat_get_db_,stat)(PG_FUNCTION_ARGS) \
1217 : : { \
1218 : : Oid dbid = PG_GETARG_OID(0); \
1219 : : double result; \
1220 : : PgStat_StatDBEntry *dbentry; \
1221 : : \
1222 : : if ((dbentry = pgstat_fetch_stat_dbentry(dbid)) == NULL) \
1223 : : result = 0; \
1224 : : else \
1225 : : result = ((double) dbentry->stat) / 1000.0; \
1226 : : \
1227 : : PG_RETURN_FLOAT8(result); \
1228 : : }
1229 : :
1230 : : /* pg_stat_get_db_active_time */
1231 [ # # ]: 0 : PG_STAT_GET_DBENTRY_FLOAT8_MS(active_time)
1232 : :
1233 : : /* pg_stat_get_db_blk_read_time */
1234 [ # # ]: 0 : PG_STAT_GET_DBENTRY_FLOAT8_MS(blk_read_time)
1235 : :
1236 : : /* pg_stat_get_db_blk_write_time */
1237 [ # # ]: 0 : PG_STAT_GET_DBENTRY_FLOAT8_MS(blk_write_time)
1238 : :
1239 : : /* pg_stat_get_db_idle_in_transaction_time */
1240 [ # # ]: 0 : PG_STAT_GET_DBENTRY_FLOAT8_MS(idle_in_transaction_time)
1241 : :
1242 : : /* pg_stat_get_db_session_time */
1243 [ # # ]: 0 : PG_STAT_GET_DBENTRY_FLOAT8_MS(session_time)
1244 : :
1245 : : Datum
1246 : 4 : pg_stat_get_checkpointer_num_timed(PG_FUNCTION_ARGS)
1247 : : {
1248 : 4 : PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->num_timed);
1249 : : }
1250 : :
1251 : : Datum
1252 : 12 : pg_stat_get_checkpointer_num_requested(PG_FUNCTION_ARGS)
1253 : : {
1254 : 12 : PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->num_requested);
1255 : : }
1256 : :
1257 : : Datum
1258 : 0 : pg_stat_get_checkpointer_num_performed(PG_FUNCTION_ARGS)
1259 : : {
1260 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->num_performed);
1261 : : }
1262 : :
1263 : : Datum
1264 : 0 : pg_stat_get_checkpointer_restartpoints_timed(PG_FUNCTION_ARGS)
1265 : : {
1266 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->restartpoints_timed);
1267 : : }
1268 : :
1269 : : Datum
1270 : 0 : pg_stat_get_checkpointer_restartpoints_requested(PG_FUNCTION_ARGS)
1271 : : {
1272 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->restartpoints_requested);
1273 : : }
1274 : :
1275 : : Datum
1276 : 0 : pg_stat_get_checkpointer_restartpoints_performed(PG_FUNCTION_ARGS)
1277 : : {
1278 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->restartpoints_performed);
1279 : : }
1280 : :
1281 : : Datum
1282 : 0 : pg_stat_get_checkpointer_buffers_written(PG_FUNCTION_ARGS)
1283 : : {
1284 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->buffers_written);
1285 : : }
1286 : :
1287 : : Datum
1288 : 0 : pg_stat_get_checkpointer_slru_written(PG_FUNCTION_ARGS)
1289 : : {
1290 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_checkpointer()->slru_written);
1291 : : }
1292 : :
1293 : : Datum
1294 : 0 : pg_stat_get_bgwriter_buf_written_clean(PG_FUNCTION_ARGS)
1295 : : {
1296 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_bgwriter()->buf_written_clean);
1297 : : }
1298 : :
1299 : : Datum
1300 : 0 : pg_stat_get_bgwriter_maxwritten_clean(PG_FUNCTION_ARGS)
1301 : : {
1302 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_bgwriter()->maxwritten_clean);
1303 : : }
1304 : :
1305 : : Datum
1306 : 0 : pg_stat_get_checkpointer_write_time(PG_FUNCTION_ARGS)
1307 : : {
1308 : : /* time is already in msec, just convert to double for presentation */
1309 : 0 : PG_RETURN_FLOAT8((double)
1310 : : pgstat_fetch_stat_checkpointer()->write_time);
1311 : : }
1312 : :
1313 : : Datum
1314 : 0 : pg_stat_get_checkpointer_sync_time(PG_FUNCTION_ARGS)
1315 : : {
1316 : : /* time is already in msec, just convert to double for presentation */
1317 : 0 : PG_RETURN_FLOAT8((double)
1318 : : pgstat_fetch_stat_checkpointer()->sync_time);
1319 : : }
1320 : :
1321 : : Datum
1322 : 12 : pg_stat_get_checkpointer_stat_reset_time(PG_FUNCTION_ARGS)
1323 : : {
1324 : 12 : PG_RETURN_TIMESTAMPTZ(pgstat_fetch_stat_checkpointer()->stat_reset_timestamp);
1325 : : }
1326 : :
1327 : : Datum
1328 : 8 : pg_stat_get_bgwriter_stat_reset_time(PG_FUNCTION_ARGS)
1329 : : {
1330 : 8 : PG_RETURN_TIMESTAMPTZ(pgstat_fetch_stat_bgwriter()->stat_reset_timestamp);
1331 : : }
1332 : :
1333 : : Datum
1334 : 0 : pg_stat_get_buf_alloc(PG_FUNCTION_ARGS)
1335 : : {
1336 : 0 : PG_RETURN_INT64(pgstat_fetch_stat_bgwriter()->buf_alloc);
1337 : : }
1338 : :
1339 : : /*
1340 : : * When adding a new column to the pg_stat_io view and the
1341 : : * pg_stat_get_backend_io() function, add a new enum value here above
1342 : : * IO_NUM_COLUMNS.
1343 : : */
1344 : : typedef enum io_stat_col
1345 : : {
1346 : : IO_COL_INVALID = -1,
1347 : : IO_COL_BACKEND_TYPE,
1348 : : IO_COL_OBJECT,
1349 : : IO_COL_CONTEXT,
1350 : : IO_COL_READS,
1351 : : IO_COL_READ_BYTES,
1352 : : IO_COL_READ_TIME,
1353 : : IO_COL_WRITES,
1354 : : IO_COL_WRITE_BYTES,
1355 : : IO_COL_WRITE_TIME,
1356 : : IO_COL_WRITEBACKS,
1357 : : IO_COL_WRITEBACK_TIME,
1358 : : IO_COL_EXTENDS,
1359 : : IO_COL_EXTEND_BYTES,
1360 : : IO_COL_EXTEND_TIME,
1361 : : IO_COL_HITS,
1362 : : IO_COL_EVICTIONS,
1363 : : IO_COL_REUSES,
1364 : : IO_COL_FSYNCS,
1365 : : IO_COL_FSYNC_TIME,
1366 : : IO_COL_RESET_TIME,
1367 : : IO_NUM_COLUMNS,
1368 : : } io_stat_col;
1369 : :
1370 : : /*
1371 : : * When adding a new IOOp, add a new io_stat_col and add a case to this
1372 : : * function returning the corresponding io_stat_col.
1373 : : */
1374 : : static io_stat_col
1375 : 73232 : pgstat_get_io_op_index(IOOp io_op)
1376 : : {
1377 [ + + + + : 73232 : switch (io_op)
+ + + +
- ]
1378 : : {
1379 : 9154 : case IOOP_EVICT:
1380 : 9154 : return IO_COL_EVICTIONS;
1381 : 9154 : case IOOP_EXTEND:
1382 : 9154 : return IO_COL_EXTENDS;
1383 : 9154 : case IOOP_FSYNC:
1384 : 9154 : return IO_COL_FSYNCS;
1385 : 9154 : case IOOP_HIT:
1386 : 9154 : return IO_COL_HITS;
1387 : 9154 : case IOOP_READ:
1388 : 9154 : return IO_COL_READS;
1389 : 9154 : case IOOP_REUSE:
1390 : 9154 : return IO_COL_REUSES;
1391 : 9154 : case IOOP_WRITE:
1392 : 9154 : return IO_COL_WRITES;
1393 : 9154 : case IOOP_WRITEBACK:
1394 : 9154 : return IO_COL_WRITEBACKS;
1395 : : }
1396 : :
1397 [ # # ]: 0 : elog(ERROR, "unrecognized IOOp value: %d", io_op);
1398 : : pg_unreachable();
1399 : : }
1400 : :
1401 : : /*
1402 : : * Get the number of the column containing IO bytes for the specified IOOp.
1403 : : * If an IOOp is not tracked in bytes, IO_COL_INVALID is returned.
1404 : : */
1405 : : static io_stat_col
1406 : 73232 : pgstat_get_io_byte_index(IOOp io_op)
1407 : : {
1408 [ + + + + : 73232 : switch (io_op)
- ]
1409 : : {
1410 : 9154 : case IOOP_EXTEND:
1411 : 9154 : return IO_COL_EXTEND_BYTES;
1412 : 9154 : case IOOP_READ:
1413 : 9154 : return IO_COL_READ_BYTES;
1414 : 9154 : case IOOP_WRITE:
1415 : 9154 : return IO_COL_WRITE_BYTES;
1416 : 45770 : case IOOP_EVICT:
1417 : : case IOOP_FSYNC:
1418 : : case IOOP_HIT:
1419 : : case IOOP_REUSE:
1420 : : case IOOP_WRITEBACK:
1421 : 45770 : return IO_COL_INVALID;
1422 : : }
1423 : :
1424 [ # # ]: 0 : elog(ERROR, "unrecognized IOOp value: %d", io_op);
1425 : : pg_unreachable();
1426 : : }
1427 : :
1428 : : /*
1429 : : * Get the number of the column containing IO times for the specified IOOp.
1430 : : * If an op has no associated time, IO_COL_INVALID is returned.
1431 : : */
1432 : : static io_stat_col
1433 : 73232 : pgstat_get_io_time_index(IOOp io_op)
1434 : : {
1435 [ + + + + : 73232 : switch (io_op)
+ + - ]
1436 : : {
1437 : 9154 : case IOOP_READ:
1438 : 9154 : return IO_COL_READ_TIME;
1439 : 9154 : case IOOP_WRITE:
1440 : 9154 : return IO_COL_WRITE_TIME;
1441 : 9154 : case IOOP_WRITEBACK:
1442 : 9154 : return IO_COL_WRITEBACK_TIME;
1443 : 9154 : case IOOP_EXTEND:
1444 : 9154 : return IO_COL_EXTEND_TIME;
1445 : 9154 : case IOOP_FSYNC:
1446 : 9154 : return IO_COL_FSYNC_TIME;
1447 : 27462 : case IOOP_EVICT:
1448 : : case IOOP_HIT:
1449 : : case IOOP_REUSE:
1450 : 27462 : return IO_COL_INVALID;
1451 : : }
1452 : :
1453 [ # # ]: 0 : elog(ERROR, "unrecognized IOOp value: %d", io_op);
1454 : : pg_unreachable();
1455 : : }
1456 : :
1457 : : static inline double
1458 : 31790 : pg_stat_us_to_ms(PgStat_Counter val_us)
1459 : : {
1460 : 31790 : return (double) val_us / 1000.0;
1461 : : }
1462 : :
1463 : : /*
1464 : : * pg_stat_io_build_tuples
1465 : : *
1466 : : * Helper routine for pg_stat_get_io() and pg_stat_get_backend_io()
1467 : : * filling a result tuplestore with one tuple for each object and each
1468 : : * context supported by the caller, based on the contents of bktype_stats.
1469 : : */
1470 : : static void
1471 : 1532 : pg_stat_io_build_tuples(ReturnSetInfo *rsinfo,
1472 : : PgStat_BktypeIO *bktype_stats,
1473 : : BackendType bktype,
1474 : : TimestampTz stat_reset_timestamp)
1475 : : {
1476 : 1532 : Datum bktype_desc = CStringGetTextDatum(GetBackendTypeDesc(bktype));
1477 : :
1478 [ + + ]: 6128 : for (int io_obj = 0; io_obj < IOOBJECT_NUM_TYPES; io_obj++)
1479 : : {
1480 : 4596 : const char *obj_name = pgstat_get_io_object_name(io_obj);
1481 : :
1482 [ + + ]: 27576 : for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
1483 : : {
1484 : 22980 : const char *context_name = pgstat_get_io_context_name(io_context);
1485 : :
1486 : 22980 : Datum values[IO_NUM_COLUMNS] = {0};
1487 : 22980 : bool nulls[IO_NUM_COLUMNS] = {0};
1488 : :
1489 : : /*
1490 : : * Some combinations of BackendType, IOObject, and IOContext are
1491 : : * not valid for any type of IOOp. In such cases, omit the entire
1492 : : * row from the view.
1493 : : */
1494 [ + + ]: 22980 : if (!pgstat_tracks_io_object(bktype, io_obj, io_context))
1495 : 13826 : continue;
1496 : :
1497 : 9154 : values[IO_COL_BACKEND_TYPE] = bktype_desc;
1498 : 9154 : values[IO_COL_CONTEXT] = CStringGetTextDatum(context_name);
1499 : 9154 : values[IO_COL_OBJECT] = CStringGetTextDatum(obj_name);
1500 [ + + ]: 9154 : if (stat_reset_timestamp != 0)
1501 : 8962 : values[IO_COL_RESET_TIME] = TimestampTzGetDatum(stat_reset_timestamp);
1502 : : else
1503 : 192 : nulls[IO_COL_RESET_TIME] = true;
1504 : :
1505 [ + + ]: 82386 : for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
1506 : : {
1507 : 73232 : int op_idx = pgstat_get_io_op_index(io_op);
1508 : 73232 : int time_idx = pgstat_get_io_time_index(io_op);
1509 : 73232 : int byte_idx = pgstat_get_io_byte_index(io_op);
1510 : :
1511 : : /*
1512 : : * Some combinations of BackendType and IOOp, of IOContext and
1513 : : * IOOp, and of IOObject and IOOp are not tracked. Set these
1514 : : * cells in the view NULL.
1515 : : */
1516 [ + + ]: 73232 : if (pgstat_tracks_io_op(bktype, io_obj, io_context, io_op))
1517 : : {
1518 : 45882 : PgStat_Counter count =
1519 : : bktype_stats->counts[io_obj][io_context][io_op];
1520 : :
1521 : 45882 : values[op_idx] = Int64GetDatum(count);
1522 : : }
1523 : : else
1524 : 27350 : nulls[op_idx] = true;
1525 : :
1526 [ + + ]: 73232 : if (!nulls[op_idx])
1527 : : {
1528 : : /* not every operation is timed */
1529 [ + + ]: 45882 : if (time_idx != IO_COL_INVALID)
1530 : : {
1531 : 31550 : PgStat_Counter time =
1532 : : bktype_stats->times[io_obj][io_context][io_op];
1533 : :
1534 : 31550 : values[time_idx] = Float8GetDatum(pg_stat_us_to_ms(time));
1535 : : }
1536 : :
1537 : : /* not every IO is tracked in bytes */
1538 [ + + ]: 45882 : if (byte_idx != IO_COL_INVALID)
1539 : : {
1540 : : char buf[256];
1541 : 20582 : PgStat_Counter byte =
1542 : 20582 : bktype_stats->bytes[io_obj][io_context][io_op];
1543 : :
1544 : : /* Convert to numeric */
1545 : 20582 : snprintf(buf, sizeof buf, INT64_FORMAT, byte);
1546 : 20582 : values[byte_idx] = DirectFunctionCall3(numeric_in,
1547 : : CStringGetDatum(buf),
1548 : : ObjectIdGetDatum(0),
1549 : : Int32GetDatum(-1));
1550 : : }
1551 : : }
1552 : : else
1553 : : {
1554 [ + + ]: 27350 : if (time_idx != IO_COL_INVALID)
1555 : 14220 : nulls[time_idx] = true;
1556 [ + + ]: 27350 : if (byte_idx != IO_COL_INVALID)
1557 : 6880 : nulls[byte_idx] = true;
1558 : : }
1559 : : }
1560 : :
1561 : 9154 : tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
1562 : : values, nulls);
1563 : : }
1564 : : }
1565 : 1532 : }
1566 : :
1567 : : Datum
1568 : 94 : pg_stat_get_io(PG_FUNCTION_ARGS)
1569 : : {
1570 : : ReturnSetInfo *rsinfo;
1571 : : PgStat_IO *backends_io_stats;
1572 : :
1573 : 94 : InitMaterializedSRF(fcinfo, 0);
1574 : 94 : rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
1575 : :
1576 : 94 : backends_io_stats = pgstat_fetch_stat_io();
1577 : :
1578 [ + + ]: 1974 : for (int bktype = 0; bktype < BACKEND_NUM_TYPES; bktype++)
1579 : : {
1580 : 1880 : PgStat_BktypeIO *bktype_stats = &backends_io_stats->stats[bktype];
1581 : :
1582 : : /*
1583 : : * In Assert builds, we can afford an extra loop through all of the
1584 : : * counters (in pg_stat_io_build_tuples()), checking that only
1585 : : * expected stats are non-zero, since it keeps the non-Assert code
1586 : : * cleaner.
1587 : : */
1588 : : Assert(pgstat_bktype_io_stats_valid(bktype_stats, bktype));
1589 : :
1590 : : /*
1591 : : * For those BackendTypes without IO Operation stats, skip
1592 : : * representing them in the view altogether.
1593 : : */
1594 [ + + ]: 1880 : if (!pgstat_tracks_io_bktype(bktype))
1595 : 376 : continue;
1596 : :
1597 : : /* save tuples with data from this PgStat_BktypeIO */
1598 : 1504 : pg_stat_io_build_tuples(rsinfo, bktype_stats, bktype,
1599 : : backends_io_stats->stat_reset_timestamp);
1600 : : }
1601 : :
1602 : 94 : return (Datum) 0;
1603 : : }
1604 : :
1605 : : /*
1606 : : * Returns I/O statistics for a backend with given PID.
1607 : : */
1608 : : Datum
1609 : 36 : pg_stat_get_backend_io(PG_FUNCTION_ARGS)
1610 : : {
1611 : : ReturnSetInfo *rsinfo;
1612 : : BackendType bktype;
1613 : : int pid;
1614 : : PgStat_Backend *backend_stats;
1615 : : PgStat_BktypeIO *bktype_stats;
1616 : :
1617 : 36 : InitMaterializedSRF(fcinfo, 0);
1618 : 36 : rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
1619 : :
1620 : 36 : pid = PG_GETARG_INT32(0);
1621 : 36 : backend_stats = pgstat_fetch_stat_backend_by_pid(pid, &bktype);
1622 : :
1623 [ + + ]: 36 : if (!backend_stats)
1624 : 8 : return (Datum) 0;
1625 : :
1626 : 28 : bktype_stats = &backend_stats->io_stats;
1627 : :
1628 : : /*
1629 : : * In Assert builds, we can afford an extra loop through all of the
1630 : : * counters (in pg_stat_io_build_tuples()), checking that only expected
1631 : : * stats are non-zero, since it keeps the non-Assert code cleaner.
1632 : : */
1633 : : Assert(pgstat_bktype_io_stats_valid(bktype_stats, bktype));
1634 : :
1635 : : /* save tuples with data from this PgStat_BktypeIO */
1636 : 28 : pg_stat_io_build_tuples(rsinfo, bktype_stats, bktype,
1637 : : backend_stats->stat_reset_timestamp);
1638 : 28 : return (Datum) 0;
1639 : : }
1640 : :
1641 : : /*
1642 : : * pg_stat_wal_build_tuple
1643 : : *
1644 : : * Helper routine for pg_stat_get_wal() and pg_stat_get_backend_wal()
1645 : : * returning one tuple based on the contents of wal_counters.
1646 : : */
1647 : : static Datum
1648 : 49 : pg_stat_wal_build_tuple(PgStat_WalCounters wal_counters,
1649 : : TimestampTz stat_reset_timestamp)
1650 : : {
1651 : : #define PG_STAT_WAL_COLS 6
1652 : : TupleDesc tupdesc;
1653 : 49 : Datum values[PG_STAT_WAL_COLS] = {0};
1654 : 49 : bool nulls[PG_STAT_WAL_COLS] = {0};
1655 : : char buf[256];
1656 : :
1657 : : /* Initialise attributes information in the tuple descriptor */
1658 : 49 : tupdesc = CreateTemplateTupleDesc(PG_STAT_WAL_COLS);
1659 : 49 : TupleDescInitEntry(tupdesc, (AttrNumber) 1, "wal_records",
1660 : : INT8OID, -1, 0);
1661 : 49 : TupleDescInitEntry(tupdesc, (AttrNumber) 2, "wal_fpi",
1662 : : INT8OID, -1, 0);
1663 : 49 : TupleDescInitEntry(tupdesc, (AttrNumber) 3, "wal_bytes",
1664 : : NUMERICOID, -1, 0);
1665 : 49 : TupleDescInitEntry(tupdesc, (AttrNumber) 4, "wal_fpi_bytes",
1666 : : NUMERICOID, -1, 0);
1667 : 49 : TupleDescInitEntry(tupdesc, (AttrNumber) 5, "wal_buffers_full",
1668 : : INT8OID, -1, 0);
1669 : 49 : TupleDescInitEntry(tupdesc, (AttrNumber) 6, "stats_reset",
1670 : : TIMESTAMPTZOID, -1, 0);
1671 : :
1672 : 49 : TupleDescFinalize(tupdesc);
1673 : 49 : BlessTupleDesc(tupdesc);
1674 : :
1675 : : /* Fill values and NULLs */
1676 : 49 : values[0] = Int64GetDatum(wal_counters.wal_records);
1677 : 49 : values[1] = Int64GetDatum(wal_counters.wal_fpi);
1678 : :
1679 : : /* Convert to numeric. */
1680 : 49 : snprintf(buf, sizeof buf, UINT64_FORMAT, wal_counters.wal_bytes);
1681 : 49 : values[2] = DirectFunctionCall3(numeric_in,
1682 : : CStringGetDatum(buf),
1683 : : ObjectIdGetDatum(0),
1684 : : Int32GetDatum(-1));
1685 : :
1686 : 49 : snprintf(buf, sizeof buf, UINT64_FORMAT, wal_counters.wal_fpi_bytes);
1687 : 49 : values[3] = DirectFunctionCall3(numeric_in,
1688 : : CStringGetDatum(buf),
1689 : : ObjectIdGetDatum(0),
1690 : : Int32GetDatum(-1));
1691 : :
1692 : 49 : values[4] = Int64GetDatum(wal_counters.wal_buffers_full);
1693 : :
1694 [ + + ]: 49 : if (stat_reset_timestamp != 0)
1695 : 41 : values[5] = TimestampTzGetDatum(stat_reset_timestamp);
1696 : : else
1697 : 8 : nulls[5] = true;
1698 : :
1699 : : /* Returns the record as Datum */
1700 : 49 : PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
1701 : : }
1702 : :
1703 : : /*
1704 : : * Returns WAL statistics for a backend with given PID.
1705 : : */
1706 : : Datum
1707 : 8 : pg_stat_get_backend_wal(PG_FUNCTION_ARGS)
1708 : : {
1709 : : int pid;
1710 : : PgStat_Backend *backend_stats;
1711 : : PgStat_WalCounters bktype_stats;
1712 : :
1713 : 8 : pid = PG_GETARG_INT32(0);
1714 : 8 : backend_stats = pgstat_fetch_stat_backend_by_pid(pid, NULL);
1715 : :
1716 [ - + ]: 8 : if (!backend_stats)
1717 : 0 : PG_RETURN_NULL();
1718 : :
1719 : 8 : bktype_stats = backend_stats->wal_counters;
1720 : :
1721 : : /* save tuples with data from this PgStat_WalCounters */
1722 : 8 : return (pg_stat_wal_build_tuple(bktype_stats, backend_stats->stat_reset_timestamp));
1723 : : }
1724 : :
1725 : : /*
1726 : : * Returns statistics of WAL activity
1727 : : */
1728 : : Datum
1729 : 41 : pg_stat_get_wal(PG_FUNCTION_ARGS)
1730 : : {
1731 : : PgStat_WalStats *wal_stats;
1732 : :
1733 : : /* Get statistics about WAL activity */
1734 : 41 : wal_stats = pgstat_fetch_stat_wal();
1735 : :
1736 : 41 : return (pg_stat_wal_build_tuple(wal_stats->wal_counters,
1737 : : wal_stats->stat_reset_timestamp));
1738 : : }
1739 : :
1740 : : /*
1741 : : * pg_stat_lock_build_tuples
1742 : : *
1743 : : * Helper routine for pg_stat_get_lock() and pg_stat_get_backend_lock(),
1744 : : * filling a result tuplestore with one tuple for each lock type.
1745 : : */
1746 : : static void
1747 : 20 : pg_stat_lock_build_tuples(ReturnSetInfo *rsinfo,
1748 : : PgStat_LockEntry *lock_stats,
1749 : : TimestampTz stat_reset_timestamp)
1750 : : {
1751 : : #define PG_STAT_LOCK_COLS 5
1752 [ + + ]: 260 : for (int lcktype = 0; lcktype <= LOCKTAG_LAST_TYPE; lcktype++)
1753 : : {
1754 : 240 : Datum values[PG_STAT_LOCK_COLS] = {0};
1755 : 240 : bool nulls[PG_STAT_LOCK_COLS] = {0};
1756 : 240 : PgStat_LockEntry *lck_stats = &lock_stats[lcktype];
1757 : 240 : int i = 0;
1758 : :
1759 : 240 : values[i++] = CStringGetTextDatum(LockTagTypeNames[lcktype]);
1760 : 240 : values[i++] = Int64GetDatum(lck_stats->waits);
1761 : 240 : values[i++] = Float8GetDatum(pg_stat_us_to_ms(lck_stats->wait_time));
1762 : 240 : values[i++] = Int64GetDatum(lck_stats->fastpath_exceeded);
1763 [ + + ]: 240 : if (stat_reset_timestamp != 0)
1764 : 144 : values[i] = TimestampTzGetDatum(stat_reset_timestamp);
1765 : : else
1766 : 96 : nulls[i] = true;
1767 : :
1768 : : Assert(i + 1 == PG_STAT_LOCK_COLS);
1769 : :
1770 : 240 : tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
1771 : : }
1772 : 20 : }
1773 : :
1774 : : Datum
1775 : 12 : pg_stat_get_lock(PG_FUNCTION_ARGS)
1776 : : {
1777 : : ReturnSetInfo *rsinfo;
1778 : : PgStat_Lock *lock_stats;
1779 : :
1780 : 12 : InitMaterializedSRF(fcinfo, 0);
1781 : 12 : rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
1782 : :
1783 : 12 : lock_stats = pgstat_fetch_stat_lock();
1784 : :
1785 : 12 : pg_stat_lock_build_tuples(rsinfo, lock_stats->stats,
1786 : : lock_stats->stat_reset_timestamp);
1787 : :
1788 : 12 : return (Datum) 0;
1789 : : }
1790 : :
1791 : : /*
1792 : : * Returns lock statistics for a backend with given PID.
1793 : : */
1794 : : Datum
1795 : 8 : pg_stat_get_backend_lock(PG_FUNCTION_ARGS)
1796 : : {
1797 : : int pid;
1798 : : ReturnSetInfo *rsinfo;
1799 : : PgStat_Backend *backend_stats;
1800 : :
1801 : 8 : InitMaterializedSRF(fcinfo, 0);
1802 : 8 : rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
1803 : :
1804 : 8 : pid = PG_GETARG_INT32(0);
1805 : 8 : backend_stats = pgstat_fetch_stat_backend_by_pid(pid, NULL);
1806 : :
1807 [ - + ]: 8 : if (!backend_stats)
1808 : 0 : return (Datum) 0;
1809 : :
1810 : 8 : pg_stat_lock_build_tuples(rsinfo, backend_stats->lock_stats.stats,
1811 : : backend_stats->stat_reset_timestamp);
1812 : :
1813 : 8 : return (Datum) 0;
1814 : : }
1815 : :
1816 : : /*
1817 : : * Returns statistics of SLRU caches.
1818 : : */
1819 : : Datum
1820 : 71 : pg_stat_get_slru(PG_FUNCTION_ARGS)
1821 : : {
1822 : : #define PG_STAT_GET_SLRU_COLS 9
1823 : 71 : ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
1824 : : int i;
1825 : : PgStat_SLRUStats *stats;
1826 : :
1827 : 71 : InitMaterializedSRF(fcinfo, 0);
1828 : :
1829 : : /* request SLRU stats from the cumulative stats system */
1830 : 71 : stats = pgstat_fetch_slru();
1831 : :
1832 : 71 : for (i = 0;; i++)
1833 : 568 : {
1834 : : /* for each row */
1835 : 639 : Datum values[PG_STAT_GET_SLRU_COLS] = {0};
1836 : 639 : bool nulls[PG_STAT_GET_SLRU_COLS] = {0};
1837 : : PgStat_SLRUStats stat;
1838 : : const char *name;
1839 : :
1840 : 639 : name = pgstat_get_slru_name(i);
1841 : :
1842 [ + + ]: 639 : if (!name)
1843 : 71 : break;
1844 : :
1845 : 568 : stat = stats[i];
1846 : :
1847 : 568 : values[0] = PointerGetDatum(cstring_to_text(name));
1848 : 568 : values[1] = Int64GetDatum(stat.blocks_zeroed);
1849 : 568 : values[2] = Int64GetDatum(stat.blocks_hit);
1850 : 568 : values[3] = Int64GetDatum(stat.blocks_read);
1851 : 568 : values[4] = Int64GetDatum(stat.blocks_written);
1852 : 568 : values[5] = Int64GetDatum(stat.blocks_exists);
1853 : 568 : values[6] = Int64GetDatum(stat.flush);
1854 : 568 : values[7] = Int64GetDatum(stat.truncate);
1855 : 568 : values[8] = TimestampTzGetDatum(stat.stat_reset_timestamp);
1856 : :
1857 : 568 : tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
1858 : : }
1859 : :
1860 : 71 : return (Datum) 0;
1861 : : }
1862 : :
1863 : : #define PG_STAT_GET_XACT_RELENTRY_INT64(stat) \
1864 : : Datum \
1865 : : CppConcat(pg_stat_get_xact_,stat)(PG_FUNCTION_ARGS) \
1866 : : { \
1867 : : Oid relid = PG_GETARG_OID(0); \
1868 : : int64 result; \
1869 : : PgStat_TableStatus *tabentry; \
1870 : : \
1871 : : if ((tabentry = find_tabstat_entry(relid)) == NULL) \
1872 : : result = 0; \
1873 : : else \
1874 : : result = (int64) (tabentry->counts.stat); \
1875 : : \
1876 : : PG_RETURN_INT64(result); \
1877 : : }
1878 : :
1879 : : /* pg_stat_get_xact_numscans */
1880 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(numscans)
1881 : :
1882 : : /* pg_stat_get_xact_tuples_returned */
1883 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(tuples_returned)
1884 : :
1885 : : /* pg_stat_get_xact_tuples_fetched */
1886 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(tuples_fetched)
1887 : :
1888 : : /* pg_stat_get_xact_tuples_hot_updated */
1889 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(tuples_hot_updated)
1890 : :
1891 : : /* pg_stat_get_xact_tuples_newpage_updated */
1892 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(tuples_newpage_updated)
1893 : :
1894 : : /* pg_stat_get_xact_blocks_fetched */
1895 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(blocks_fetched)
1896 : :
1897 : : /* pg_stat_get_xact_blocks_hit */
1898 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(blocks_hit)
1899 : :
1900 : : /* pg_stat_get_xact_tuples_inserted */
1901 [ + + ]: 32 : PG_STAT_GET_XACT_RELENTRY_INT64(tuples_inserted)
1902 : :
1903 : : /* pg_stat_get_xact_tuples_updated */
1904 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(tuples_updated)
1905 : :
1906 : : /* pg_stat_get_xact_tuples_deleted */
1907 [ # # ]: 0 : PG_STAT_GET_XACT_RELENTRY_INT64(tuples_deleted)
1908 : :
1909 : : Datum
1910 : 16 : pg_stat_get_xact_function_calls(PG_FUNCTION_ARGS)
1911 : : {
1912 : 16 : Oid funcid = PG_GETARG_OID(0);
1913 : : PgStat_FunctionCounts *funcentry;
1914 : :
1915 [ + + ]: 16 : if ((funcentry = find_funcstat_entry(funcid)) == NULL)
1916 : 4 : PG_RETURN_NULL();
1917 : 12 : PG_RETURN_INT64(funcentry->numcalls);
1918 : : }
1919 : :
1920 : : #define PG_STAT_GET_XACT_FUNCENTRY_FLOAT8_MS(stat) \
1921 : : Datum \
1922 : : CppConcat(pg_stat_get_xact_function_,stat)(PG_FUNCTION_ARGS) \
1923 : : { \
1924 : : Oid funcid = PG_GETARG_OID(0); \
1925 : : PgStat_FunctionCounts *funcentry; \
1926 : : \
1927 : : if ((funcentry = find_funcstat_entry(funcid)) == NULL) \
1928 : : PG_RETURN_NULL(); \
1929 : : PG_RETURN_FLOAT8(INSTR_TIME_GET_MILLISEC(funcentry->stat)); \
1930 : : }
1931 : :
1932 : : /* pg_stat_get_xact_function_total_time */
1933 [ # # ]: 0 : PG_STAT_GET_XACT_FUNCENTRY_FLOAT8_MS(total_time)
1934 : :
1935 : : /* pg_stat_get_xact_function_self_time */
1936 [ # # ]: 0 : PG_STAT_GET_XACT_FUNCENTRY_FLOAT8_MS(self_time)
1937 : :
1938 : : /* Get the timestamp of the current statistics snapshot */
1939 : : Datum
1940 : 40 : pg_stat_get_snapshot_timestamp(PG_FUNCTION_ARGS)
1941 : : {
1942 : : bool have_snapshot;
1943 : : TimestampTz ts;
1944 : :
1945 : 40 : ts = pgstat_get_stat_snapshot_timestamp(&have_snapshot);
1946 : :
1947 [ + + ]: 40 : if (!have_snapshot)
1948 : 24 : PG_RETURN_NULL();
1949 : :
1950 : 16 : PG_RETURN_TIMESTAMPTZ(ts);
1951 : : }
1952 : :
1953 : : /* Discard the active statistics snapshot */
1954 : : Datum
1955 : 10 : pg_stat_clear_snapshot(PG_FUNCTION_ARGS)
1956 : : {
1957 : 10 : pgstat_clear_snapshot();
1958 : :
1959 : 10 : PG_RETURN_VOID();
1960 : : }
1961 : :
1962 : :
1963 : : /* Force statistics to be reported at the next occasion */
1964 : : Datum
1965 : 341 : pg_stat_force_next_flush(PG_FUNCTION_ARGS)
1966 : : {
1967 : 341 : pgstat_force_next_flush();
1968 : :
1969 : 341 : PG_RETURN_VOID();
1970 : : }
1971 : :
1972 : :
1973 : : /* Reset all counters for the current database */
1974 : : Datum
1975 : 15 : pg_stat_reset(PG_FUNCTION_ARGS)
1976 : : {
1977 : 15 : pgstat_reset_counters();
1978 : :
1979 : 15 : PG_RETURN_VOID();
1980 : : }
1981 : :
1982 : : /*
1983 : : * Reset some shared cluster-wide counters
1984 : : *
1985 : : * When adding a new reset target, ideally the name should match that in
1986 : : * pgstat_kind_builtin_infos, if relevant.
1987 : : */
1988 : : Datum
1989 : 44 : pg_stat_reset_shared(PG_FUNCTION_ARGS)
1990 : : {
1991 : 44 : char *target = NULL;
1992 : :
1993 [ - + ]: 44 : if (PG_ARGISNULL(0))
1994 : : {
1995 : : /* Reset all the statistics when nothing is specified */
1996 : 0 : pgstat_reset_of_kind(PGSTAT_KIND_ARCHIVER);
1997 : 0 : pgstat_reset_of_kind(PGSTAT_KIND_BGWRITER);
1998 : 0 : pgstat_reset_of_kind(PGSTAT_KIND_CHECKPOINTER);
1999 : 0 : pgstat_reset_of_kind(PGSTAT_KIND_IO);
2000 : 0 : pgstat_reset_of_kind(PGSTAT_KIND_LOCK);
2001 : 0 : XLogPrefetchResetStats();
2002 : 0 : pgstat_reset_of_kind(PGSTAT_KIND_SLRU);
2003 : 0 : pgstat_reset_of_kind(PGSTAT_KIND_WAL);
2004 : :
2005 : 0 : PG_RETURN_VOID();
2006 : : }
2007 : :
2008 : 44 : target = text_to_cstring(PG_GETARG_TEXT_PP(0));
2009 : :
2010 [ + + ]: 44 : if (strcmp(target, "archiver") == 0)
2011 : 4 : pgstat_reset_of_kind(PGSTAT_KIND_ARCHIVER);
2012 [ + + ]: 40 : else if (strcmp(target, "bgwriter") == 0)
2013 : 4 : pgstat_reset_of_kind(PGSTAT_KIND_BGWRITER);
2014 [ + + ]: 36 : else if (strcmp(target, "checkpointer") == 0)
2015 : 5 : pgstat_reset_of_kind(PGSTAT_KIND_CHECKPOINTER);
2016 [ + + ]: 31 : else if (strcmp(target, "io") == 0)
2017 : 6 : pgstat_reset_of_kind(PGSTAT_KIND_IO);
2018 [ + + ]: 25 : else if (strcmp(target, "lock") == 0)
2019 : 8 : pgstat_reset_of_kind(PGSTAT_KIND_LOCK);
2020 [ + + ]: 17 : else if (strcmp(target, "recovery_prefetch") == 0)
2021 : 4 : XLogPrefetchResetStats();
2022 [ + + ]: 13 : else if (strcmp(target, "slru") == 0)
2023 : 4 : pgstat_reset_of_kind(PGSTAT_KIND_SLRU);
2024 [ + + ]: 9 : else if (strcmp(target, "wal") == 0)
2025 : 5 : pgstat_reset_of_kind(PGSTAT_KIND_WAL);
2026 : : else
2027 [ + - ]: 4 : ereport(ERROR,
2028 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2029 : : errmsg("unrecognized reset target: \"%s\"", target),
2030 : : errhint("Target must be \"archiver\", \"bgwriter\", \"checkpointer\", \"io\", \"lock\", \"recovery_prefetch\", \"slru\", or \"wal\".")));
2031 : :
2032 : 40 : PG_RETURN_VOID();
2033 : : }
2034 : :
2035 : : /*
2036 : : * Reset statistics for a single object, which may be of current
2037 : : * database or shared across all databases in the cluster.
2038 : : */
2039 : : Datum
2040 : 26 : pg_stat_reset_single_table_counters(PG_FUNCTION_ARGS)
2041 : : {
2042 : 26 : Oid taboid = PG_GETARG_OID(0);
2043 [ + + ]: 26 : Oid dboid = (IsSharedRelation(taboid) ? InvalidOid : MyDatabaseId);
2044 : :
2045 : 26 : pgstat_reset(PGSTAT_KIND_RELATION, dboid, taboid);
2046 : :
2047 : 26 : PG_RETURN_VOID();
2048 : : }
2049 : :
2050 : : Datum
2051 : 2 : pg_stat_reset_single_function_counters(PG_FUNCTION_ARGS)
2052 : : {
2053 : 2 : Oid funcoid = PG_GETARG_OID(0);
2054 : :
2055 : 2 : pgstat_reset(PGSTAT_KIND_FUNCTION, MyDatabaseId, funcoid);
2056 : :
2057 : 2 : PG_RETURN_VOID();
2058 : : }
2059 : :
2060 : : /*
2061 : : * Reset statistics of backend with given PID.
2062 : : */
2063 : : Datum
2064 : 4 : pg_stat_reset_backend_stats(PG_FUNCTION_ARGS)
2065 : : {
2066 : : PGPROC *proc;
2067 : : PgBackendStatus *beentry;
2068 : : ProcNumber procNumber;
2069 : 4 : int backend_pid = PG_GETARG_INT32(0);
2070 : :
2071 : 4 : proc = BackendPidGetProc(backend_pid);
2072 : :
2073 : : /* This could be an auxiliary process */
2074 [ - + ]: 4 : if (!proc)
2075 : 0 : proc = AuxiliaryPidGetProc(backend_pid);
2076 : :
2077 [ - + ]: 4 : if (!proc)
2078 : 0 : PG_RETURN_VOID();
2079 : :
2080 : 4 : procNumber = GetNumberFromPGProc(proc);
2081 : :
2082 : 4 : beentry = pgstat_get_beentry_by_proc_number(procNumber);
2083 [ - + ]: 4 : if (!beentry)
2084 : 0 : PG_RETURN_VOID();
2085 : :
2086 : : /* Check if the backend type tracks statistics */
2087 [ - + ]: 4 : if (!pgstat_tracks_backend_bktype(beentry->st_backendType))
2088 : 0 : PG_RETURN_VOID();
2089 : :
2090 : 4 : pgstat_reset(PGSTAT_KIND_BACKEND, InvalidOid, procNumber);
2091 : :
2092 : 4 : PG_RETURN_VOID();
2093 : : }
2094 : :
2095 : : /* Reset SLRU counters (a specific one or all of them). */
2096 : : Datum
2097 : 8 : pg_stat_reset_slru(PG_FUNCTION_ARGS)
2098 : : {
2099 : 8 : char *target = NULL;
2100 : :
2101 [ + + ]: 8 : if (PG_ARGISNULL(0))
2102 : 4 : pgstat_reset_of_kind(PGSTAT_KIND_SLRU);
2103 : : else
2104 : : {
2105 : 4 : target = text_to_cstring(PG_GETARG_TEXT_PP(0));
2106 : 4 : pgstat_reset_slru(target);
2107 : : }
2108 : :
2109 : 8 : PG_RETURN_VOID();
2110 : : }
2111 : :
2112 : : /* Reset replication slots stats (a specific one or all of them). */
2113 : : Datum
2114 : 6 : pg_stat_reset_replication_slot(PG_FUNCTION_ARGS)
2115 : : {
2116 : 6 : char *target = NULL;
2117 : :
2118 [ + + ]: 6 : if (PG_ARGISNULL(0))
2119 : 2 : pgstat_reset_of_kind(PGSTAT_KIND_REPLSLOT);
2120 : : else
2121 : : {
2122 : 4 : target = text_to_cstring(PG_GETARG_TEXT_PP(0));
2123 : 4 : pgstat_reset_replslot(target);
2124 : : }
2125 : :
2126 : 5 : PG_RETURN_VOID();
2127 : : }
2128 : :
2129 : : /* Reset subscription stats (a specific one or all of them) */
2130 : : Datum
2131 : 12 : pg_stat_reset_subscription_stats(PG_FUNCTION_ARGS)
2132 : : {
2133 : : Oid subid;
2134 : :
2135 [ + + ]: 12 : if (PG_ARGISNULL(0))
2136 : : {
2137 : : /* Clear all subscription stats */
2138 : 2 : pgstat_reset_of_kind(PGSTAT_KIND_SUBSCRIPTION);
2139 : : }
2140 : : else
2141 : : {
2142 : 10 : subid = PG_GETARG_OID(0);
2143 : :
2144 [ - + ]: 10 : if (!OidIsValid(subid))
2145 [ # # ]: 0 : ereport(ERROR,
2146 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2147 : : errmsg("invalid subscription OID %u", subid)));
2148 : 10 : pgstat_reset(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid);
2149 : : }
2150 : :
2151 : 12 : PG_RETURN_VOID();
2152 : : }
2153 : :
2154 : : Datum
2155 : 24 : pg_stat_get_archiver(PG_FUNCTION_ARGS)
2156 : : {
2157 : : TupleDesc tupdesc;
2158 : 24 : Datum values[7] = {0};
2159 : 24 : bool nulls[7] = {0};
2160 : : PgStat_ArchiverStats *archiver_stats;
2161 : :
2162 : : /* Initialise attributes information in the tuple descriptor */
2163 : 24 : tupdesc = CreateTemplateTupleDesc(7);
2164 : 24 : TupleDescInitEntry(tupdesc, (AttrNumber) 1, "archived_count",
2165 : : INT8OID, -1, 0);
2166 : 24 : TupleDescInitEntry(tupdesc, (AttrNumber) 2, "last_archived_wal",
2167 : : TEXTOID, -1, 0);
2168 : 24 : TupleDescInitEntry(tupdesc, (AttrNumber) 3, "last_archived_time",
2169 : : TIMESTAMPTZOID, -1, 0);
2170 : 24 : TupleDescInitEntry(tupdesc, (AttrNumber) 4, "failed_count",
2171 : : INT8OID, -1, 0);
2172 : 24 : TupleDescInitEntry(tupdesc, (AttrNumber) 5, "last_failed_wal",
2173 : : TEXTOID, -1, 0);
2174 : 24 : TupleDescInitEntry(tupdesc, (AttrNumber) 6, "last_failed_time",
2175 : : TIMESTAMPTZOID, -1, 0);
2176 : 24 : TupleDescInitEntry(tupdesc, (AttrNumber) 7, "stats_reset",
2177 : : TIMESTAMPTZOID, -1, 0);
2178 : :
2179 : 24 : TupleDescFinalize(tupdesc);
2180 : 24 : BlessTupleDesc(tupdesc);
2181 : :
2182 : : /* Get statistics about the archiver process */
2183 : 24 : archiver_stats = pgstat_fetch_stat_archiver();
2184 : :
2185 : : /* Fill values and NULLs */
2186 : 24 : values[0] = Int64GetDatum(archiver_stats->archived_count);
2187 [ + + ]: 24 : if (*(archiver_stats->last_archived_wal) == '\0')
2188 : 9 : nulls[1] = true;
2189 : : else
2190 : 15 : values[1] = CStringGetTextDatum(archiver_stats->last_archived_wal);
2191 : :
2192 [ + + ]: 24 : if (archiver_stats->last_archived_timestamp == 0)
2193 : 9 : nulls[2] = true;
2194 : : else
2195 : 15 : values[2] = TimestampTzGetDatum(archiver_stats->last_archived_timestamp);
2196 : :
2197 : 24 : values[3] = Int64GetDatum(archiver_stats->failed_count);
2198 [ + + ]: 24 : if (*(archiver_stats->last_failed_wal) == '\0')
2199 : 16 : nulls[4] = true;
2200 : : else
2201 : 8 : values[4] = CStringGetTextDatum(archiver_stats->last_failed_wal);
2202 : :
2203 [ + + ]: 24 : if (archiver_stats->last_failed_timestamp == 0)
2204 : 16 : nulls[5] = true;
2205 : : else
2206 : 8 : values[5] = TimestampTzGetDatum(archiver_stats->last_failed_timestamp);
2207 : :
2208 [ - + ]: 24 : if (archiver_stats->stat_reset_timestamp == 0)
2209 : 0 : nulls[6] = true;
2210 : : else
2211 : 24 : values[6] = TimestampTzGetDatum(archiver_stats->stat_reset_timestamp);
2212 : :
2213 : : /* Returns the record as Datum */
2214 : 24 : PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
2215 : : }
2216 : :
2217 : : /*
2218 : : * Get the statistics for the replication slot. If the slot statistics is not
2219 : : * available, return all-zeroes stats.
2220 : : */
2221 : : Datum
2222 : 52 : pg_stat_get_replication_slot(PG_FUNCTION_ARGS)
2223 : : {
2224 : : #define PG_STAT_GET_REPLICATION_SLOT_COLS 13
2225 : 52 : text *slotname_text = PG_GETARG_TEXT_P(0);
2226 : : NameData slotname;
2227 : : TupleDesc tupdesc;
2228 : 52 : Datum values[PG_STAT_GET_REPLICATION_SLOT_COLS] = {0};
2229 : 52 : bool nulls[PG_STAT_GET_REPLICATION_SLOT_COLS] = {0};
2230 : : PgStat_StatReplSlotEntry *slotent;
2231 : : PgStat_StatReplSlotEntry allzero;
2232 : :
2233 : : /* Initialise attributes information in the tuple descriptor */
2234 : 52 : tupdesc = CreateTemplateTupleDesc(PG_STAT_GET_REPLICATION_SLOT_COLS);
2235 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 1, "slot_name",
2236 : : TEXTOID, -1, 0);
2237 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 2, "spill_txns",
2238 : : INT8OID, -1, 0);
2239 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 3, "spill_count",
2240 : : INT8OID, -1, 0);
2241 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 4, "spill_bytes",
2242 : : INT8OID, -1, 0);
2243 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 5, "stream_txns",
2244 : : INT8OID, -1, 0);
2245 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 6, "stream_count",
2246 : : INT8OID, -1, 0);
2247 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 7, "stream_bytes",
2248 : : INT8OID, -1, 0);
2249 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 8, "mem_exceeded_count",
2250 : : INT8OID, -1, 0);
2251 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 9, "total_txns",
2252 : : INT8OID, -1, 0);
2253 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 10, "total_bytes",
2254 : : INT8OID, -1, 0);
2255 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 11, "slotsync_skip_count",
2256 : : INT8OID, -1, 0);
2257 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 12, "slotsync_last_skip",
2258 : : TIMESTAMPTZOID, -1, 0);
2259 : 52 : TupleDescInitEntry(tupdesc, (AttrNumber) 13, "stats_reset",
2260 : : TIMESTAMPTZOID, -1, 0);
2261 : 52 : TupleDescFinalize(tupdesc);
2262 : 52 : BlessTupleDesc(tupdesc);
2263 : :
2264 : 52 : namestrcpy(&slotname, text_to_cstring(slotname_text));
2265 : 52 : slotent = pgstat_fetch_replslot(slotname);
2266 [ + + ]: 52 : if (!slotent)
2267 : : {
2268 : : /*
2269 : : * If the slot is not found, initialise its stats. This is possible if
2270 : : * the create slot message is lost.
2271 : : */
2272 : 2 : memset(&allzero, 0, sizeof(PgStat_StatReplSlotEntry));
2273 : 2 : slotent = &allzero;
2274 : : }
2275 : :
2276 : 52 : values[0] = CStringGetTextDatum(NameStr(slotname));
2277 : 52 : values[1] = Int64GetDatum(slotent->spill_txns);
2278 : 52 : values[2] = Int64GetDatum(slotent->spill_count);
2279 : 52 : values[3] = Int64GetDatum(slotent->spill_bytes);
2280 : 52 : values[4] = Int64GetDatum(slotent->stream_txns);
2281 : 52 : values[5] = Int64GetDatum(slotent->stream_count);
2282 : 52 : values[6] = Int64GetDatum(slotent->stream_bytes);
2283 : 52 : values[7] = Int64GetDatum(slotent->mem_exceeded_count);
2284 : 52 : values[8] = Int64GetDatum(slotent->total_txns);
2285 : 52 : values[9] = Int64GetDatum(slotent->total_bytes);
2286 : 52 : values[10] = Int64GetDatum(slotent->slotsync_skip_count);
2287 : :
2288 [ + + ]: 52 : if (slotent->slotsync_last_skip == 0)
2289 : 51 : nulls[11] = true;
2290 : : else
2291 : 1 : values[11] = TimestampTzGetDatum(slotent->slotsync_last_skip);
2292 : :
2293 [ + + ]: 52 : if (slotent->stat_reset_timestamp == 0)
2294 : 28 : nulls[12] = true;
2295 : : else
2296 : 24 : values[12] = TimestampTzGetDatum(slotent->stat_reset_timestamp);
2297 : :
2298 : : /* Returns the record as Datum */
2299 : 52 : PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
2300 : : }
2301 : :
2302 : : /*
2303 : : * Get the subscription statistics for the given subscription. If the
2304 : : * subscription statistics is not available, return all-zeros stats.
2305 : : */
2306 : : Datum
2307 : 39 : pg_stat_get_subscription_stats(PG_FUNCTION_ARGS)
2308 : : {
2309 : : #define PG_STAT_GET_SUBSCRIPTION_STATS_COLS 13
2310 : 39 : Oid subid = PG_GETARG_OID(0);
2311 : : TupleDesc tupdesc;
2312 : 39 : Datum values[PG_STAT_GET_SUBSCRIPTION_STATS_COLS] = {0};
2313 : 39 : bool nulls[PG_STAT_GET_SUBSCRIPTION_STATS_COLS] = {0};
2314 : : PgStat_StatSubEntry *subentry;
2315 : : PgStat_StatSubEntry allzero;
2316 : 39 : int i = 0;
2317 : :
2318 : : /* Get subscription stats */
2319 : 39 : subentry = pgstat_fetch_stat_subscription(subid);
2320 : :
2321 : : /* Initialise attributes information in the tuple descriptor */
2322 : 39 : tupdesc = CreateTemplateTupleDesc(PG_STAT_GET_SUBSCRIPTION_STATS_COLS);
2323 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 1, "subid",
2324 : : OIDOID, -1, 0);
2325 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 2, "apply_error_count",
2326 : : INT8OID, -1, 0);
2327 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 3, "sync_seq_error_count",
2328 : : INT8OID, -1, 0);
2329 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 4, "sync_table_error_count",
2330 : : INT8OID, -1, 0);
2331 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 5, "confl_insert_exists",
2332 : : INT8OID, -1, 0);
2333 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 6, "confl_update_origin_differs",
2334 : : INT8OID, -1, 0);
2335 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 7, "confl_update_exists",
2336 : : INT8OID, -1, 0);
2337 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 8, "confl_update_deleted",
2338 : : INT8OID, -1, 0);
2339 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 9, "confl_update_missing",
2340 : : INT8OID, -1, 0);
2341 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 10, "confl_delete_origin_differs",
2342 : : INT8OID, -1, 0);
2343 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 11, "confl_delete_missing",
2344 : : INT8OID, -1, 0);
2345 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 12, "confl_multiple_unique_conflicts",
2346 : : INT8OID, -1, 0);
2347 : 39 : TupleDescInitEntry(tupdesc, (AttrNumber) 13, "stats_reset",
2348 : : TIMESTAMPTZOID, -1, 0);
2349 : 39 : TupleDescFinalize(tupdesc);
2350 : 39 : BlessTupleDesc(tupdesc);
2351 : :
2352 [ - + ]: 39 : if (!subentry)
2353 : : {
2354 : : /* If the subscription is not found, initialise its stats */
2355 : 0 : memset(&allzero, 0, sizeof(PgStat_StatSubEntry));
2356 : 0 : subentry = &allzero;
2357 : : }
2358 : :
2359 : : /* subid */
2360 : 39 : values[i++] = ObjectIdGetDatum(subid);
2361 : :
2362 : : /* apply_error_count */
2363 : 39 : values[i++] = Int64GetDatum(subentry->apply_error_count);
2364 : :
2365 : : /* sync_seq_error_count */
2366 : 39 : values[i++] = Int64GetDatum(subentry->sync_seq_error_count);
2367 : :
2368 : : /* sync_table_error_count */
2369 : 39 : values[i++] = Int64GetDatum(subentry->sync_table_error_count);
2370 : :
2371 : : /* conflict count */
2372 [ + + ]: 351 : for (int nconflict = 0; nconflict < CONFLICT_NUM_TYPES; nconflict++)
2373 : 312 : values[i++] = Int64GetDatum(subentry->conflict_count[nconflict]);
2374 : :
2375 : : /* stats_reset */
2376 [ + + ]: 39 : if (subentry->stat_reset_timestamp == 0)
2377 : 17 : nulls[i] = true;
2378 : : else
2379 : 22 : values[i] = TimestampTzGetDatum(subentry->stat_reset_timestamp);
2380 : :
2381 : : Assert(i + 1 == PG_STAT_GET_SUBSCRIPTION_STATS_COLS);
2382 : :
2383 : : /* Returns the record as Datum */
2384 : 39 : PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
2385 : : }
2386 : :
2387 : : /*
2388 : : * Checks for presence of stats for object with provided kind, database oid,
2389 : : * object oid.
2390 : : *
2391 : : * This is useful for tests, but not really anything else. Therefore not
2392 : : * documented.
2393 : : */
2394 : : Datum
2395 : 99 : pg_stat_have_stats(PG_FUNCTION_ARGS)
2396 : : {
2397 : 99 : char *stats_type = text_to_cstring(PG_GETARG_TEXT_P(0));
2398 : 99 : Oid dboid = PG_GETARG_OID(1);
2399 : 99 : uint64 objid = PG_GETARG_INT64(2);
2400 : 99 : PgStat_Kind kind = pgstat_get_kind_from_str(stats_type);
2401 : :
2402 : 95 : PG_RETURN_BOOL(pgstat_have_entry(kind, dboid, objid));
2403 : : }
|
