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