LCOV - code coverage report
Current view: top level - src/bin/pg_waldump - xactdesc.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 124 246 50.4 %
Date: 2025-04-01 16:15:31 Functions: 9 12 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * xactdesc.c
       4             :  *    rmgr descriptor routines for access/transam/xact.c
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/access/rmgrdesc/xactdesc.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/transam.h"
      18             : #include "access/xact.h"
      19             : #include "replication/origin.h"
      20             : #include "storage/sinval.h"
      21             : #include "storage/standbydefs.h"
      22             : #include "utils/timestamp.h"
      23             : 
      24             : /*
      25             :  * Parse the WAL format of an xact commit and abort records into an easier to
      26             :  * understand format.
      27             :  *
      28             :  * These routines are in xactdesc.c because they're accessed in backend (when
      29             :  * replaying WAL) and frontend (pg_waldump) code. This file is the only xact
      30             :  * specific one shared between both. They're complicated enough that
      31             :  * duplication would be bothersome.
      32             :  */
      33             : 
      34             : void
      35        3308 : ParseCommitRecord(uint8 info, xl_xact_commit *xlrec, xl_xact_parsed_commit *parsed)
      36             : {
      37        3308 :     char       *data = ((char *) xlrec) + MinSizeOfXactCommit;
      38             : 
      39        3308 :     memset(parsed, 0, sizeof(*parsed));
      40             : 
      41        3308 :     parsed->xinfo = 0;           /* default, if no XLOG_XACT_HAS_INFO is
      42             :                                  * present */
      43             : 
      44        3308 :     parsed->xact_time = xlrec->xact_time;
      45             : 
      46        3308 :     if (info & XLOG_XACT_HAS_INFO)
      47             :     {
      48        3268 :         xl_xact_xinfo *xl_xinfo = (xl_xact_xinfo *) data;
      49             : 
      50        3268 :         parsed->xinfo = xl_xinfo->xinfo;
      51             : 
      52        3268 :         data += sizeof(xl_xact_xinfo);
      53             :     }
      54             : 
      55        3308 :     if (parsed->xinfo & XACT_XINFO_HAS_DBINFO)
      56             :     {
      57        3268 :         xl_xact_dbinfo *xl_dbinfo = (xl_xact_dbinfo *) data;
      58             : 
      59        3268 :         parsed->dbId = xl_dbinfo->dbId;
      60        3268 :         parsed->tsId = xl_dbinfo->tsId;
      61             : 
      62        3268 :         data += sizeof(xl_xact_dbinfo);
      63             :     }
      64             : 
      65        3308 :     if (parsed->xinfo & XACT_XINFO_HAS_SUBXACTS)
      66             :     {
      67           0 :         xl_xact_subxacts *xl_subxacts = (xl_xact_subxacts *) data;
      68             : 
      69           0 :         parsed->nsubxacts = xl_subxacts->nsubxacts;
      70           0 :         parsed->subxacts = xl_subxacts->subxacts;
      71             : 
      72           0 :         data += MinSizeOfXactSubxacts;
      73           0 :         data += parsed->nsubxacts * sizeof(TransactionId);
      74             :     }
      75             : 
      76        3308 :     if (parsed->xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
      77             :     {
      78          24 :         xl_xact_relfilelocators *xl_rellocators = (xl_xact_relfilelocators *) data;
      79             : 
      80          24 :         parsed->nrels = xl_rellocators->nrels;
      81          24 :         parsed->xlocators = xl_rellocators->xlocators;
      82             : 
      83          24 :         data += MinSizeOfXactRelfileLocators;
      84          24 :         data += xl_rellocators->nrels * sizeof(RelFileLocator);
      85             :     }
      86             : 
      87        3308 :     if (parsed->xinfo & XACT_XINFO_HAS_DROPPED_STATS)
      88             :     {
      89          24 :         xl_xact_stats_items *xl_drops = (xl_xact_stats_items *) data;
      90             : 
      91          24 :         parsed->nstats = xl_drops->nitems;
      92          24 :         parsed->stats = xl_drops->items;
      93             : 
      94          24 :         data += MinSizeOfXactStatsItems;
      95          24 :         data += xl_drops->nitems * sizeof(xl_xact_stats_item);
      96             :     }
      97             : 
      98        3308 :     if (parsed->xinfo & XACT_XINFO_HAS_INVALS)
      99             :     {
     100        3172 :         xl_xact_invals *xl_invals = (xl_xact_invals *) data;
     101             : 
     102        3172 :         parsed->nmsgs = xl_invals->nmsgs;
     103        3172 :         parsed->msgs = xl_invals->msgs;
     104             : 
     105        3172 :         data += MinSizeOfXactInvals;
     106        3172 :         data += xl_invals->nmsgs * sizeof(SharedInvalidationMessage);
     107             :     }
     108             : 
     109        3308 :     if (parsed->xinfo & XACT_XINFO_HAS_TWOPHASE)
     110             :     {
     111           0 :         xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
     112             : 
     113           0 :         parsed->twophase_xid = xl_twophase->xid;
     114             : 
     115           0 :         data += sizeof(xl_xact_twophase);
     116             : 
     117           0 :         if (parsed->xinfo & XACT_XINFO_HAS_GID)
     118             :         {
     119           0 :             strlcpy(parsed->twophase_gid, data, sizeof(parsed->twophase_gid));
     120           0 :             data += strlen(data) + 1;
     121             :         }
     122             :     }
     123             : 
     124             :     /* Note: no alignment is guaranteed after this point */
     125             : 
     126        3308 :     if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
     127             :     {
     128             :         xl_xact_origin xl_origin;
     129             : 
     130             :         /* no alignment is guaranteed, so copy onto stack */
     131           0 :         memcpy(&xl_origin, data, sizeof(xl_origin));
     132             : 
     133           0 :         parsed->origin_lsn = xl_origin.origin_lsn;
     134           0 :         parsed->origin_timestamp = xl_origin.origin_timestamp;
     135             : 
     136           0 :         data += sizeof(xl_xact_origin);
     137             :     }
     138        3308 : }
     139             : 
     140             : void
     141          12 : ParseAbortRecord(uint8 info, xl_xact_abort *xlrec, xl_xact_parsed_abort *parsed)
     142             : {
     143          12 :     char       *data = ((char *) xlrec) + MinSizeOfXactAbort;
     144             : 
     145          12 :     memset(parsed, 0, sizeof(*parsed));
     146             : 
     147          12 :     parsed->xinfo = 0;           /* default, if no XLOG_XACT_HAS_INFO is
     148             :                                  * present */
     149             : 
     150          12 :     parsed->xact_time = xlrec->xact_time;
     151             : 
     152          12 :     if (info & XLOG_XACT_HAS_INFO)
     153             :     {
     154           0 :         xl_xact_xinfo *xl_xinfo = (xl_xact_xinfo *) data;
     155             : 
     156           0 :         parsed->xinfo = xl_xinfo->xinfo;
     157             : 
     158           0 :         data += sizeof(xl_xact_xinfo);
     159             :     }
     160             : 
     161          12 :     if (parsed->xinfo & XACT_XINFO_HAS_DBINFO)
     162             :     {
     163           0 :         xl_xact_dbinfo *xl_dbinfo = (xl_xact_dbinfo *) data;
     164             : 
     165           0 :         parsed->dbId = xl_dbinfo->dbId;
     166           0 :         parsed->tsId = xl_dbinfo->tsId;
     167             : 
     168           0 :         data += sizeof(xl_xact_dbinfo);
     169             :     }
     170             : 
     171          12 :     if (parsed->xinfo & XACT_XINFO_HAS_SUBXACTS)
     172             :     {
     173           0 :         xl_xact_subxacts *xl_subxacts = (xl_xact_subxacts *) data;
     174             : 
     175           0 :         parsed->nsubxacts = xl_subxacts->nsubxacts;
     176           0 :         parsed->subxacts = xl_subxacts->subxacts;
     177             : 
     178           0 :         data += MinSizeOfXactSubxacts;
     179           0 :         data += parsed->nsubxacts * sizeof(TransactionId);
     180             :     }
     181             : 
     182          12 :     if (parsed->xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
     183             :     {
     184           0 :         xl_xact_relfilelocators *xl_rellocator = (xl_xact_relfilelocators *) data;
     185             : 
     186           0 :         parsed->nrels = xl_rellocator->nrels;
     187           0 :         parsed->xlocators = xl_rellocator->xlocators;
     188             : 
     189           0 :         data += MinSizeOfXactRelfileLocators;
     190           0 :         data += xl_rellocator->nrels * sizeof(RelFileLocator);
     191             :     }
     192             : 
     193          12 :     if (parsed->xinfo & XACT_XINFO_HAS_DROPPED_STATS)
     194             :     {
     195           0 :         xl_xact_stats_items *xl_drops = (xl_xact_stats_items *) data;
     196             : 
     197           0 :         parsed->nstats = xl_drops->nitems;
     198           0 :         parsed->stats = xl_drops->items;
     199             : 
     200           0 :         data += MinSizeOfXactStatsItems;
     201           0 :         data += xl_drops->nitems * sizeof(xl_xact_stats_item);
     202             :     }
     203             : 
     204          12 :     if (parsed->xinfo & XACT_XINFO_HAS_TWOPHASE)
     205             :     {
     206           0 :         xl_xact_twophase *xl_twophase = (xl_xact_twophase *) data;
     207             : 
     208           0 :         parsed->twophase_xid = xl_twophase->xid;
     209             : 
     210           0 :         data += sizeof(xl_xact_twophase);
     211             : 
     212           0 :         if (parsed->xinfo & XACT_XINFO_HAS_GID)
     213             :         {
     214           0 :             strlcpy(parsed->twophase_gid, data, sizeof(parsed->twophase_gid));
     215           0 :             data += strlen(data) + 1;
     216             :         }
     217             :     }
     218             : 
     219             :     /* Note: no alignment is guaranteed after this point */
     220             : 
     221          12 :     if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
     222             :     {
     223             :         xl_xact_origin xl_origin;
     224             : 
     225             :         /* no alignment is guaranteed, so copy onto stack */
     226           0 :         memcpy(&xl_origin, data, sizeof(xl_origin));
     227             : 
     228           0 :         parsed->origin_lsn = xl_origin.origin_lsn;
     229           0 :         parsed->origin_timestamp = xl_origin.origin_timestamp;
     230             : 
     231           0 :         data += sizeof(xl_xact_origin);
     232             :     }
     233          12 : }
     234             : 
     235             : /*
     236             :  * ParsePrepareRecord
     237             :  */
     238             : void
     239           0 : ParsePrepareRecord(uint8 info, xl_xact_prepare *xlrec, xl_xact_parsed_prepare *parsed)
     240             : {
     241             :     char       *bufptr;
     242             : 
     243           0 :     bufptr = ((char *) xlrec) + MAXALIGN(sizeof(xl_xact_prepare));
     244             : 
     245           0 :     memset(parsed, 0, sizeof(*parsed));
     246             : 
     247           0 :     parsed->xact_time = xlrec->prepared_at;
     248           0 :     parsed->origin_lsn = xlrec->origin_lsn;
     249           0 :     parsed->origin_timestamp = xlrec->origin_timestamp;
     250           0 :     parsed->twophase_xid = xlrec->xid;
     251           0 :     parsed->dbId = xlrec->database;
     252           0 :     parsed->nsubxacts = xlrec->nsubxacts;
     253           0 :     parsed->nrels = xlrec->ncommitrels;
     254           0 :     parsed->nabortrels = xlrec->nabortrels;
     255           0 :     parsed->nmsgs = xlrec->ninvalmsgs;
     256             : 
     257           0 :     strncpy(parsed->twophase_gid, bufptr, xlrec->gidlen);
     258           0 :     bufptr += MAXALIGN(xlrec->gidlen);
     259             : 
     260           0 :     parsed->subxacts = (TransactionId *) bufptr;
     261           0 :     bufptr += MAXALIGN(xlrec->nsubxacts * sizeof(TransactionId));
     262             : 
     263           0 :     parsed->xlocators = (RelFileLocator *) bufptr;
     264           0 :     bufptr += MAXALIGN(xlrec->ncommitrels * sizeof(RelFileLocator));
     265             : 
     266           0 :     parsed->abortlocators = (RelFileLocator *) bufptr;
     267           0 :     bufptr += MAXALIGN(xlrec->nabortrels * sizeof(RelFileLocator));
     268             : 
     269           0 :     parsed->stats = (xl_xact_stats_item *) bufptr;
     270           0 :     bufptr += MAXALIGN(xlrec->ncommitstats * sizeof(xl_xact_stats_item));
     271             : 
     272           0 :     parsed->abortstats = (xl_xact_stats_item *) bufptr;
     273           0 :     bufptr += MAXALIGN(xlrec->nabortstats * sizeof(xl_xact_stats_item));
     274             : 
     275           0 :     parsed->msgs = (SharedInvalidationMessage *) bufptr;
     276           0 :     bufptr += MAXALIGN(xlrec->ninvalmsgs * sizeof(SharedInvalidationMessage));
     277           0 : }
     278             : 
     279             : static void
     280        3320 : xact_desc_relations(StringInfo buf, char *label, int nrels,
     281             :                     RelFileLocator *xlocators)
     282             : {
     283             :     int         i;
     284             : 
     285        3320 :     if (nrels > 0)
     286             :     {
     287          24 :         appendStringInfo(buf, "; %s:", label);
     288         120 :         for (i = 0; i < nrels; i++)
     289             :         {
     290          96 :             appendStringInfo(buf, " %s",
     291          96 :                              relpathperm(xlocators[i], MAIN_FORKNUM).str);
     292             :         }
     293             :     }
     294        3320 : }
     295             : 
     296             : static void
     297        3320 : xact_desc_subxacts(StringInfo buf, int nsubxacts, TransactionId *subxacts)
     298             : {
     299             :     int         i;
     300             : 
     301        3320 :     if (nsubxacts > 0)
     302             :     {
     303           0 :         appendStringInfoString(buf, "; subxacts:");
     304           0 :         for (i = 0; i < nsubxacts; i++)
     305           0 :             appendStringInfo(buf, " %u", subxacts[i]);
     306             :     }
     307        3320 : }
     308             : 
     309             : static void
     310        3320 : xact_desc_stats(StringInfo buf, const char *label,
     311             :                 int ndropped, xl_xact_stats_item *dropped_stats)
     312             : {
     313             :     int         i;
     314             : 
     315        3320 :     if (ndropped > 0)
     316             :     {
     317          24 :         appendStringInfo(buf, "; %sdropped stats:", label);
     318          48 :         for (i = 0; i < ndropped; i++)
     319             :         {
     320          24 :             uint64      objid =
     321          24 :                 ((uint64) dropped_stats[i].objid_hi) << 32 | dropped_stats[i].objid_lo;
     322             : 
     323          24 :             appendStringInfo(buf, " %d/%u/%" PRIu64,
     324          24 :                              dropped_stats[i].kind,
     325          24 :                              dropped_stats[i].dboid,
     326             :                              objid);
     327             :         }
     328             :     }
     329        3320 : }
     330             : 
     331             : static void
     332        3308 : xact_desc_commit(StringInfo buf, uint8 info, xl_xact_commit *xlrec, RepOriginId origin_id)
     333             : {
     334             :     xl_xact_parsed_commit parsed;
     335             : 
     336        3308 :     ParseCommitRecord(info, xlrec, &parsed);
     337             : 
     338             :     /* If this is a prepared xact, show the xid of the original xact */
     339        3308 :     if (TransactionIdIsValid(parsed.twophase_xid))
     340           0 :         appendStringInfo(buf, "%u: ", parsed.twophase_xid);
     341             : 
     342        3308 :     appendStringInfoString(buf, timestamptz_to_str(xlrec->xact_time));
     343             : 
     344        3308 :     xact_desc_relations(buf, "rels", parsed.nrels, parsed.xlocators);
     345        3308 :     xact_desc_subxacts(buf, parsed.nsubxacts, parsed.subxacts);
     346        3308 :     xact_desc_stats(buf, "", parsed.nstats, parsed.stats);
     347             : 
     348        3308 :     standby_desc_invalidations(buf, parsed.nmsgs, parsed.msgs, parsed.dbId,
     349             :                                parsed.tsId,
     350        3308 :                                XactCompletionRelcacheInitFileInval(parsed.xinfo));
     351             : 
     352        3308 :     if (XactCompletionApplyFeedback(parsed.xinfo))
     353           0 :         appendStringInfoString(buf, "; apply_feedback");
     354             : 
     355        3308 :     if (XactCompletionForceSyncCommit(parsed.xinfo))
     356          56 :         appendStringInfoString(buf, "; sync");
     357             : 
     358        3308 :     if (parsed.xinfo & XACT_XINFO_HAS_ORIGIN)
     359             :     {
     360           0 :         appendStringInfo(buf, "; origin: node %u, lsn %X/%X, at %s",
     361             :                          origin_id,
     362           0 :                          LSN_FORMAT_ARGS(parsed.origin_lsn),
     363             :                          timestamptz_to_str(parsed.origin_timestamp));
     364             :     }
     365        3308 : }
     366             : 
     367             : static void
     368          12 : xact_desc_abort(StringInfo buf, uint8 info, xl_xact_abort *xlrec, RepOriginId origin_id)
     369             : {
     370             :     xl_xact_parsed_abort parsed;
     371             : 
     372          12 :     ParseAbortRecord(info, xlrec, &parsed);
     373             : 
     374             :     /* If this is a prepared xact, show the xid of the original xact */
     375          12 :     if (TransactionIdIsValid(parsed.twophase_xid))
     376           0 :         appendStringInfo(buf, "%u: ", parsed.twophase_xid);
     377             : 
     378          12 :     appendStringInfoString(buf, timestamptz_to_str(xlrec->xact_time));
     379             : 
     380          12 :     xact_desc_relations(buf, "rels", parsed.nrels, parsed.xlocators);
     381          12 :     xact_desc_subxacts(buf, parsed.nsubxacts, parsed.subxacts);
     382             : 
     383          12 :     if (parsed.xinfo & XACT_XINFO_HAS_ORIGIN)
     384             :     {
     385           0 :         appendStringInfo(buf, "; origin: node %u, lsn %X/%X, at %s",
     386             :                          origin_id,
     387           0 :                          LSN_FORMAT_ARGS(parsed.origin_lsn),
     388             :                          timestamptz_to_str(parsed.origin_timestamp));
     389             :     }
     390             : 
     391          12 :     xact_desc_stats(buf, "", parsed.nstats, parsed.stats);
     392          12 : }
     393             : 
     394             : static void
     395           0 : xact_desc_prepare(StringInfo buf, uint8 info, xl_xact_prepare *xlrec, RepOriginId origin_id)
     396             : {
     397             :     xl_xact_parsed_prepare parsed;
     398             : 
     399           0 :     ParsePrepareRecord(info, xlrec, &parsed);
     400             : 
     401           0 :     appendStringInfo(buf, "gid %s: ", parsed.twophase_gid);
     402           0 :     appendStringInfoString(buf, timestamptz_to_str(parsed.xact_time));
     403             : 
     404           0 :     xact_desc_relations(buf, "rels(commit)", parsed.nrels, parsed.xlocators);
     405           0 :     xact_desc_relations(buf, "rels(abort)", parsed.nabortrels,
     406             :                         parsed.abortlocators);
     407           0 :     xact_desc_stats(buf, "commit ", parsed.nstats, parsed.stats);
     408           0 :     xact_desc_stats(buf, "abort ", parsed.nabortstats, parsed.abortstats);
     409           0 :     xact_desc_subxacts(buf, parsed.nsubxacts, parsed.subxacts);
     410             : 
     411           0 :     standby_desc_invalidations(buf, parsed.nmsgs, parsed.msgs, parsed.dbId,
     412           0 :                                parsed.tsId, xlrec->initfileinval);
     413             : 
     414             :     /*
     415             :      * Check if the replication origin has been set in this record in the same
     416             :      * way as PrepareRedoAdd().
     417             :      */
     418           0 :     if (origin_id != InvalidRepOriginId)
     419           0 :         appendStringInfo(buf, "; origin: node %u, lsn %X/%X, at %s",
     420             :                          origin_id,
     421           0 :                          LSN_FORMAT_ARGS(parsed.origin_lsn),
     422             :                          timestamptz_to_str(parsed.origin_timestamp));
     423           0 : }
     424             : 
     425             : static void
     426           0 : xact_desc_assignment(StringInfo buf, xl_xact_assignment *xlrec)
     427             : {
     428             :     int         i;
     429             : 
     430           0 :     appendStringInfoString(buf, "subxacts:");
     431             : 
     432           0 :     for (i = 0; i < xlrec->nsubxacts; i++)
     433           0 :         appendStringInfo(buf, " %u", xlrec->xsub[i]);
     434           0 : }
     435             : 
     436             : void
     437        5492 : xact_desc(StringInfo buf, XLogReaderState *record)
     438             : {
     439        5492 :     char       *rec = XLogRecGetData(record);
     440        5492 :     uint8       info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
     441             : 
     442        5492 :     if (info == XLOG_XACT_COMMIT || info == XLOG_XACT_COMMIT_PREPARED)
     443        3308 :     {
     444        3308 :         xl_xact_commit *xlrec = (xl_xact_commit *) rec;
     445             : 
     446        3308 :         xact_desc_commit(buf, XLogRecGetInfo(record), xlrec,
     447        3308 :                          XLogRecGetOrigin(record));
     448             :     }
     449        2184 :     else if (info == XLOG_XACT_ABORT || info == XLOG_XACT_ABORT_PREPARED)
     450          12 :     {
     451          12 :         xl_xact_abort *xlrec = (xl_xact_abort *) rec;
     452             : 
     453          12 :         xact_desc_abort(buf, XLogRecGetInfo(record), xlrec,
     454          12 :                         XLogRecGetOrigin(record));
     455             :     }
     456        2172 :     else if (info == XLOG_XACT_PREPARE)
     457             :     {
     458           0 :         xl_xact_prepare *xlrec = (xl_xact_prepare *) rec;
     459             : 
     460           0 :         xact_desc_prepare(buf, XLogRecGetInfo(record), xlrec,
     461           0 :                           XLogRecGetOrigin(record));
     462             :     }
     463        2172 :     else if (info == XLOG_XACT_ASSIGNMENT)
     464             :     {
     465           0 :         xl_xact_assignment *xlrec = (xl_xact_assignment *) rec;
     466             : 
     467             :         /*
     468             :          * Note that we ignore the WAL record's xid, since we're more
     469             :          * interested in the top-level xid that issued the record and which
     470             :          * xids are being reported here.
     471             :          */
     472           0 :         appendStringInfo(buf, "xtop %u: ", xlrec->xtop);
     473           0 :         xact_desc_assignment(buf, xlrec);
     474             :     }
     475        2172 :     else if (info == XLOG_XACT_INVALIDATIONS)
     476             :     {
     477        2172 :         xl_xact_invals *xlrec = (xl_xact_invals *) rec;
     478             : 
     479        2172 :         standby_desc_invalidations(buf, xlrec->nmsgs, xlrec->msgs, InvalidOid,
     480             :                                    InvalidOid, false);
     481             :     }
     482        5492 : }
     483             : 
     484             : const char *
     485        5498 : xact_identify(uint8 info)
     486             : {
     487        5498 :     const char *id = NULL;
     488             : 
     489        5498 :     switch (info & XLOG_XACT_OPMASK)
     490             :     {
     491        3310 :         case XLOG_XACT_COMMIT:
     492        3310 :             id = "COMMIT";
     493        3310 :             break;
     494           0 :         case XLOG_XACT_PREPARE:
     495           0 :             id = "PREPARE";
     496           0 :             break;
     497          14 :         case XLOG_XACT_ABORT:
     498          14 :             id = "ABORT";
     499          14 :             break;
     500           0 :         case XLOG_XACT_COMMIT_PREPARED:
     501           0 :             id = "COMMIT_PREPARED";
     502           0 :             break;
     503           0 :         case XLOG_XACT_ABORT_PREPARED:
     504           0 :             id = "ABORT_PREPARED";
     505           0 :             break;
     506           0 :         case XLOG_XACT_ASSIGNMENT:
     507           0 :             id = "ASSIGNMENT";
     508           0 :             break;
     509        2174 :         case XLOG_XACT_INVALIDATIONS:
     510        2174 :             id = "INVALIDATION";
     511        2174 :             break;
     512             :     }
     513             : 
     514        5498 :     return id;
     515             : }

Generated by: LCOV version 1.14