Debian Codegraph @

src/backend/utils/activity/pgstat_relation.c

raw
1 /* -------------------------------------------------------------------------
2 *
3 * pgstat_relation.c
4 * Implementation of relation statistics.
5 *
6 * This file contains the implementation of function relation. It is kept
7 * separate from pgstat.c to enforce the line between the statistics access /
8 * storage implementation and the details about individual types of
9 * statistics.
10 *
11 * Copyright (c) 2001-2025, PostgreSQL Global Development Group
12 *
13 * IDENTIFICATION
14 * src/backend/utils/activity/pgstat_relation.c
15 * -------------------------------------------------------------------------
16 */
17
18 #include "postgres.h"
19
20 #include "access/twophase_rmgr.h"
21 #include "access/xact.h"
22 #include "catalog/catalog.h"
23 #include "utils/memutils.h"
24 #include "utils/pgstat_internal.h"
25 #include "utils/rel.h"
26 #include "utils/timestamp.h"
27
28
29 /* Record that's written to 2PC state file when pgstat state is persisted */
30 typedef struct TwoPhasePgStatRecord
31 {
32 PgStat_Counter tuples_inserted; /* tuples inserted in xact */
33 PgStat_Counter tuples_updated; /* tuples updated in xact */
34 PgStat_Counter tuples_deleted; /* tuples deleted in xact */
35 /* tuples i/u/d prior to truncate/drop */
36 PgStat_Counter inserted_pre_truncdrop;
37 PgStat_Counter updated_pre_truncdrop;
38 PgStat_Counter deleted_pre_truncdrop;
39 Oid id; /* table's OID */
40 bool shared; /* is it a shared catalog? */
41 bool truncdropped; /* was the relation truncated/dropped? */
42 } TwoPhasePgStatRecord;
43
44
45 static PgStat_TableStatus *pgstat_prep_relation_pending(Oid rel_id, bool isshared);
46 static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level);
47 static void ensure_tabstat_xact_level(PgStat_TableStatus *pgstat_info);
48 static void save_truncdrop_counters(PgStat_TableXactStatus *trans, bool is_drop);
49 static void restore_truncdrop_counters(PgStat_TableXactStatus *trans);
50
51
52 /*
53 * Copy stats between relations. This is used for things like REINDEX
54 * CONCURRENTLY.
55 */
56 void
57 pgstat_copy_relation_stats(Relation dst, Relation src)
58 {
59 PgStat_StatTabEntry *srcstats;
60 PgStatShared_Relation *dstshstats;
61 PgStat_EntryRef *dst_ref;
62
63 srcstats = pgstat_fetch_stat_tabentry_ext(src->rd_rel->relisshared,
64 RelationGetRelid(src));
65 if (!srcstats)
66 return;
67
68 dst_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
69 dst->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
70 RelationGetRelid(dst),
71 false);
72
73 dstshstats = (PgStatShared_Relation *) dst_ref->shared_stats;
74 dstshstats->stats = *srcstats;
75
76 pgstat_unlock_entry(dst_ref);
77 }
78
79 /*
80 * Initialize a relcache entry to count access statistics. Called whenever a
81 * relation is opened.
82 *
83 * We assume that a relcache entry's pgstat_info field is zeroed by relcache.c
84 * when the relcache entry is made; thereafter it is long-lived data.
85 *
86 * This does not create a reference to a stats entry in shared memory, nor
87 * allocate memory for the pending stats. That happens in
88 * pgstat_assoc_relation().
89 */
90 void
91 pgstat_init_relation(Relation rel)
92 {
93 char relkind = rel->rd_rel->relkind;
94
95 /*
96 * We only count stats for relations with storage and partitioned tables
97 */
98 if (!RELKIND_HAS_STORAGE(relkind) && relkind != RELKIND_PARTITIONED_TABLE)
99 {
100 rel->pgstat_enabled = false;
101 rel->pgstat_info = NULL;
102 return;
103 }
104
105 if (!pgstat_track_counts)
106 {
107 if (rel->pgstat_info)
108 pgstat_unlink_relation(rel);
109
110 /* We're not counting at all */
111 rel->pgstat_enabled = false;
112 rel->pgstat_info = NULL;
113 return;
114 }
115
116 rel->pgstat_enabled = true;
117 }
118
119 /*
120 * Prepare for statistics for this relation to be collected.
121 *
122 * This ensures we have a reference to the stats entry before stats can be
123 * generated. That is important because a relation drop in another connection
124 * could otherwise lead to the stats entry being dropped, which then later
125 * would get recreated when flushing stats.
126 *
127 * This is separate from pgstat_init_relation() as it is not uncommon for
128 * relcache entries to be opened without ever getting stats reported.
129 */
130 void
131 pgstat_assoc_relation(Relation rel)
132 {
133 Assert(rel->pgstat_enabled);
134 Assert(rel->pgstat_info == NULL);
135
136 /* Else find or make the PgStat_TableStatus entry, and update link */
137 rel->pgstat_info = pgstat_prep_relation_pending(RelationGetRelid(rel),
138 rel->rd_rel->relisshared);
139
140 /* don't allow link a stats to multiple relcache entries */
141 Assert(rel->pgstat_info->relation == NULL);
142
143 /* mark this relation as the owner */
144 rel->pgstat_info->relation = rel;
145 }
146
147 /*
148 * Break the mutual link between a relcache entry and pending stats entry.
149 * This must be called whenever one end of the link is removed.
150 */
151 void
152 pgstat_unlink_relation(Relation rel)
153 {
154 /* remove the link to stats info if any */
155 if (rel->pgstat_info == NULL)
156 return;
157
158 /* link sanity check */
159 Assert(rel->pgstat_info->relation == rel);
160 rel->pgstat_info->relation = NULL;
161 rel->pgstat_info = NULL;
162 }
163
164 /*
165 * Ensure that stats are dropped if transaction aborts.
166 */
167 void
168 pgstat_create_relation(Relation rel)
169 {
170 pgstat_create_transactional(PGSTAT_KIND_RELATION,
171 rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
172 RelationGetRelid(rel));
173 }
174
175 /*
176 * Ensure that stats are dropped if transaction commits.
177 */
178 void
179 pgstat_drop_relation(Relation rel)
180 {
181 int nest_level = GetCurrentTransactionNestLevel();
182 PgStat_TableStatus *pgstat_info;
183
184 pgstat_drop_transactional(PGSTAT_KIND_RELATION,
185 rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
186 RelationGetRelid(rel));
187
188 if (!pgstat_should_count_relation(rel))
189 return;
190
191 /*
192 * Transactionally set counters to 0. That ensures that accesses to
193 * pg_stat_xact_all_tables inside the transaction show 0.
194 */
195 pgstat_info = rel->pgstat_info;
196 if (pgstat_info->trans &&
197 pgstat_info->trans->nest_level == nest_level)
198 {
199 save_truncdrop_counters(pgstat_info->trans, true);
200 pgstat_info->trans->tuples_inserted = 0;
201 pgstat_info->trans->tuples_updated = 0;
202 pgstat_info->trans->tuples_deleted = 0;
203 }
204 }
205
206 /*
207 * Report that the table was just vacuumed and flush IO statistics.
208 */
209 void
210 pgstat_report_vacuum(Oid tableoid, bool shared,
211 PgStat_Counter livetuples, PgStat_Counter deadtuples,
212 TimestampTz starttime)
213 {
214 PgStat_EntryRef *entry_ref;
215 PgStatShared_Relation *shtabentry;
216 PgStat_StatTabEntry *tabentry;
217 Oid dboid = (shared ? InvalidOid : MyDatabaseId);
218 TimestampTz ts;
219 PgStat_Counter elapsedtime;
220
221 if (!pgstat_track_counts)
222 return;
223
224 /* Store the data in the table's hash table entry. */
225 ts = GetCurrentTimestamp();
226 elapsedtime = TimestampDifferenceMilliseconds(starttime, ts);
227
228 /* block acquiring lock for the same reason as pgstat_report_autovac() */
229 entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
230 dboid, tableoid, false);
231
232 shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
233 tabentry = &shtabentry->stats;
234
235 tabentry->live_tuples = livetuples;
236 tabentry->dead_tuples = deadtuples;
237
238 /*
239 * It is quite possible that a non-aggressive VACUUM ended up skipping
240 * various pages, however, we'll zero the insert counter here regardless.
241 * It's currently used only to track when we need to perform an "insert"
242 * autovacuum, which are mainly intended to freeze newly inserted tuples.
243 * Zeroing this may just mean we'll not try to vacuum the table again
244 * until enough tuples have been inserted to trigger another insert
245 * autovacuum. An anti-wraparound autovacuum will catch any persistent
246 * stragglers.
247 */
248 tabentry->ins_since_vacuum = 0;
249
250 if (AmAutoVacuumWorkerProcess())
251 {
252 tabentry->last_autovacuum_time = ts;
253 tabentry->autovacuum_count++;
254 tabentry->total_autovacuum_time += elapsedtime;
255 }
256 else
257 {
258 tabentry->last_vacuum_time = ts;
259 tabentry->vacuum_count++;
260 tabentry->total_vacuum_time += elapsedtime;
261 }
262
263 pgstat_unlock_entry(entry_ref);
264
265 /*
266 * Flush IO statistics now. pgstat_report_stat() will flush IO stats,
267 * however this will not be called until after an entire autovacuum cycle
268 * is done -- which will likely vacuum many relations -- or until the
269 * VACUUM command has processed all tables and committed.
270 */
271 pgstat_flush_io(false);
272 (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO);
273 }
274
275 /*
276 * Report that the table was just analyzed and flush IO statistics.
277 *
278 * Caller must provide new live- and dead-tuples estimates, as well as a
279 * flag indicating whether to reset the mod_since_analyze counter.
280 */
281 void
282 pgstat_report_analyze(Relation rel,
283 PgStat_Counter livetuples, PgStat_Counter deadtuples,
284 bool resetcounter, TimestampTz starttime)
285 {
286 PgStat_EntryRef *entry_ref;
287 PgStatShared_Relation *shtabentry;
288 PgStat_StatTabEntry *tabentry;
289 Oid dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
290 TimestampTz ts;
291 PgStat_Counter elapsedtime;
292
293 if (!pgstat_track_counts)
294 return;
295
296 /*
297 * Unlike VACUUM, ANALYZE might be running inside a transaction that has
298 * already inserted and/or deleted rows in the target table. ANALYZE will
299 * have counted such rows as live or dead respectively. Because we will
300 * report our counts of such rows at transaction end, we should subtract
301 * off these counts from the update we're making now, else they'll be
302 * double-counted after commit. (This approach also ensures that the
303 * shared stats entry ends up with the right numbers if we abort instead
304 * of committing.)
305 *
306 * Waste no time on partitioned tables, though.
307 */
308 if (pgstat_should_count_relation(rel) &&
309 rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
310 {
311 PgStat_TableXactStatus *trans;
312
313 for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
314 {
315 livetuples -= trans->tuples_inserted - trans->tuples_deleted;
316 deadtuples -= trans->tuples_updated + trans->tuples_deleted;
317 }
318 /* count stuff inserted by already-aborted subxacts, too */
319 deadtuples -= rel->pgstat_info->counts.delta_dead_tuples;
320 /* Since ANALYZE's counts are estimates, we could have underflowed */
321 livetuples = Max(livetuples, 0);
322 deadtuples = Max(deadtuples, 0);
323 }
324
325 /* Store the data in the table's hash table entry. */
326 ts = GetCurrentTimestamp();
327 elapsedtime = TimestampDifferenceMilliseconds(starttime, ts);
328
329 /* block acquiring lock for the same reason as pgstat_report_autovac() */
330 entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION, dboid,
331 RelationGetRelid(rel),
332 false);
333 /* can't get dropped while accessed */
334 Assert(entry_ref != NULL && entry_ref->shared_stats != NULL);
335
336 shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
337 tabentry = &shtabentry->stats;
338
339 tabentry->live_tuples = livetuples;
340 tabentry->dead_tuples = deadtuples;
341
342 /*
343 * If commanded, reset mod_since_analyze to zero. This forgets any
344 * changes that were committed while the ANALYZE was in progress, but we
345 * have no good way to estimate how many of those there were.
346 */
347 if (resetcounter)
348 tabentry->mod_since_analyze = 0;
349
350 if (AmAutoVacuumWorkerProcess())
351 {
352 tabentry->last_autoanalyze_time = ts;
353 tabentry->autoanalyze_count++;
354 tabentry->total_autoanalyze_time += elapsedtime;
355 }
356 else
357 {
358 tabentry->last_analyze_time = ts;
359 tabentry->analyze_count++;
360 tabentry->total_analyze_time += elapsedtime;
361 }
362
363 pgstat_unlock_entry(entry_ref);
364
365 /* see pgstat_report_vacuum() */
366 pgstat_flush_io(false);
367 (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO);
368 }
369
370 /*
371 * count a tuple insertion of n tuples
372 */
373 void
374 pgstat_count_heap_insert(Relation rel, PgStat_Counter n)
375 {
376 if (pgstat_should_count_relation(rel))
377 {
378 PgStat_TableStatus *pgstat_info = rel->pgstat_info;
379
380 ensure_tabstat_xact_level(pgstat_info);
381 pgstat_info->trans->tuples_inserted += n;
382 }
383 }
384
385 /*
386 * count a tuple update
387 */
388 void
389 pgstat_count_heap_update(Relation rel, bool hot, bool newpage)
390 {
391 Assert(!(hot && newpage));
392
393 if (pgstat_should_count_relation(rel))
394 {
395 PgStat_TableStatus *pgstat_info = rel->pgstat_info;
396
397 ensure_tabstat_xact_level(pgstat_info);
398 pgstat_info->trans->tuples_updated++;
399
400 /*
401 * tuples_hot_updated and tuples_newpage_updated counters are
402 * nontransactional, so just advance them
403 */
404 if (hot)
405 pgstat_info->counts.tuples_hot_updated++;
406 else if (newpage)
407 pgstat_info->counts.tuples_newpage_updated++;
408 }
409 }
410
411 /*
412 * count a tuple deletion
413 */
414 void
415 pgstat_count_heap_delete(Relation rel)
416 {
417 if (pgstat_should_count_relation(rel))
418 {
419 PgStat_TableStatus *pgstat_info = rel->pgstat_info;
420
421 ensure_tabstat_xact_level(pgstat_info);
422 pgstat_info->trans->tuples_deleted++;
423 }
424 }
425
426 /*
427 * update tuple counters due to truncate
428 */
429 void
430 pgstat_count_truncate(Relation rel)
431 {
432 if (pgstat_should_count_relation(rel))
433 {
434 PgStat_TableStatus *pgstat_info = rel->pgstat_info;
435
436 ensure_tabstat_xact_level(pgstat_info);
437 save_truncdrop_counters(pgstat_info->trans, false);
438 pgstat_info->trans->tuples_inserted = 0;
439 pgstat_info->trans->tuples_updated = 0;
440 pgstat_info->trans->tuples_deleted = 0;
441 }
442 }
443
444 /*
445 * update dead-tuples count
446 *
447 * The semantics of this are that we are reporting the nontransactional
448 * recovery of "delta" dead tuples; so delta_dead_tuples decreases
449 * rather than increasing, and the change goes straight into the per-table
450 * counter, not into transactional state.
451 */
452 void
453 pgstat_update_heap_dead_tuples(Relation rel, int delta)
454 {
455 if (pgstat_should_count_relation(rel))
456 {
457 PgStat_TableStatus *pgstat_info = rel->pgstat_info;
458
459 pgstat_info->counts.delta_dead_tuples -= delta;
460 }
461 }
462
463 /*
464 * Support function for the SQL-callable pgstat* functions. Returns
465 * the collected statistics for one table or NULL. NULL doesn't mean
466 * that the table doesn't exist, just that there are no statistics, so the
467 * caller is better off to report ZERO instead.
468 */
469 PgStat_StatTabEntry *
470 pgstat_fetch_stat_tabentry(Oid relid)
471 {
472 return pgstat_fetch_stat_tabentry_ext(IsSharedRelation(relid), relid);
473 }
474
475 /*
476 * More efficient version of pgstat_fetch_stat_tabentry(), allowing to specify
477 * whether the to-be-accessed table is a shared relation or not.
478 */
479 PgStat_StatTabEntry *
480 pgstat_fetch_stat_tabentry_ext(bool shared, Oid reloid)
481 {
482 Oid dboid = (shared ? InvalidOid : MyDatabaseId);
483
484 return (PgStat_StatTabEntry *)
485 pgstat_fetch_entry(PGSTAT_KIND_RELATION, dboid, reloid);
486 }
487
488 /*
489 * find any existing PgStat_TableStatus entry for rel
490 *
491 * Find any existing PgStat_TableStatus entry for rel_id in the current
492 * database. If not found, try finding from shared tables.
493 *
494 * If an entry is found, copy it and increment the copy's counters with their
495 * subtransaction counterparts, then return the copy. The caller may need to
496 * pfree() the copy.
497 *
498 * If no entry found, return NULL, don't create a new one.
499 */
500 PgStat_TableStatus *
501 find_tabstat_entry(Oid rel_id)
502 {
503 PgStat_EntryRef *entry_ref;
504 PgStat_TableXactStatus *trans;
505 PgStat_TableStatus *tabentry = NULL;
506 PgStat_TableStatus *tablestatus = NULL;
507
508 entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, MyDatabaseId, rel_id);
509 if (!entry_ref)
510 {
511 entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, InvalidOid, rel_id);
512 if (!entry_ref)
513 return tablestatus;
514 }
515
516 tabentry = (PgStat_TableStatus *) entry_ref->pending;
517 tablestatus = palloc(sizeof(PgStat_TableStatus));
518 *tablestatus = *tabentry;
519
520 /*
521 * Reset tablestatus->trans in the copy of PgStat_TableStatus as it may
522 * point to a shared memory area. Its data is saved below, so removing it
523 * does not matter.
524 */
525 tablestatus->trans = NULL;
526
527 /*
528 * Live subtransaction counts are not included yet. This is not a hot
529 * code path so reconcile tuples_inserted, tuples_updated and
530 * tuples_deleted even if the caller may not be interested in this data.
531 */
532 for (trans = tabentry->trans; trans != NULL; trans = trans->upper)
533 {
534 tablestatus->counts.tuples_inserted += trans->tuples_inserted;
535 tablestatus->counts.tuples_updated += trans->tuples_updated;
536 tablestatus->counts.tuples_deleted += trans->tuples_deleted;
537 }
538
539 return tablestatus;
540 }
541
542 /*
543 * Perform relation stats specific end-of-transaction work. Helper for
544 * AtEOXact_PgStat.
545 *
546 * Transfer transactional insert/update counts into the base tabstat entries.
547 * We don't bother to free any of the transactional state, since it's all in
548 * TopTransactionContext and will go away anyway.
549 */
550 void
551 AtEOXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit)
552 {
553 PgStat_TableXactStatus *trans;
554
555 for (trans = xact_state->first; trans != NULL; trans = trans->next)
556 {
557 PgStat_TableStatus *tabstat;
558
559 Assert(trans->nest_level == 1);
560 Assert(trans->upper == NULL);
561 tabstat = trans->parent;
562 Assert(tabstat->trans == trans);
563 /* restore pre-truncate/drop stats (if any) in case of aborted xact */
564 if (!isCommit)
565 restore_truncdrop_counters(trans);
566 /* count attempted actions regardless of commit/abort */
567 tabstat->counts.tuples_inserted += trans->tuples_inserted;
568 tabstat->counts.tuples_updated += trans->tuples_updated;
569 tabstat->counts.tuples_deleted += trans->tuples_deleted;
570 if (isCommit)
571 {
572 tabstat->counts.truncdropped = trans->truncdropped;
573 if (trans->truncdropped)
574 {
575 /* forget live/dead stats seen by backend thus far */
576 tabstat->counts.delta_live_tuples = 0;
577 tabstat->counts.delta_dead_tuples = 0;
578 }
579 /* insert adds a live tuple, delete removes one */
580 tabstat->counts.delta_live_tuples +=
581 trans->tuples_inserted - trans->tuples_deleted;
582 /* update and delete each create a dead tuple */
583 tabstat->counts.delta_dead_tuples +=
584 trans->tuples_updated + trans->tuples_deleted;
585 /* insert, update, delete each count as one change event */
586 tabstat->counts.changed_tuples +=
587 trans->tuples_inserted + trans->tuples_updated +
588 trans->tuples_deleted;
589 }
590 else
591 {
592 /* inserted tuples are dead, deleted tuples are unaffected */
593 tabstat->counts.delta_dead_tuples +=
594 trans->tuples_inserted + trans->tuples_updated;
595 /* an aborted xact generates no changed_tuple events */
596 }
597 tabstat->trans = NULL;
598 }
599 }
600
601 /*
602 * Perform relation stats specific end-of-sub-transaction work. Helper for
603 * AtEOSubXact_PgStat.
604 *
605 * Transfer transactional insert/update counts into the next higher
606 * subtransaction state.
607 */
608 void
609 AtEOSubXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit, int nestDepth)
610 {
611 PgStat_TableXactStatus *trans;
612 PgStat_TableXactStatus *next_trans;
613
614 for (trans = xact_state->first; trans != NULL; trans = next_trans)
615 {
616 PgStat_TableStatus *tabstat;
617
618 next_trans = trans->next;
619 Assert(trans->nest_level == nestDepth);
620 tabstat = trans->parent;
621 Assert(tabstat->trans == trans);
622
623 if (isCommit)
624 {
625 if (trans->upper && trans->upper->nest_level == nestDepth - 1)
626 {
627 if (trans->truncdropped)
628 {
629 /* propagate the truncate/drop status one level up */
630 save_truncdrop_counters(trans->upper, false);
631 /* replace upper xact stats with ours */
632 trans->upper->tuples_inserted = trans->tuples_inserted;
633 trans->upper->tuples_updated = trans->tuples_updated;
634 trans->upper->tuples_deleted = trans->tuples_deleted;
635 }
636 else
637 {
638 trans->upper->tuples_inserted += trans->tuples_inserted;
639 trans->upper->tuples_updated += trans->tuples_updated;
640 trans->upper->tuples_deleted += trans->tuples_deleted;
641 }
642 tabstat->trans = trans->upper;
643 pfree(trans);
644 }
645 else
646 {
647 /*
648 * When there isn't an immediate parent state, we can just
649 * reuse the record instead of going through a palloc/pfree
650 * pushup (this works since it's all in TopTransactionContext
651 * anyway). We have to re-link it into the parent level,
652 * though, and that might mean pushing a new entry into the
653 * pgStatXactStack.
654 */
655 PgStat_SubXactStatus *upper_xact_state;
656
657 upper_xact_state = pgstat_get_xact_stack_level(nestDepth - 1);
658 trans->next = upper_xact_state->first;
659 upper_xact_state->first = trans;
660 trans->nest_level = nestDepth - 1;
661 }
662 }
663 else
664 {
665 /*
666 * On abort, update top-level tabstat counts, then forget the
667 * subtransaction
668 */
669
670 /* first restore values obliterated by truncate/drop */
671 restore_truncdrop_counters(trans);
672 /* count attempted actions regardless of commit/abort */
673 tabstat->counts.tuples_inserted += trans->tuples_inserted;
674 tabstat->counts.tuples_updated += trans->tuples_updated;
675 tabstat->counts.tuples_deleted += trans->tuples_deleted;
676 /* inserted tuples are dead, deleted tuples are unaffected */
677 tabstat->counts.delta_dead_tuples +=
678 trans->tuples_inserted + trans->tuples_updated;
679 tabstat->trans = trans->upper;
680 pfree(trans);
681 }
682 }
683 }
684
685 /*
686 * Generate 2PC records for all the pending transaction-dependent relation
687 * stats.
688 */
689 void
690 AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
691 {
692 PgStat_TableXactStatus *trans;
693
694 for (trans = xact_state->first; trans != NULL; trans = trans->next)
695 {
696 PgStat_TableStatus *tabstat PG_USED_FOR_ASSERTS_ONLY;
697 TwoPhasePgStatRecord record;
698
699 Assert(trans->nest_level == 1);
700 Assert(trans->upper == NULL);
701 tabstat = trans->parent;
702 Assert(tabstat->trans == trans);
703
704 record.tuples_inserted = trans->tuples_inserted;
705 record.tuples_updated = trans->tuples_updated;
706 record.tuples_deleted = trans->tuples_deleted;
707 record.inserted_pre_truncdrop = trans->inserted_pre_truncdrop;
708 record.updated_pre_truncdrop = trans->updated_pre_truncdrop;
709 record.deleted_pre_truncdrop = trans->deleted_pre_truncdrop;
710 record.id = tabstat->id;
711 record.shared = tabstat->shared;
712 record.truncdropped = trans->truncdropped;
713
714 RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
715 &record, sizeof(TwoPhasePgStatRecord));
716 }
717 }
718
719 /*
720 * All we need do here is unlink the transaction stats state from the
721 * nontransactional state. The nontransactional action counts will be
722 * reported to the stats system immediately, while the effects on live and
723 * dead tuple counts are preserved in the 2PC state file.
724 *
725 * Note: AtEOXact_PgStat_Relations is not called during PREPARE.
726 */
727 void
728 PostPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
729 {
730 PgStat_TableXactStatus *trans;
731
732 for (trans = xact_state->first; trans != NULL; trans = trans->next)
733 {
734 PgStat_TableStatus *tabstat;
735
736 tabstat = trans->parent;
737 tabstat->trans = NULL;
738 }
739 }
740
741 /*
742 * 2PC processing routine for COMMIT PREPARED case.
743 *
744 * Load the saved counts into our local pgstats state.
745 */
746 void
747 pgstat_twophase_postcommit(TransactionId xid, uint16 info,
748 void *recdata, uint32 len)
749 {
750 TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
751 PgStat_TableStatus *pgstat_info;
752
753 /* Find or create a tabstat entry for the rel */
754 pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
755
756 /* Same math as in AtEOXact_PgStat, commit case */
757 pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
758 pgstat_info->counts.tuples_updated += rec->tuples_updated;
759 pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
760 pgstat_info->counts.truncdropped = rec->truncdropped;
761 if (rec->truncdropped)
762 {
763 /* forget live/dead stats seen by backend thus far */
764 pgstat_info->counts.delta_live_tuples = 0;
765 pgstat_info->counts.delta_dead_tuples = 0;
766 }
767 pgstat_info->counts.delta_live_tuples +=
768 rec->tuples_inserted - rec->tuples_deleted;
769 pgstat_info->counts.delta_dead_tuples +=
770 rec->tuples_updated + rec->tuples_deleted;
771 pgstat_info->counts.changed_tuples +=
772 rec->tuples_inserted + rec->tuples_updated +
773 rec->tuples_deleted;
774 }
775
776 /*
777 * 2PC processing routine for ROLLBACK PREPARED case.
778 *
779 * Load the saved counts into our local pgstats state, but treat them
780 * as aborted.
781 */
782 void
783 pgstat_twophase_postabort(TransactionId xid, uint16 info,
784 void *recdata, uint32 len)
785 {
786 TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
787 PgStat_TableStatus *pgstat_info;
788
789 /* Find or create a tabstat entry for the rel */
790 pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
791
792 /* Same math as in AtEOXact_PgStat, abort case */
793 if (rec->truncdropped)
794 {
795 rec->tuples_inserted = rec->inserted_pre_truncdrop;
796 rec->tuples_updated = rec->updated_pre_truncdrop;
797 rec->tuples_deleted = rec->deleted_pre_truncdrop;
798 }
799 pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
800 pgstat_info->counts.tuples_updated += rec->tuples_updated;
801 pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
802 pgstat_info->counts.delta_dead_tuples +=
803 rec->tuples_inserted + rec->tuples_updated;
804 }
805
806 /*
807 * Flush out pending stats for the entry
808 *
809 * If nowait is true and the lock could not be immediately acquired, returns
810 * false without flushing the entry. Otherwise returns true.
811 *
812 * Some of the stats are copied to the corresponding pending database stats
813 * entry when successfully flushing.
814 */
815 bool
816 pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait)
817 {
818 Oid dboid;
819 PgStat_TableStatus *lstats; /* pending stats entry */
820 PgStatShared_Relation *shtabstats;
821 PgStat_StatTabEntry *tabentry; /* table entry of shared stats */
822 PgStat_StatDBEntry *dbentry; /* pending database entry */
823
824 dboid = entry_ref->shared_entry->key.dboid;
825 lstats = (PgStat_TableStatus *) entry_ref->pending;
826 shtabstats = (PgStatShared_Relation *) entry_ref->shared_stats;
827
828 /*
829 * Ignore entries that didn't accumulate any actual counts, such as
830 * indexes that were opened by the planner but not used.
831 */
832 if (pg_memory_is_all_zeros(&lstats->counts,
833 sizeof(struct PgStat_TableCounts)))
834 return true;
835
836 if (!pgstat_lock_entry(entry_ref, nowait))
837 return false;
838
839 /* add the values to the shared entry. */
840 tabentry = &shtabstats->stats;
841
842 tabentry->numscans += lstats->counts.numscans;
843 if (lstats->counts.numscans)
844 {
845 TimestampTz t = GetCurrentTransactionStopTimestamp();
846
847 if (t > tabentry->lastscan)
848 tabentry->lastscan = t;
849 }
850 tabentry->tuples_returned += lstats->counts.tuples_returned;
851 tabentry->tuples_fetched += lstats->counts.tuples_fetched;
852 tabentry->tuples_inserted += lstats->counts.tuples_inserted;
853 tabentry->tuples_updated += lstats->counts.tuples_updated;
854 tabentry->tuples_deleted += lstats->counts.tuples_deleted;
855 tabentry->tuples_hot_updated += lstats->counts.tuples_hot_updated;
856 tabentry->tuples_newpage_updated += lstats->counts.tuples_newpage_updated;
857
858 /*
859 * If table was truncated/dropped, first reset the live/dead counters.
860 */
861 if (lstats->counts.truncdropped)
862 {
863 tabentry->live_tuples = 0;
864 tabentry->dead_tuples = 0;
865 tabentry->ins_since_vacuum = 0;
866 }
867
868 tabentry->live_tuples += lstats->counts.delta_live_tuples;
869 tabentry->dead_tuples += lstats->counts.delta_dead_tuples;
870 tabentry->mod_since_analyze += lstats->counts.changed_tuples;
871
872 /*
873 * Using tuples_inserted to update ins_since_vacuum does mean that we'll
874 * track aborted inserts too. This isn't ideal, but otherwise probably
875 * not worth adding an extra field for. It may just amount to autovacuums
876 * triggering for inserts more often than they maybe should, which is
877 * probably not going to be common enough to be too concerned about here.
878 */
879 tabentry->ins_since_vacuum += lstats->counts.tuples_inserted;
880
881 tabentry->blocks_fetched += lstats->counts.blocks_fetched;
882 tabentry->blocks_hit += lstats->counts.blocks_hit;
883
884 /* Clamp live_tuples in case of negative delta_live_tuples */
885 tabentry->live_tuples = Max(tabentry->live_tuples, 0);
886 /* Likewise for dead_tuples */
887 tabentry->dead_tuples = Max(tabentry->dead_tuples, 0);
888
889 pgstat_unlock_entry(entry_ref);
890
891 /* The entry was successfully flushed, add the same to database stats */
892 dbentry = pgstat_prep_database_pending(dboid);
893 dbentry->tuples_returned += lstats->counts.tuples_returned;
894 dbentry->tuples_fetched += lstats->counts.tuples_fetched;
895 dbentry->tuples_inserted += lstats->counts.tuples_inserted;
896 dbentry->tuples_updated += lstats->counts.tuples_updated;
897 dbentry->tuples_deleted += lstats->counts.tuples_deleted;
898 dbentry->blocks_fetched += lstats->counts.blocks_fetched;
899 dbentry->blocks_hit += lstats->counts.blocks_hit;
900
901 return true;
902 }
903
904 void
905 pgstat_relation_delete_pending_cb(PgStat_EntryRef *entry_ref)
906 {
907 PgStat_TableStatus *pending = (PgStat_TableStatus *) entry_ref->pending;
908
909 if (pending->relation)
910 pgstat_unlink_relation(pending->relation);
911 }
912
913 /*
914 * Find or create a PgStat_TableStatus entry for rel. New entry is created and
915 * initialized if not exists.
916 */
917 static PgStat_TableStatus *
918 pgstat_prep_relation_pending(Oid rel_id, bool isshared)
919 {
920 PgStat_EntryRef *entry_ref;
921 PgStat_TableStatus *pending;
922
923 entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_RELATION,
924 isshared ? InvalidOid : MyDatabaseId,
925 rel_id, NULL);
926 pending = entry_ref->pending;
927 pending->id = rel_id;
928 pending->shared = isshared;
929
930 return pending;
931 }
932
933 /*
934 * add a new (sub)transaction state record
935 */
936 static void
937 add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
938 {
939 PgStat_SubXactStatus *xact_state;
940 PgStat_TableXactStatus *trans;
941
942 /*
943 * If this is the first rel to be modified at the current nest level, we
944 * first have to push a transaction stack entry.
945 */
946 xact_state = pgstat_get_xact_stack_level(nest_level);
947
948 /* Now make a per-table stack entry */
949 trans = (PgStat_TableXactStatus *)
950 MemoryContextAllocZero(TopTransactionContext,
951 sizeof(PgStat_TableXactStatus));
952 trans->nest_level = nest_level;
953 trans->upper = pgstat_info->trans;
954 trans->parent = pgstat_info;
955 trans->next = xact_state->first;
956 xact_state->first = trans;
957 pgstat_info->trans = trans;
958 }
959
960 /*
961 * Add a new (sub)transaction record if needed.
962 */
963 static void
964 ensure_tabstat_xact_level(PgStat_TableStatus *pgstat_info)
965 {
966 int nest_level = GetCurrentTransactionNestLevel();
967
968 if (pgstat_info->trans == NULL ||
969 pgstat_info->trans->nest_level != nest_level)
970 add_tabstat_xact_level(pgstat_info, nest_level);
971 }
972
973 /*
974 * Whenever a table is truncated/dropped, we save its i/u/d counters so that
975 * they can be cleared, and if the (sub)xact that executed the truncate/drop
976 * later aborts, the counters can be restored to the saved (pre-truncate/drop)
977 * values.
978 *
979 * Note that for truncate we do this on the first truncate in any particular
980 * subxact level only.
981 */
982 static void
983 save_truncdrop_counters(PgStat_TableXactStatus *trans, bool is_drop)
984 {
985 if (!trans->truncdropped || is_drop)
986 {
987 trans->inserted_pre_truncdrop = trans->tuples_inserted;
988 trans->updated_pre_truncdrop = trans->tuples_updated;
989 trans->deleted_pre_truncdrop = trans->tuples_deleted;
990 trans->truncdropped = true;
991 }
992 }
993
994 /*
995 * restore counters when a truncate aborts
996 */
997 static void
998 restore_truncdrop_counters(PgStat_TableXactStatus *trans)
999 {
1000 if (trans->truncdropped)
1001 {
1002 trans->tuples_inserted = trans->inserted_pre_truncdrop;
1003 trans->tuples_updated = trans->updated_pre_truncdrop;
1004 trans->tuples_deleted = trans->deleted_pre_truncdrop;
1005 }
1006 }