src/backend/access/rmgrdesc/heapdesc.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * heapdesc.c
   4  *        rmgr descriptor routines for access/heap/heapam.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/heapdesc.c
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 #include "postgres.h"
  16
  17 #include "access/heapam_xlog.h"
  18 #include "access/rmgrdesc_utils.h"
  19 #include "storage/standbydefs.h"
  20
  21 /*
  22  * NOTE: "keyname" argument cannot have trailing spaces or punctuation
  23  * characters
  24  */
  25 static void
  26 infobits_desc(StringInfo buf, uint8 infobits, const char *keyname)
  27 {
  28         appendStringInfo(buf, "%s: [", keyname);
  29
  30         Assert(buf->data[buf->len - 1] != ' ');
  31
  32         if (infobits & XLHL_XMAX_IS_MULTI)
  33                 appendStringInfoString(buf, "IS_MULTI, ");
  34         if (infobits & XLHL_XMAX_LOCK_ONLY)
  35                 appendStringInfoString(buf, "LOCK_ONLY, ");
  36         if (infobits & XLHL_XMAX_EXCL_LOCK)
  37                 appendStringInfoString(buf, "EXCL_LOCK, ");
  38         if (infobits & XLHL_XMAX_KEYSHR_LOCK)
  39                 appendStringInfoString(buf, "KEYSHR_LOCK, ");
  40         if (infobits & XLHL_KEYS_UPDATED)
  41                 appendStringInfoString(buf, "KEYS_UPDATED, ");
  42
  43         if (buf->data[buf->len - 1] == ' ')
  44         {
  45                 /* Truncate-away final unneeded ", "  */
  46                 Assert(buf->data[buf->len - 2] == ',');
  47                 buf->len -= 2;
  48                 buf->data[buf->len] = '\0';
  49         }
  50
  51         appendStringInfoChar(buf, ']');
  52 }
  53
  54 static void
  55 truncate_flags_desc(StringInfo buf, uint8 flags)
  56 {
  57         appendStringInfoString(buf, "flags: [");
  58
  59         if (flags & XLH_TRUNCATE_CASCADE)
  60                 appendStringInfoString(buf, "CASCADE, ");
  61         if (flags & XLH_TRUNCATE_RESTART_SEQS)
  62                 appendStringInfoString(buf, "RESTART_SEQS, ");
  63
  64         if (buf->data[buf->len - 1] == ' ')
  65         {
  66                 /* Truncate-away final unneeded ", "  */
  67                 Assert(buf->data[buf->len - 2] == ',');
  68                 buf->len -= 2;
  69                 buf->data[buf->len] = '\0';
  70         }
  71
  72         appendStringInfoChar(buf, ']');
  73 }
  74
  75 static void
  76 plan_elem_desc(StringInfo buf, void *plan, void *data)
  77 {
  78         xlhp_freeze_plan *new_plan = (xlhp_freeze_plan *) plan;
  79         OffsetNumber **offsets = data;
  80
  81         appendStringInfo(buf, "{ xmax: %u, infomask: %u, infomask2: %u, ntuples: %u",
  82                                          new_plan->xmax,
  83                                          new_plan->t_infomask, new_plan->t_infomask2,
  84                                          new_plan->ntuples);
  85
  86         appendStringInfoString(buf, ", offsets:");
  87         array_desc(buf, *offsets, sizeof(OffsetNumber), new_plan->ntuples,
  88                            &offset_elem_desc, NULL);
  89
  90         *offsets += new_plan->ntuples;
  91
  92         appendStringInfoString(buf, " }");
  93 }
  94
  95
  96 /*
  97  * Given a MAXALIGNed buffer returned by XLogRecGetBlockData() and pointed to
  98  * by cursor and any xl_heap_prune flags, deserialize the arrays of
  99  * OffsetNumbers contained in an XLOG_HEAP2_PRUNE_* record.
 100  *
 101  * This is in heapdesc.c so it can be shared between heap2_redo and heap2_desc
 102  * code, the latter of which is used in frontend (pg_waldump) code.
 103  */
 104 void
 105 heap_xlog_deserialize_prune_and_freeze(char *cursor, uint8 flags,
 106                                                                            int *nplans, xlhp_freeze_plan **plans,
 107                                                                            OffsetNumber **frz_offsets,
 108                                                                            int *nredirected, OffsetNumber **redirected,
 109                                                                            int *ndead, OffsetNumber **nowdead,
 110                                                                            int *nunused, OffsetNumber **nowunused)
 111 {
 112         if (flags & XLHP_HAS_FREEZE_PLANS)
 113         {
 114                 xlhp_freeze_plans *freeze_plans = (xlhp_freeze_plans *) cursor;
 115
 116                 *nplans = freeze_plans->nplans;
 117                 Assert(*nplans > 0);
 118                 *plans = freeze_plans->plans;
 119
 120                 cursor += offsetof(xlhp_freeze_plans, plans);
 121                 cursor += sizeof(xlhp_freeze_plan) * *nplans;
 122         }
 123         else
 124         {
 125                 *nplans = 0;
 126                 *plans = NULL;
 127         }
 128
 129         if (flags & XLHP_HAS_REDIRECTIONS)
 130         {
 131                 xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
 132
 133                 *nredirected = subrecord->ntargets;
 134                 Assert(*nredirected > 0);
 135                 *redirected = &subrecord->data[0];
 136
 137                 cursor += offsetof(xlhp_prune_items, data);
 138                 cursor += sizeof(OffsetNumber[2]) * *nredirected;
 139         }
 140         else
 141         {
 142                 *nredirected = 0;
 143                 *redirected = NULL;
 144         }
 145
 146         if (flags & XLHP_HAS_DEAD_ITEMS)
 147         {
 148                 xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
 149
 150                 *ndead = subrecord->ntargets;
 151                 Assert(*ndead > 0);
 152                 *nowdead = subrecord->data;
 153
 154                 cursor += offsetof(xlhp_prune_items, data);
 155                 cursor += sizeof(OffsetNumber) * *ndead;
 156         }
 157         else
 158         {
 159                 *ndead = 0;
 160                 *nowdead = NULL;
 161         }
 162
 163         if (flags & XLHP_HAS_NOW_UNUSED_ITEMS)
 164         {
 165                 xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
 166
 167                 *nunused = subrecord->ntargets;
 168                 Assert(*nunused > 0);
 169                 *nowunused = subrecord->data;
 170
 171                 cursor += offsetof(xlhp_prune_items, data);
 172                 cursor += sizeof(OffsetNumber) * *nunused;
 173         }
 174         else
 175         {
 176                 *nunused = 0;
 177                 *nowunused = NULL;
 178         }
 179
 180         *frz_offsets = (OffsetNumber *) cursor;
 181 }
 182
 183 void
 184 heap_desc(StringInfo buf, XLogReaderState *record)
 185 {
 186         char       *rec = XLogRecGetData(record);
 187         uint8           info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 188
 189         info &= XLOG_HEAP_OPMASK;
 190         if (info == XLOG_HEAP_INSERT)
 191         {
 192                 xl_heap_insert *xlrec = (xl_heap_insert *) rec;
 193
 194                 appendStringInfo(buf, "off: %u, flags: 0x%02X",
 195                                                  xlrec->offnum,
 196                                                  xlrec->flags);
 197         }
 198         else if (info == XLOG_HEAP_DELETE)
 199         {
 200                 xl_heap_delete *xlrec = (xl_heap_delete *) rec;
 201
 202                 appendStringInfo(buf, "xmax: %u, off: %u, ",
 203                                                  xlrec->xmax, xlrec->offnum);
 204                 infobits_desc(buf, xlrec->infobits_set, "infobits");
 205                 appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
 206         }
 207         else if (info == XLOG_HEAP_UPDATE)
 208         {
 209                 xl_heap_update *xlrec = (xl_heap_update *) rec;
 210
 211                 appendStringInfo(buf, "old_xmax: %u, old_off: %u, ",
 212                                                  xlrec->old_xmax, xlrec->old_offnum);
 213                 infobits_desc(buf, xlrec->old_infobits_set, "old_infobits");
 214                 appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %u, new_off: %u",
 215                                                  xlrec->flags, xlrec->new_xmax, xlrec->new_offnum);
 216         }
 217         else if (info == XLOG_HEAP_HOT_UPDATE)
 218         {
 219                 xl_heap_update *xlrec = (xl_heap_update *) rec;
 220
 221                 appendStringInfo(buf, "old_xmax: %u, old_off: %u, ",
 222                                                  xlrec->old_xmax, xlrec->old_offnum);
 223                 infobits_desc(buf, xlrec->old_infobits_set, "old_infobits");
 224                 appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %u, new_off: %u",
 225                                                  xlrec->flags, xlrec->new_xmax, xlrec->new_offnum);
 226         }
 227         else if (info == XLOG_HEAP_TRUNCATE)
 228         {
 229                 xl_heap_truncate *xlrec = (xl_heap_truncate *) rec;
 230
 231                 truncate_flags_desc(buf, xlrec->flags);
 232                 appendStringInfo(buf, ", nrelids: %u", xlrec->nrelids);
 233                 appendStringInfoString(buf, ", relids:");
 234                 array_desc(buf, xlrec->relids, sizeof(Oid), xlrec->nrelids,
 235                                    &oid_elem_desc, NULL);
 236         }
 237         else if (info == XLOG_HEAP_CONFIRM)
 238         {
 239                 xl_heap_confirm *xlrec = (xl_heap_confirm *) rec;
 240
 241                 appendStringInfo(buf, "off: %u", xlrec->offnum);
 242         }
 243         else if (info == XLOG_HEAP_LOCK)
 244         {
 245                 xl_heap_lock *xlrec = (xl_heap_lock *) rec;
 246
 247                 appendStringInfo(buf, "xmax: %u, off: %u, ",
 248                                                  xlrec->xmax, xlrec->offnum);
 249                 infobits_desc(buf, xlrec->infobits_set, "infobits");
 250                 appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
 251         }
 252         else if (info == XLOG_HEAP_INPLACE)
 253         {
 254                 xl_heap_inplace *xlrec = (xl_heap_inplace *) rec;
 255
 256                 appendStringInfo(buf, "off: %u", xlrec->offnum);
 257                 standby_desc_invalidations(buf, xlrec->nmsgs, xlrec->msgs,
 258                                                                    xlrec->dbId, xlrec->tsId,
 259                                                                    xlrec->relcacheInitFileInval);
 260         }
 261 }
 262
 263 void
 264 heap2_desc(StringInfo buf, XLogReaderState *record)
 265 {
 266         char       *rec = XLogRecGetData(record);
 267         uint8           info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 268
 269         info &= XLOG_HEAP_OPMASK;
 270         if (info == XLOG_HEAP2_PRUNE_ON_ACCESS ||
 271                 info == XLOG_HEAP2_PRUNE_VACUUM_SCAN ||
 272                 info == XLOG_HEAP2_PRUNE_VACUUM_CLEANUP)
 273         {
 274                 xl_heap_prune *xlrec = (xl_heap_prune *) rec;
 275
 276                 if (xlrec->flags & XLHP_HAS_CONFLICT_HORIZON)
 277                 {
 278                         TransactionId conflict_xid;
 279
 280                         memcpy(&conflict_xid, rec + SizeOfHeapPrune, sizeof(TransactionId));
 281
 282                         appendStringInfo(buf, "snapshotConflictHorizon: %u",
 283                                                          conflict_xid);
 284                 }
 285
 286                 appendStringInfo(buf, ", isCatalogRel: %c",
 287                                                  xlrec->flags & XLHP_IS_CATALOG_REL ? 'T' : 'F');
 288
 289                 if (XLogRecHasBlockData(record, 0))
 290                 {
 291                         Size            datalen;
 292                         OffsetNumber *redirected;
 293                         OffsetNumber *nowdead;
 294                         OffsetNumber *nowunused;
 295                         int                     nredirected;
 296                         int                     nunused;
 297                         int                     ndead;
 298                         int                     nplans;
 299                         xlhp_freeze_plan *plans;
 300                         OffsetNumber *frz_offsets;
 301
 302                         char       *cursor = XLogRecGetBlockData(record, 0, &datalen);
 303
 304                         heap_xlog_deserialize_prune_and_freeze(cursor, xlrec->flags,
 305                                                                                                    &nplans, &plans, &frz_offsets,
 306                                                                                                    &nredirected, &redirected,
 307                                                                                                    &ndead, &nowdead,
 308                                                                                                    &nunused, &nowunused);
 309
 310                         appendStringInfo(buf, ", nplans: %u, nredirected: %u, ndead: %u, nunused: %u",
 311                                                          nplans, nredirected, ndead, nunused);
 312
 313                         if (nplans > 0)
 314                         {
 315                                 appendStringInfoString(buf, ", plans:");
 316                                 array_desc(buf, plans, sizeof(xlhp_freeze_plan), nplans,
 317                                                    &plan_elem_desc, &frz_offsets);
 318                         }
 319
 320                         if (nredirected > 0)
 321                         {
 322                                 appendStringInfoString(buf, ", redirected:");
 323                                 array_desc(buf, redirected, sizeof(OffsetNumber) * 2,
 324                                                    nredirected, &redirect_elem_desc, NULL);
 325                         }
 326
 327                         if (ndead > 0)
 328                         {
 329                                 appendStringInfoString(buf, ", dead:");
 330                                 array_desc(buf, nowdead, sizeof(OffsetNumber), ndead,
 331                                                    &offset_elem_desc, NULL);
 332                         }
 333
 334                         if (nunused > 0)
 335                         {
 336                                 appendStringInfoString(buf, ", unused:");
 337                                 array_desc(buf, nowunused, sizeof(OffsetNumber), nunused,
 338                                                    &offset_elem_desc, NULL);
 339                         }
 340                 }
 341         }
 342         else if (info == XLOG_HEAP2_VISIBLE)
 343         {
 344                 xl_heap_visible *xlrec = (xl_heap_visible *) rec;
 345
 346                 appendStringInfo(buf, "snapshotConflictHorizon: %u, flags: 0x%02X",
 347                                                  xlrec->snapshotConflictHorizon, xlrec->flags);
 348         }
 349         else if (info == XLOG_HEAP2_MULTI_INSERT)
 350         {
 351                 xl_heap_multi_insert *xlrec = (xl_heap_multi_insert *) rec;
 352                 bool            isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
 353
 354                 appendStringInfo(buf, "ntuples: %d, flags: 0x%02X", xlrec->ntuples,
 355                                                  xlrec->flags);
 356
 357                 if (XLogRecHasBlockData(record, 0) && !isinit)
 358                 {
 359                         appendStringInfoString(buf, ", offsets:");
 360                         array_desc(buf, xlrec->offsets, sizeof(OffsetNumber),
 361                                            xlrec->ntuples, &offset_elem_desc, NULL);
 362                 }
 363         }
 364         else if (info == XLOG_HEAP2_LOCK_UPDATED)
 365         {
 366                 xl_heap_lock_updated *xlrec = (xl_heap_lock_updated *) rec;
 367
 368                 appendStringInfo(buf, "xmax: %u, off: %u, ",
 369                                                  xlrec->xmax, xlrec->offnum);
 370                 infobits_desc(buf, xlrec->infobits_set, "infobits");
 371                 appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
 372         }
 373         else if (info == XLOG_HEAP2_NEW_CID)
 374         {
 375                 xl_heap_new_cid *xlrec = (xl_heap_new_cid *) rec;
 376
 377                 appendStringInfo(buf, "rel: %u/%u/%u, tid: %u/%u",
 378                                                  xlrec->target_locator.spcOid,
 379                                                  xlrec->target_locator.dbOid,
 380                                                  xlrec->target_locator.relNumber,
 381                                                  ItemPointerGetBlockNumber(&(xlrec->target_tid)),
 382                                                  ItemPointerGetOffsetNumber(&(xlrec->target_tid)));
 383                 appendStringInfo(buf, ", cmin: %u, cmax: %u, combo: %u",
 384                                                  xlrec->cmin, xlrec->cmax, xlrec->combocid);
 385         }
 386 }
 387
 388 const char *
 389 heap_identify(uint8 info)
 390 {
 391         const char *id = NULL;
 392
 393         switch (info & ~XLR_INFO_MASK)
 394         {
 395                 case XLOG_HEAP_INSERT:
 396                         id = "INSERT";
 397                         break;
 398                 case XLOG_HEAP_INSERT | XLOG_HEAP_INIT_PAGE:
 399                         id = "INSERT+INIT";
 400                         break;
 401                 case XLOG_HEAP_DELETE:
 402                         id = "DELETE";
 403                         break;
 404                 case XLOG_HEAP_UPDATE:
 405                         id = "UPDATE";
 406                         break;
 407                 case XLOG_HEAP_UPDATE | XLOG_HEAP_INIT_PAGE:
 408                         id = "UPDATE+INIT";
 409                         break;
 410                 case XLOG_HEAP_HOT_UPDATE:
 411                         id = "HOT_UPDATE";
 412                         break;
 413                 case XLOG_HEAP_HOT_UPDATE | XLOG_HEAP_INIT_PAGE:
 414                         id = "HOT_UPDATE+INIT";
 415                         break;
 416                 case XLOG_HEAP_TRUNCATE:
 417                         id = "TRUNCATE";
 418                         break;
 419                 case XLOG_HEAP_CONFIRM:
 420                         id = "HEAP_CONFIRM";
 421                         break;
 422                 case XLOG_HEAP_LOCK:
 423                         id = "LOCK";
 424                         break;
 425                 case XLOG_HEAP_INPLACE:
 426                         id = "INPLACE";
 427                         break;
 428         }
 429
 430         return id;
 431 }
 432
 433 const char *
 434 heap2_identify(uint8 info)
 435 {
 436         const char *id = NULL;
 437
 438         switch (info & ~XLR_INFO_MASK)
 439         {
 440                 case XLOG_HEAP2_PRUNE_ON_ACCESS:
 441                         id = "PRUNE_ON_ACCESS";
 442                         break;
 443                 case XLOG_HEAP2_PRUNE_VACUUM_SCAN:
 444                         id = "PRUNE_VACUUM_SCAN";
 445                         break;
 446                 case XLOG_HEAP2_PRUNE_VACUUM_CLEANUP:
 447                         id = "PRUNE_VACUUM_CLEANUP";
 448                         break;
 449                 case XLOG_HEAP2_VISIBLE:
 450                         id = "VISIBLE";
 451                         break;
 452                 case XLOG_HEAP2_MULTI_INSERT:
 453                         id = "MULTI_INSERT";
 454                         break;
 455                 case XLOG_HEAP2_MULTI_INSERT | XLOG_HEAP_INIT_PAGE:
 456                         id = "MULTI_INSERT+INIT";
 457                         break;
 458                 case XLOG_HEAP2_LOCK_UPDATED:
 459                         id = "LOCK_UPDATED";
 460                         break;
 461                 case XLOG_HEAP2_NEW_CID:
 462                         id = "NEW_CID";
 463                         break;
 464                 case XLOG_HEAP2_REWRITE:
 465                         id = "REWRITE";
 466                         break;
 467         }
 468
 469         return id;
 470 }