LCOV - code coverage report
Current view: top level - src/bin/pg_waldump - nbtdesc.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 93 136 68.4 %
Date: 2024-07-19 16:11:31 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * nbtdesc.c
       4             :  *    rmgr descriptor routines for access/nbtree/nbtxlog.c
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/access/rmgrdesc/nbtdesc.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/nbtxlog.h"
      18             : #include "access/rmgrdesc_utils.h"
      19             : 
      20             : static void delvacuum_desc(StringInfo buf, char *block_data,
      21             :                            uint16 ndeleted, uint16 nupdated);
      22             : 
      23             : void
      24       70674 : btree_desc(StringInfo buf, XLogReaderState *record)
      25             : {
      26       70674 :     char       *rec = XLogRecGetData(record);
      27       70674 :     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
      28             : 
      29       70674 :     switch (info)
      30             :     {
      31       69760 :         case XLOG_BTREE_INSERT_LEAF:
      32             :         case XLOG_BTREE_INSERT_UPPER:
      33             :         case XLOG_BTREE_INSERT_META:
      34             :         case XLOG_BTREE_INSERT_POST:
      35             :             {
      36       69760 :                 xl_btree_insert *xlrec = (xl_btree_insert *) rec;
      37             : 
      38       69760 :                 appendStringInfo(buf, "off: %u", xlrec->offnum);
      39       69760 :                 break;
      40             :             }
      41         216 :         case XLOG_BTREE_SPLIT_L:
      42             :         case XLOG_BTREE_SPLIT_R:
      43             :             {
      44         216 :                 xl_btree_split *xlrec = (xl_btree_split *) rec;
      45             : 
      46         216 :                 appendStringInfo(buf, "level: %u, firstrightoff: %d, newitemoff: %d, postingoff: %d",
      47         216 :                                  xlrec->level, xlrec->firstrightoff,
      48         216 :                                  xlrec->newitemoff, xlrec->postingoff);
      49         216 :                 break;
      50             :             }
      51         216 :         case XLOG_BTREE_DEDUP:
      52             :             {
      53         216 :                 xl_btree_dedup *xlrec = (xl_btree_dedup *) rec;
      54             : 
      55         216 :                 appendStringInfo(buf, "nintervals: %u", xlrec->nintervals);
      56         216 :                 break;
      57             :             }
      58         242 :         case XLOG_BTREE_VACUUM:
      59             :             {
      60         242 :                 xl_btree_vacuum *xlrec = (xl_btree_vacuum *) rec;
      61             : 
      62         242 :                 appendStringInfo(buf, "ndeleted: %u, nupdated: %u",
      63         242 :                                  xlrec->ndeleted, xlrec->nupdated);
      64             : 
      65         242 :                 if (XLogRecHasBlockData(record, 0))
      66         242 :                     delvacuum_desc(buf, XLogRecGetBlockData(record, 0, NULL),
      67         242 :                                    xlrec->ndeleted, xlrec->nupdated);
      68         242 :                 break;
      69             :             }
      70          28 :         case XLOG_BTREE_DELETE:
      71             :             {
      72          28 :                 xl_btree_delete *xlrec = (xl_btree_delete *) rec;
      73             : 
      74          28 :                 appendStringInfo(buf, "snapshotConflictHorizon: %u, ndeleted: %u, nupdated: %u, isCatalogRel: %c",
      75             :                                  xlrec->snapshotConflictHorizon,
      76          28 :                                  xlrec->ndeleted, xlrec->nupdated,
      77          28 :                                  xlrec->isCatalogRel ? 'T' : 'F');
      78             : 
      79          28 :                 if (XLogRecHasBlockData(record, 0))
      80          28 :                     delvacuum_desc(buf, XLogRecGetBlockData(record, 0, NULL),
      81          28 :                                    xlrec->ndeleted, xlrec->nupdated);
      82          28 :                 break;
      83             :             }
      84           0 :         case XLOG_BTREE_MARK_PAGE_HALFDEAD:
      85             :             {
      86           0 :                 xl_btree_mark_page_halfdead *xlrec = (xl_btree_mark_page_halfdead *) rec;
      87             : 
      88           0 :                 appendStringInfo(buf, "topparent: %u, leaf: %u, left: %u, right: %u",
      89             :                                  xlrec->topparent, xlrec->leafblk, xlrec->leftblk, xlrec->rightblk);
      90           0 :                 break;
      91             :             }
      92           0 :         case XLOG_BTREE_UNLINK_PAGE_META:
      93             :         case XLOG_BTREE_UNLINK_PAGE:
      94             :             {
      95           0 :                 xl_btree_unlink_page *xlrec = (xl_btree_unlink_page *) rec;
      96             : 
      97           0 :                 appendStringInfo(buf, "left: %u, right: %u, level: %u, safexid: %u:%u, ",
      98             :                                  xlrec->leftsib, xlrec->rightsib, xlrec->level,
      99           0 :                                  EpochFromFullTransactionId(xlrec->safexid),
     100           0 :                                  XidFromFullTransactionId(xlrec->safexid));
     101           0 :                 appendStringInfo(buf, "leafleft: %u, leafright: %u, leaftopparent: %u",
     102             :                                  xlrec->leafleftsib, xlrec->leafrightsib,
     103             :                                  xlrec->leaftopparent);
     104           0 :                 break;
     105             :             }
     106         212 :         case XLOG_BTREE_NEWROOT:
     107             :             {
     108         212 :                 xl_btree_newroot *xlrec = (xl_btree_newroot *) rec;
     109             : 
     110         212 :                 appendStringInfo(buf, "level: %u", xlrec->level);
     111         212 :                 break;
     112             :             }
     113           0 :         case XLOG_BTREE_REUSE_PAGE:
     114             :             {
     115           0 :                 xl_btree_reuse_page *xlrec = (xl_btree_reuse_page *) rec;
     116             : 
     117           0 :                 appendStringInfo(buf, "rel: %u/%u/%u, snapshotConflictHorizon: %u:%u, isCatalogRel: %c",
     118             :                                  xlrec->locator.spcOid, xlrec->locator.dbOid,
     119             :                                  xlrec->locator.relNumber,
     120           0 :                                  EpochFromFullTransactionId(xlrec->snapshotConflictHorizon),
     121           0 :                                  XidFromFullTransactionId(xlrec->snapshotConflictHorizon),
     122           0 :                                  xlrec->isCatalogRel ? 'T' : 'F');
     123           0 :                 break;
     124             :             }
     125           0 :         case XLOG_BTREE_META_CLEANUP:
     126             :             {
     127             :                 xl_btree_metadata *xlrec;
     128             : 
     129           0 :                 xlrec = (xl_btree_metadata *) XLogRecGetBlockData(record, 0,
     130             :                                                                   NULL);
     131           0 :                 appendStringInfo(buf, "last_cleanup_num_delpages: %u",
     132             :                                  xlrec->last_cleanup_num_delpages);
     133           0 :                 break;
     134             :             }
     135             :     }
     136       70674 : }
     137             : 
     138             : const char *
     139       70686 : btree_identify(uint8 info)
     140             : {
     141       70686 :     const char *id = NULL;
     142             : 
     143       70686 :     switch (info & ~XLR_INFO_MASK)
     144             :     {
     145       69590 :         case XLOG_BTREE_INSERT_LEAF:
     146       69590 :             id = "INSERT_LEAF";
     147       69590 :             break;
     148         174 :         case XLOG_BTREE_INSERT_UPPER:
     149         174 :             id = "INSERT_UPPER";
     150         174 :             break;
     151           0 :         case XLOG_BTREE_INSERT_META:
     152           0 :             id = "INSERT_META";
     153           0 :             break;
     154          58 :         case XLOG_BTREE_SPLIT_L:
     155          58 :             id = "SPLIT_L";
     156          58 :             break;
     157         162 :         case XLOG_BTREE_SPLIT_R:
     158         162 :             id = "SPLIT_R";
     159         162 :             break;
     160           0 :         case XLOG_BTREE_INSERT_POST:
     161           0 :             id = "INSERT_POST";
     162           0 :             break;
     163         216 :         case XLOG_BTREE_DEDUP:
     164         216 :             id = "DEDUP";
     165         216 :             break;
     166         244 :         case XLOG_BTREE_VACUUM:
     167         244 :             id = "VACUUM";
     168         244 :             break;
     169          28 :         case XLOG_BTREE_DELETE:
     170          28 :             id = "DELETE";
     171          28 :             break;
     172           0 :         case XLOG_BTREE_MARK_PAGE_HALFDEAD:
     173           0 :             id = "MARK_PAGE_HALFDEAD";
     174           0 :             break;
     175           0 :         case XLOG_BTREE_UNLINK_PAGE:
     176           0 :             id = "UNLINK_PAGE";
     177           0 :             break;
     178           0 :         case XLOG_BTREE_UNLINK_PAGE_META:
     179           0 :             id = "UNLINK_PAGE_META";
     180           0 :             break;
     181         214 :         case XLOG_BTREE_NEWROOT:
     182         214 :             id = "NEWROOT";
     183         214 :             break;
     184           0 :         case XLOG_BTREE_REUSE_PAGE:
     185           0 :             id = "REUSE_PAGE";
     186           0 :             break;
     187           0 :         case XLOG_BTREE_META_CLEANUP:
     188           0 :             id = "META_CLEANUP";
     189           0 :             break;
     190             :     }
     191             : 
     192       70686 :     return id;
     193             : }
     194             : 
     195             : static void
     196         270 : delvacuum_desc(StringInfo buf, char *block_data,
     197             :                uint16 ndeleted, uint16 nupdated)
     198             : {
     199             :     OffsetNumber *deletedoffsets;
     200             :     OffsetNumber *updatedoffsets;
     201             :     xl_btree_update *updates;
     202             : 
     203             :     /* Output deleted page offset number array */
     204         270 :     appendStringInfoString(buf, ", deleted:");
     205         270 :     deletedoffsets = (OffsetNumber *) block_data;
     206         270 :     array_desc(buf, deletedoffsets, sizeof(OffsetNumber), ndeleted,
     207             :                &offset_elem_desc, NULL);
     208             : 
     209             :     /*
     210             :      * Output updates as an array of "update objects", where each element
     211             :      * contains a page offset number from updated array.  (This is not the
     212             :      * most literal representation of the underlying physical data structure
     213             :      * that we could use.  Readability seems more important here.)
     214             :      */
     215         270 :     appendStringInfoString(buf, ", updated: [");
     216         270 :     updatedoffsets = (OffsetNumber *) (block_data + ndeleted *
     217             :                                        sizeof(OffsetNumber));
     218         270 :     updates = (xl_btree_update *) ((char *) updatedoffsets +
     219         270 :                                    nupdated *
     220             :                                    sizeof(OffsetNumber));
     221        1214 :     for (int i = 0; i < nupdated; i++)
     222             :     {
     223         944 :         OffsetNumber off = updatedoffsets[i];
     224             : 
     225             :         Assert(OffsetNumberIsValid(off));
     226             :         Assert(updates->ndeletedtids > 0);
     227             : 
     228             :         /*
     229             :          * "ptid" is the symbol name used when building each xl_btree_update's
     230             :          * array of offsets into a posting list tuple's ItemPointerData array.
     231             :          * xl_btree_update describes a subset of the existing TIDs to delete.
     232             :          */
     233         944 :         appendStringInfo(buf, "{ off: %u, nptids: %u, ptids: [",
     234         944 :                          off, updates->ndeletedtids);
     235        2196 :         for (int p = 0; p < updates->ndeletedtids; p++)
     236             :         {
     237             :             uint16     *ptid;
     238             : 
     239        1252 :             ptid = (uint16 *) ((char *) updates + SizeOfBtreeUpdate) + p;
     240        1252 :             appendStringInfo(buf, "%u", *ptid);
     241             : 
     242        1252 :             if (p < updates->ndeletedtids - 1)
     243         308 :                 appendStringInfoString(buf, ", ");
     244             :         }
     245         944 :         appendStringInfoString(buf, "] }");
     246         944 :         if (i < nupdated - 1)
     247         900 :             appendStringInfoString(buf, ", ");
     248             : 
     249         944 :         updates = (xl_btree_update *)
     250         944 :             ((char *) updates + SizeOfBtreeUpdate +
     251         944 :              updates->ndeletedtids * sizeof(uint16));
     252             :     }
     253         270 :     appendStringInfoChar(buf, ']');
     254         270 : }

Generated by: LCOV version 1.14