Debian Codegraph @

src/backend/access/rmgrdesc/heapdesc.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * heapdesc.c
4 * rmgr descriptor routines for access/heap/heapam.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/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 }