LCOV - code coverage report
Current view: top level - src/backend/utils/activity - pgstat_relation.c (source / functions) Hit Total Coverage
Test: PostgreSQL 16beta1 Lines: 325 328 99.1 %
Date: 2023-06-06 10:12:12 Functions: 29 29 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14