?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix xslt_process() to ensure that it inserts a NULL terminator after the
[PostgreSQL.git] / src / include / pgstat.h
blob91ad364928627f81d5b7fd4b7c8e304a9ef722b6
1 /* ----------
2 * pgstat.h
3 *
4 * Definitions for the PostgreSQL statistics collector daemon.
5 *
6 * Copyright (c) 2001-2009, PostgreSQL Global Development Group
7 *
8 * $PostgreSQL$
9 * ----------
10 */
11 #ifndef PGSTAT_H
12 #define PGSTAT_H
13
14 #include "libpq/pqcomm.h"
15 #include "portability/instr_time.h"
16 #include "utils/hsearch.h"
17 #include "utils/relcache.h"
18 #include "utils/timestamp.h"
19
20
21 /* Values for track_functions GUC variable --- order is significant! */
22 typedef enum TrackFunctionsLevel
23 {
24 TRACK_FUNC_OFF,
25 TRACK_FUNC_PL,
26 TRACK_FUNC_ALL
27 } TrackFunctionsLevel;
28
29 /* ----------
30 * The types of backend -> collector messages
31 * ----------
32 */
33 typedef enum StatMsgType
34 {
35 PGSTAT_MTYPE_DUMMY,
36 PGSTAT_MTYPE_INQUIRY,
37 PGSTAT_MTYPE_TABSTAT,
38 PGSTAT_MTYPE_TABPURGE,
39 PGSTAT_MTYPE_DROPDB,
40 PGSTAT_MTYPE_RESETCOUNTER,
41 PGSTAT_MTYPE_AUTOVAC_START,
42 PGSTAT_MTYPE_VACUUM,
43 PGSTAT_MTYPE_ANALYZE,
44 PGSTAT_MTYPE_BGWRITER,
45 PGSTAT_MTYPE_FUNCSTAT,
46 PGSTAT_MTYPE_FUNCPURGE
47 } StatMsgType;
48
49 /* ----------
50 * The data type used for counters.
51 * ----------
52 */
53 typedef int64 PgStat_Counter;
54
55 /* ----------
56 * PgStat_TableCounts The actual per-table counts kept by a backend
57 *
58 * This struct should contain only actual event counters, because we memcmp
59 * it against zeroes to detect whether there are any counts to transmit.
60 * It is a component of PgStat_TableStatus (within-backend state) and
61 * PgStat_TableEntry (the transmitted message format).
62 *
63 * Note: for a table, tuples_returned is the number of tuples successfully
64 * fetched by heap_getnext, while tuples_fetched is the number of tuples
65 * successfully fetched by heap_fetch under the control of bitmap indexscans.
66 * For an index, tuples_returned is the number of index entries returned by
67 * the index AM, while tuples_fetched is the number of tuples successfully
68 * fetched by heap_fetch under the control of simple indexscans for this index.
69 *
70 * tuples_inserted/updated/deleted/hot_updated count attempted actions,
71 * regardless of whether the transaction committed. new_live_tuples and
72 * new_dead_tuples are properly adjusted depending on commit or abort.
73 * Note that new_live_tuples and new_dead_tuples can be negative!
74 * ----------
75 */
76 typedef struct PgStat_TableCounts
77 {
78 PgStat_Counter t_numscans;
79
80 PgStat_Counter t_tuples_returned;
81 PgStat_Counter t_tuples_fetched;
82
83 PgStat_Counter t_tuples_inserted;
84 PgStat_Counter t_tuples_updated;
85 PgStat_Counter t_tuples_deleted;
86 PgStat_Counter t_tuples_hot_updated;
87
88 PgStat_Counter t_new_live_tuples;
89 PgStat_Counter t_new_dead_tuples;
90
91 PgStat_Counter t_blocks_fetched;
92 PgStat_Counter t_blocks_hit;
93 } PgStat_TableCounts;
94
95
96 /* ------------------------------------------------------------
97 * Structures kept in backend local memory while accumulating counts
98 * ------------------------------------------------------------
99 */
100
101
102 /* ----------
103 * PgStat_TableStatus Per-table status within a backend
104 *
105 * Most of the event counters are nontransactional, ie, we count events
106 * in committed and aborted transactions alike. For these, we just count
107 * directly in the PgStat_TableStatus. However, new_live_tuples and
108 * new_dead_tuples must be derived from tuple insertion and deletion counts
109 * with awareness of whether the transaction or subtransaction committed or
110 * aborted. Hence, we also keep a stack of per-(sub)transaction status
111 * records for every table modified in the current transaction. At commit
112 * or abort, we propagate tuples_inserted and tuples_deleted up to the
113 * parent subtransaction level, or out to the parent PgStat_TableStatus,
114 * as appropriate.
115 * ----------
116 */
117 typedef struct PgStat_TableStatus
118 {
119 Oid t_id; /* table's OID */
120 bool t_shared; /* is it a shared catalog? */
121 struct PgStat_TableXactStatus *trans; /* lowest subxact's counts */
122 PgStat_TableCounts t_counts; /* event counts to be sent */
123 } PgStat_TableStatus;
124
125 /* ----------
126 * PgStat_TableXactStatus Per-table, per-subtransaction status
127 * ----------
128 */
129 typedef struct PgStat_TableXactStatus
130 {
131 PgStat_Counter tuples_inserted; /* tuples inserted in (sub)xact */
132 PgStat_Counter tuples_deleted; /* tuples deleted in (sub)xact */
133 int nest_level; /* subtransaction nest level */
134 /* links to other structs for same relation: */
135 struct PgStat_TableXactStatus *upper; /* next higher subxact if any */
136 PgStat_TableStatus *parent; /* per-table status */
137 /* structs of same subxact level are linked here: */
138 struct PgStat_TableXactStatus *next; /* next of same subxact */
139 } PgStat_TableXactStatus;
140
141
142 /* ------------------------------------------------------------
143 * Message formats follow
144 * ------------------------------------------------------------
145 */
146
147
148 /* ----------
149 * PgStat_MsgHdr The common message header
150 * ----------
151 */
152 typedef struct PgStat_MsgHdr
153 {
154 StatMsgType m_type;
155 int m_size;
156 } PgStat_MsgHdr;
157
158 /* ----------
159 * Space available in a message. This will keep the UDP packets below 1K,
160 * which should fit unfragmented into the MTU of the lo interface on most
161 * platforms. Does anybody care for platforms where it doesn't?
162 * ----------
163 */
164 #define PGSTAT_MSG_PAYLOAD (1000 - sizeof(PgStat_MsgHdr))
165
166
167 /* ----------
168 * PgStat_MsgDummy A dummy message, ignored by the collector
169 * ----------
170 */
171 typedef struct PgStat_MsgDummy
172 {
173 PgStat_MsgHdr m_hdr;
174 } PgStat_MsgDummy;
175
176
177 /* ----------
178 * PgStat_MsgInquiry Sent by a backend to ask the collector
179 * to write the stats file.
180 * ----------
181 */
182
183 typedef struct PgStat_MsgInquiry
184 {
185 PgStat_MsgHdr m_hdr;
186 TimestampTz inquiry_time; /* minimum acceptable file timestamp */
187 } PgStat_MsgInquiry;
188
189
190 /* ----------
191 * PgStat_TableEntry Per-table info in a MsgTabstat
192 * ----------
193 */
194 typedef struct PgStat_TableEntry
195 {
196 Oid t_id;
197 PgStat_TableCounts t_counts;
198 } PgStat_TableEntry;
199
200 /* ----------
201 * PgStat_MsgTabstat Sent by the backend to report table
202 * and buffer access statistics.
203 * ----------
204 */
205 #define PGSTAT_NUM_TABENTRIES \
206 ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - 3 * sizeof(int)) \
207 / sizeof(PgStat_TableEntry))
208
209 typedef struct PgStat_MsgTabstat
210 {
211 PgStat_MsgHdr m_hdr;
212 Oid m_databaseid;
213 int m_nentries;
214 int m_xact_commit;
215 int m_xact_rollback;
216 PgStat_TableEntry m_entry[PGSTAT_NUM_TABENTRIES];
217 } PgStat_MsgTabstat;
218
219
220 /* ----------
221 * PgStat_MsgTabpurge Sent by the backend to tell the collector
222 * about dead tables.
223 * ----------
224 */
225 #define PGSTAT_NUM_TABPURGE \
226 ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \
227 / sizeof(Oid))
228
229 typedef struct PgStat_MsgTabpurge
230 {
231 PgStat_MsgHdr m_hdr;
232 Oid m_databaseid;
233 int m_nentries;
234 Oid m_tableid[PGSTAT_NUM_TABPURGE];
235 } PgStat_MsgTabpurge;
236
237
238 /* ----------
239 * PgStat_MsgDropdb Sent by the backend to tell the collector
240 * about a dropped database
241 * ----------
242 */
243 typedef struct PgStat_MsgDropdb
244 {
245 PgStat_MsgHdr m_hdr;
246 Oid m_databaseid;
247 } PgStat_MsgDropdb;
248
249
250 /* ----------
251 * PgStat_MsgResetcounter Sent by the backend to tell the collector
252 * to reset counters
253 * ----------
254 */
255 typedef struct PgStat_MsgResetcounter
256 {
257 PgStat_MsgHdr m_hdr;
258 Oid m_databaseid;
259 } PgStat_MsgResetcounter;
260
261
262 /* ----------
263 * PgStat_MsgAutovacStart Sent by the autovacuum daemon to signal
264 * that a database is going to be processed
265 * ----------
266 */
267 typedef struct PgStat_MsgAutovacStart
268 {
269 PgStat_MsgHdr m_hdr;
270 Oid m_databaseid;
271 TimestampTz m_start_time;
272 } PgStat_MsgAutovacStart;
273
274
275 /* ----------
276 * PgStat_MsgVacuum Sent by the backend or autovacuum daemon
277 * after VACUUM or VACUUM ANALYZE
278 * ----------
279 */
280 typedef struct PgStat_MsgVacuum
281 {
282 PgStat_MsgHdr m_hdr;
283 Oid m_databaseid;
284 Oid m_tableoid;
285 bool m_analyze;
286 bool m_autovacuum;
287 bool m_scanned_all;
288 TimestampTz m_vacuumtime;
289 PgStat_Counter m_tuples;
290 } PgStat_MsgVacuum;
291
292
293 /* ----------
294 * PgStat_MsgAnalyze Sent by the backend or autovacuum daemon
295 * after ANALYZE
296 * ----------
297 */
298 typedef struct PgStat_MsgAnalyze
299 {
300 PgStat_MsgHdr m_hdr;
301 Oid m_databaseid;
302 Oid m_tableoid;
303 bool m_autovacuum;
304 TimestampTz m_analyzetime;
305 PgStat_Counter m_live_tuples;
306 PgStat_Counter m_dead_tuples;
307 } PgStat_MsgAnalyze;
308
309
310 /* ----------
311 * PgStat_MsgBgWriter Sent by the bgwriter to update statistics.
312 * ----------
313 */
314 typedef struct PgStat_MsgBgWriter
315 {
316 PgStat_MsgHdr m_hdr;
317
318 PgStat_Counter m_timed_checkpoints;
319 PgStat_Counter m_requested_checkpoints;
320 PgStat_Counter m_buf_written_checkpoints;
321 PgStat_Counter m_buf_written_clean;
322 PgStat_Counter m_maxwritten_clean;
323 PgStat_Counter m_buf_written_backend;
324 PgStat_Counter m_buf_alloc;
325 } PgStat_MsgBgWriter;
326
327
328 /* ----------
329 * PgStat_FunctionCounts The actual per-function counts kept by a backend
330 *
331 * This struct should contain only actual event counters, because we memcmp
332 * it against zeroes to detect whether there are any counts to transmit.
333 *
334 * Note that the time counters are in instr_time format here. We convert to
335 * microseconds in PgStat_Counter format when transmitting to the collector.
336 * ----------
337 */
338 typedef struct PgStat_FunctionCounts
339 {
340 PgStat_Counter f_numcalls;
341 instr_time f_time;
342 instr_time f_time_self;
343 } PgStat_FunctionCounts;
344
345 /* ----------
346 * PgStat_BackendFunctionEntry Entry in backend's per-function hash table
347 * ----------
348 */
349 typedef struct PgStat_BackendFunctionEntry
350 {
351 Oid f_id;
352 PgStat_FunctionCounts f_counts;
353 } PgStat_BackendFunctionEntry;
354
355 /* ----------
356 * PgStat_FunctionEntry Per-function info in a MsgFuncstat
357 * ----------
358 */
359 typedef struct PgStat_FunctionEntry
360 {
361 Oid f_id;
362 PgStat_Counter f_numcalls;
363 PgStat_Counter f_time; /* times in microseconds */
364 PgStat_Counter f_time_self;
365 } PgStat_FunctionEntry;
366
367 /* ----------
368 * PgStat_MsgFuncstat Sent by the backend to report function
369 * usage statistics.
370 * ----------
371 */
372 #define PGSTAT_NUM_FUNCENTRIES \
373 ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \
374 / sizeof(PgStat_FunctionEntry))
375
376 typedef struct PgStat_MsgFuncstat
377 {
378 PgStat_MsgHdr m_hdr;
379 Oid m_databaseid;
380 int m_nentries;
381 PgStat_FunctionEntry m_entry[PGSTAT_NUM_FUNCENTRIES];
382 } PgStat_MsgFuncstat;
383
384 /* ----------
385 * PgStat_MsgFuncpurge Sent by the backend to tell the collector
386 * about dead functions.
387 * ----------
388 */
389 #define PGSTAT_NUM_FUNCPURGE \
390 ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \
391 / sizeof(Oid))
392
393 typedef struct PgStat_MsgFuncpurge
394 {
395 PgStat_MsgHdr m_hdr;
396 Oid m_databaseid;
397 int m_nentries;
398 Oid m_functionid[PGSTAT_NUM_FUNCPURGE];
399 } PgStat_MsgFuncpurge;
400
401
402 /* ----------
403 * PgStat_Msg Union over all possible messages.
404 * ----------
405 */
406 typedef union PgStat_Msg
407 {
408 PgStat_MsgHdr msg_hdr;
409 PgStat_MsgDummy msg_dummy;
410 PgStat_MsgInquiry msg_inquiry;
411 PgStat_MsgTabstat msg_tabstat;
412 PgStat_MsgTabpurge msg_tabpurge;
413 PgStat_MsgDropdb msg_dropdb;
414 PgStat_MsgResetcounter msg_resetcounter;
415 PgStat_MsgAutovacStart msg_autovacuum;
416 PgStat_MsgVacuum msg_vacuum;
417 PgStat_MsgAnalyze msg_analyze;
418 PgStat_MsgBgWriter msg_bgwriter;
419 PgStat_MsgFuncstat msg_funcstat;
420 PgStat_MsgFuncpurge msg_funcpurge;
421 } PgStat_Msg;
422
423
424 /* ------------------------------------------------------------
425 * Statistic collector data structures follow
426 *
427 * PGSTAT_FILE_FORMAT_ID should be changed whenever any of these
428 * data structures change.
429 * ------------------------------------------------------------
430 */
431
432 #define PGSTAT_FILE_FORMAT_ID 0x01A5BC98
433
434 /* ----------
435 * PgStat_StatDBEntry The collector's data per database
436 * ----------
437 */
438 typedef struct PgStat_StatDBEntry
439 {
440 Oid databaseid;
441 PgStat_Counter n_xact_commit;
442 PgStat_Counter n_xact_rollback;
443 PgStat_Counter n_blocks_fetched;
444 PgStat_Counter n_blocks_hit;
445 PgStat_Counter n_tuples_returned;
446 PgStat_Counter n_tuples_fetched;
447 PgStat_Counter n_tuples_inserted;
448 PgStat_Counter n_tuples_updated;
449 PgStat_Counter n_tuples_deleted;
450 TimestampTz last_autovac_time;
451
452 /*
453 * tables and functions must be last in the struct, because we don't write
454 * the pointers out to the stats file.
455 */
456 HTAB *tables;
457 HTAB *functions;
458 } PgStat_StatDBEntry;
459
460
461 /* ----------
462 * PgStat_StatTabEntry The collector's data per table (or index)
463 * ----------
464 */
465 typedef struct PgStat_StatTabEntry
466 {
467 Oid tableid;
468
469 PgStat_Counter numscans;
470
471 PgStat_Counter tuples_returned;
472 PgStat_Counter tuples_fetched;
473
474 PgStat_Counter tuples_inserted;
475 PgStat_Counter tuples_updated;
476 PgStat_Counter tuples_deleted;
477 PgStat_Counter tuples_hot_updated;
478
479 PgStat_Counter n_live_tuples;
480 PgStat_Counter n_dead_tuples;
481 PgStat_Counter last_anl_tuples;
482
483 PgStat_Counter blocks_fetched;
484 PgStat_Counter blocks_hit;
485
486 TimestampTz vacuum_timestamp; /* user initiated vacuum */
487 TimestampTz autovac_vacuum_timestamp; /* autovacuum initiated */
488 TimestampTz analyze_timestamp; /* user initiated */
489 TimestampTz autovac_analyze_timestamp; /* autovacuum initiated */
490 } PgStat_StatTabEntry;
491
492
493 /* ----------
494 * PgStat_StatFuncEntry The collector's data per function
495 * ----------
496 */
497 typedef struct PgStat_StatFuncEntry
498 {
499 Oid functionid;
500
501 PgStat_Counter f_numcalls;
502
503 PgStat_Counter f_time; /* times in microseconds */
504 PgStat_Counter f_time_self;
505 } PgStat_StatFuncEntry;
506
507
508 /*
509 * Global statistics kept in the stats collector
510 */
511 typedef struct PgStat_GlobalStats
512 {
513 TimestampTz stats_timestamp; /* time of stats file update */
514 PgStat_Counter timed_checkpoints;
515 PgStat_Counter requested_checkpoints;
516 PgStat_Counter buf_written_checkpoints;
517 PgStat_Counter buf_written_clean;
518 PgStat_Counter maxwritten_clean;
519 PgStat_Counter buf_written_backend;
520 PgStat_Counter buf_alloc;
521 } PgStat_GlobalStats;
522
523
524 /* ----------
525 * Shared-memory data structures
526 * ----------
527 */
528
529 /* ----------
530 * PgBackendStatus
531 *
532 * Each live backend maintains a PgBackendStatus struct in shared memory
533 * showing its current activity. (The structs are allocated according to
534 * BackendId, but that is not critical.) Note that the collector process
535 * has no involvement in, or even access to, these structs.
536 * ----------
537 */
538 typedef struct PgBackendStatus
539 {
540 /*
541 * To avoid locking overhead, we use the following protocol: a backend
542 * increments st_changecount before modifying its entry, and again after
543 * finishing a modification. A would-be reader should note the value of
544 * st_changecount, copy the entry into private memory, then check
545 * st_changecount again. If the value hasn't changed, and if it's even,
546 * the copy is valid; otherwise start over. This makes updates cheap
547 * while reads are potentially expensive, but that's the tradeoff we want.
548 */
549 int st_changecount;
550
551 /* The entry is valid iff st_procpid > 0, unused if st_procpid == 0 */
552 int st_procpid;
553
554 /* Times when current backend, transaction, and activity started */
555 TimestampTz st_proc_start_timestamp;
556 TimestampTz st_xact_start_timestamp;
557 TimestampTz st_activity_start_timestamp;
558
559 /* Database OID, owning user's OID, connection client address */
560 Oid st_databaseid;
561 Oid st_userid;
562 SockAddr st_clientaddr;
563
564 /* Is backend currently waiting on an lmgr lock? */
565 bool st_waiting;
566
567 /* current command string; MUST be null-terminated */
568 char *st_activity;
569 } PgBackendStatus;
570
571 /*
572 * Working state needed to accumulate per-function-call timing statistics.
573 */
574 typedef struct PgStat_FunctionCallUsage
575 {
576 /* Link to function's hashtable entry (must still be there at exit!) */
577 /* NULL means we are not tracking the current function call */
578 PgStat_FunctionCounts *fs;
579 /* Total time previously charged to function, as of function start */
580 instr_time save_f_time;
581 /* Backend-wide total time as of function start */
582 instr_time save_total;
583 /* system clock as of function start */
584 instr_time f_start;
585 } PgStat_FunctionCallUsage;
586
587
588 /* ----------
589 * GUC parameters
590 * ----------
591 */
592 extern bool pgstat_track_activities;
593 extern bool pgstat_track_counts;
594 extern int pgstat_track_functions;
595 extern PGDLLIMPORT int pgstat_track_activity_query_size;
596 extern char *pgstat_stat_tmpname;
597 extern char *pgstat_stat_filename;
598
599 /*
600 * BgWriter statistics counters are updated directly by bgwriter and bufmgr
601 */
602 extern PgStat_MsgBgWriter BgWriterStats;
603
604 /* ----------
605 * Functions called from postmaster
606 * ----------
607 */
608 extern Size BackendStatusShmemSize(void);
609 extern void CreateSharedBackendStatus(void);
610
611 extern void pgstat_init(void);
612 extern int pgstat_start(void);
613 extern void pgstat_reset_all(void);
614 extern void allow_immediate_pgstat_restart(void);
615
616 #ifdef EXEC_BACKEND
617 extern void PgstatCollectorMain(int argc, char *argv[]);
618 #endif
619
620
621 /* ----------
622 * Functions called from backends
623 * ----------
624 */
625 extern void pgstat_ping(void);
626
627 extern void pgstat_report_stat(bool force);
628 extern void pgstat_vacuum_stat(void);
629 extern void pgstat_drop_database(Oid databaseid);
630
631 extern void pgstat_clear_snapshot(void);
632 extern void pgstat_reset_counters(void);
633
634 extern void pgstat_report_autovac(Oid dboid);
635 extern void pgstat_report_vacuum(Oid tableoid, bool shared, bool scanned_all,
636 bool analyze, PgStat_Counter tuples);
637 extern void pgstat_report_analyze(Relation rel,
638 PgStat_Counter livetuples,
639 PgStat_Counter deadtuples);
640
641 extern void pgstat_initialize(void);
642 extern void pgstat_bestart(void);
643
644 extern void pgstat_report_activity(const char *what);
645 extern void pgstat_report_xact_timestamp(TimestampTz tstamp);
646 extern void pgstat_report_waiting(bool waiting);
647 extern const char *pgstat_get_backend_current_activity(int pid, bool checkUser);
648
649 extern void pgstat_initstats(Relation rel);
650
651 /* nontransactional event counts are simple enough to inline */
652
653 #define pgstat_count_heap_scan(rel) \
654 do { \
655 if (pgstat_track_counts && (rel)->pgstat_info != NULL) \
656 (rel)->pgstat_info->t_counts.t_numscans++; \
657 } while (0)
658 #define pgstat_count_heap_getnext(rel) \
659 do { \
660 if (pgstat_track_counts && (rel)->pgstat_info != NULL) \
661 (rel)->pgstat_info->t_counts.t_tuples_returned++; \
662 } while (0)
663 #define pgstat_count_heap_fetch(rel) \
664 do { \
665 if (pgstat_track_counts && (rel)->pgstat_info != NULL) \
666 (rel)->pgstat_info->t_counts.t_tuples_fetched++; \
667 } while (0)
668 #define pgstat_count_index_scan(rel) \
669 do { \
670 if (pgstat_track_counts && (rel)->pgstat_info != NULL) \
671 (rel)->pgstat_info->t_counts.t_numscans++; \
672 } while (0)
673 #define pgstat_count_index_tuples(rel, n) \
674 do { \
675 if (pgstat_track_counts && (rel)->pgstat_info != NULL) \
676 (rel)->pgstat_info->t_counts.t_tuples_returned += (n); \
677 } while (0)
678 #define pgstat_count_buffer_read(rel) \
679 do { \
680 if (pgstat_track_counts && (rel)->pgstat_info != NULL) \
681 (rel)->pgstat_info->t_counts.t_blocks_fetched++; \
682 } while (0)
683 #define pgstat_count_buffer_hit(rel) \
684 do { \
685 if (pgstat_track_counts && (rel)->pgstat_info != NULL) \
686 (rel)->pgstat_info->t_counts.t_blocks_hit++; \
687 } while (0)
688
689 extern void pgstat_count_heap_insert(Relation rel);
690 extern void pgstat_count_heap_update(Relation rel, bool hot);
691 extern void pgstat_count_heap_delete(Relation rel);
692 extern void pgstat_update_heap_dead_tuples(Relation rel, int delta);
693
694 extern void pgstat_init_function_usage(FunctionCallInfoData *fcinfo,
695 PgStat_FunctionCallUsage *fcu);
696 extern void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu,
697 bool finalize);
698
699 extern void AtEOXact_PgStat(bool isCommit);
700 extern void AtEOSubXact_PgStat(bool isCommit, int nestDepth);
701
702 extern void AtPrepare_PgStat(void);
703 extern void PostPrepare_PgStat(void);
704
705 extern void pgstat_twophase_postcommit(TransactionId xid, uint16 info,
706 void *recdata, uint32 len);
707 extern void pgstat_twophase_postabort(TransactionId xid, uint16 info,
708 void *recdata, uint32 len);
709
710 extern void pgstat_send_bgwriter(void);
711
712 /* ----------
713 * Support functions for the SQL-callable functions to
714 * generate the pgstat* views.
715 * ----------
716 */
717 extern PgStat_StatDBEntry *pgstat_fetch_stat_dbentry(Oid dbid);
718 extern PgStat_StatTabEntry *pgstat_fetch_stat_tabentry(Oid relid);
719 extern PgBackendStatus *pgstat_fetch_stat_beentry(int beid);
720 extern PgStat_StatFuncEntry *pgstat_fetch_stat_funcentry(Oid funcid);
721 extern int pgstat_fetch_stat_numbackends(void);
722 extern PgStat_GlobalStats *pgstat_fetch_global(void);
723
724 #endif /* PGSTAT_H */
PostgreSQL from CVS