Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * heapfuncs.c
4 : * Functions to investigate heap pages
5 : *
6 : * We check the input to these functions for corrupt pointers etc. that
7 : * might cause crashes, but at the same time we try to print out as much
8 : * information as possible, even if it's nonsense. That's because if a
9 : * page is corrupt, we don't know why and how exactly it is corrupt, so we
10 : * let the user judge it.
11 : *
12 : * These functions are restricted to superusers for the fear of introducing
13 : * security holes if the input checking isn't as water-tight as it should be.
14 : * You'd need to be superuser to obtain a raw page image anyway, so
15 : * there's hardly any use case for using these without superuser-rights
16 : * anyway.
17 : *
18 : * Copyright (c) 2007-2026, PostgreSQL Global Development Group
19 : *
20 : * IDENTIFICATION
21 : * contrib/pageinspect/heapfuncs.c
22 : *
23 : *-------------------------------------------------------------------------
24 : */
25 :
26 : #include "postgres.h"
27 :
28 : #include "access/htup_details.h"
29 : #include "access/relation.h"
30 : #include "catalog/pg_am_d.h"
31 : #include "catalog/pg_type.h"
32 : #include "funcapi.h"
33 : #include "mb/pg_wchar.h"
34 : #include "miscadmin.h"
35 : #include "port/pg_bitutils.h"
36 : #include "utils/array.h"
37 : #include "utils/builtins.h"
38 : #include "utils/rel.h"
39 :
40 : /*
41 : * It's not supported to create tuples with oids anymore, but when pg_upgrade
42 : * was used to upgrade from an older version, tuples might still have an
43 : * oid. Seems worthwhile to display that.
44 : */
45 : static inline Oid
46 0 : HeapTupleHeaderGetOidOld(const HeapTupleHeaderData *tup)
47 : {
48 0 : if (tup->t_infomask & HEAP_HASOID_OLD)
49 0 : return *((Oid *) ((char *) (tup) + (tup)->t_hoff - sizeof(Oid)));
50 : else
51 0 : return InvalidOid;
52 0 : }
53 :
54 :
55 : /*
56 : * bits_to_text
57 : *
58 : * Converts a bits8-array of 'len' bits to a human-readable
59 : * c-string representation.
60 : */
61 : static char *
62 0 : bits_to_text(bits8 *bits, int len)
63 : {
64 0 : int i;
65 0 : char *str;
66 :
67 0 : str = palloc(len + 1);
68 :
69 0 : for (i = 0; i < len; i++)
70 0 : str[i] = (bits[(i / 8)] & (1 << (i % 8))) ? '1' : '0';
71 :
72 0 : str[i] = '\0';
73 :
74 0 : return str;
75 0 : }
76 :
77 :
78 : /*
79 : * text_to_bits
80 : *
81 : * Converts a c-string representation of bits into a bits8-array. This is
82 : * the reverse operation of previous routine.
83 : */
84 : static bits8 *
85 0 : text_to_bits(char *str, int len)
86 : {
87 0 : bits8 *bits;
88 0 : int off = 0;
89 0 : char byte = 0;
90 :
91 0 : bits = palloc(len + 1);
92 :
93 0 : while (off < len)
94 : {
95 0 : if (off % 8 == 0)
96 0 : byte = 0;
97 :
98 0 : if ((str[off] == '0') || (str[off] == '1'))
99 0 : byte = byte | ((str[off] - '0') << off % 8);
100 : else
101 0 : ereport(ERROR,
102 : (errcode(ERRCODE_DATA_CORRUPTED),
103 : errmsg("invalid character \"%.*s\" in t_bits string",
104 : pg_mblen(str + off), str + off)));
105 :
106 0 : if (off % 8 == 7)
107 0 : bits[off / 8] = byte;
108 :
109 0 : off++;
110 : }
111 :
112 0 : return bits;
113 0 : }
114 :
115 : /*
116 : * heap_page_items
117 : *
118 : * Allows inspection of line pointers and tuple headers of a heap page.
119 : */
120 0 : PG_FUNCTION_INFO_V1(heap_page_items);
121 :
122 : typedef struct heap_page_items_state
123 : {
124 : TupleDesc tupd;
125 : Page page;
126 : uint16 offset;
127 : } heap_page_items_state;
128 :
129 : Datum
130 0 : heap_page_items(PG_FUNCTION_ARGS)
131 : {
132 0 : bytea *raw_page = PG_GETARG_BYTEA_P(0);
133 0 : heap_page_items_state *inter_call_data = NULL;
134 0 : FuncCallContext *fctx;
135 0 : int raw_page_size;
136 :
137 0 : if (!superuser())
138 0 : ereport(ERROR,
139 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
140 : errmsg("must be superuser to use raw page functions")));
141 :
142 0 : raw_page_size = VARSIZE(raw_page) - VARHDRSZ;
143 :
144 0 : if (SRF_IS_FIRSTCALL())
145 : {
146 0 : TupleDesc tupdesc;
147 0 : MemoryContext mctx;
148 :
149 0 : if (raw_page_size < SizeOfPageHeaderData)
150 0 : ereport(ERROR,
151 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
152 : errmsg("input page too small (%d bytes)", raw_page_size)));
153 :
154 0 : fctx = SRF_FIRSTCALL_INIT();
155 0 : mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
156 :
157 0 : inter_call_data = palloc_object(heap_page_items_state);
158 :
159 : /* Build a tuple descriptor for our result type */
160 0 : if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
161 0 : elog(ERROR, "return type must be a row type");
162 :
163 0 : inter_call_data->tupd = tupdesc;
164 :
165 0 : inter_call_data->offset = FirstOffsetNumber;
166 0 : inter_call_data->page = VARDATA(raw_page);
167 :
168 0 : fctx->max_calls = PageGetMaxOffsetNumber(inter_call_data->page);
169 0 : fctx->user_fctx = inter_call_data;
170 :
171 0 : MemoryContextSwitchTo(mctx);
172 0 : }
173 :
174 0 : fctx = SRF_PERCALL_SETUP();
175 0 : inter_call_data = fctx->user_fctx;
176 :
177 0 : if (fctx->call_cntr < fctx->max_calls)
178 : {
179 0 : Page page = inter_call_data->page;
180 0 : HeapTuple resultTuple;
181 0 : Datum result;
182 0 : ItemId id;
183 0 : Datum values[14];
184 0 : bool nulls[14];
185 0 : uint16 lp_offset;
186 0 : uint16 lp_flags;
187 0 : uint16 lp_len;
188 :
189 0 : memset(nulls, 0, sizeof(nulls));
190 :
191 : /* Extract information from the line pointer */
192 :
193 0 : id = PageGetItemId(page, inter_call_data->offset);
194 :
195 0 : lp_offset = ItemIdGetOffset(id);
196 0 : lp_flags = ItemIdGetFlags(id);
197 0 : lp_len = ItemIdGetLength(id);
198 :
199 0 : values[0] = UInt16GetDatum(inter_call_data->offset);
200 0 : values[1] = UInt16GetDatum(lp_offset);
201 0 : values[2] = UInt16GetDatum(lp_flags);
202 0 : values[3] = UInt16GetDatum(lp_len);
203 :
204 : /*
205 : * We do just enough validity checking to make sure we don't reference
206 : * data outside the page passed to us. The page could be corrupt in
207 : * many other ways, but at least we won't crash.
208 : */
209 0 : if (ItemIdHasStorage(id) &&
210 0 : lp_len >= MinHeapTupleSize &&
211 0 : lp_offset == MAXALIGN(lp_offset) &&
212 0 : lp_offset + lp_len <= raw_page_size)
213 : {
214 0 : HeapTupleHeader tuphdr;
215 :
216 : /* Extract information from the tuple header */
217 0 : tuphdr = (HeapTupleHeader) PageGetItem(page, id);
218 :
219 0 : values[4] = UInt32GetDatum(HeapTupleHeaderGetRawXmin(tuphdr));
220 0 : values[5] = UInt32GetDatum(HeapTupleHeaderGetRawXmax(tuphdr));
221 : /* shared with xvac */
222 0 : values[6] = UInt32GetDatum(HeapTupleHeaderGetRawCommandId(tuphdr));
223 0 : values[7] = PointerGetDatum(&tuphdr->t_ctid);
224 0 : values[8] = UInt32GetDatum(tuphdr->t_infomask2);
225 0 : values[9] = UInt32GetDatum(tuphdr->t_infomask);
226 0 : values[10] = UInt8GetDatum(tuphdr->t_hoff);
227 :
228 : /*
229 : * We already checked that the item is completely within the raw
230 : * page passed to us, with the length given in the line pointer.
231 : * But t_hoff could be out of range, so check it before relying on
232 : * it to fetch additional info.
233 : */
234 0 : if (tuphdr->t_hoff >= SizeofHeapTupleHeader &&
235 0 : tuphdr->t_hoff <= lp_len &&
236 0 : tuphdr->t_hoff == MAXALIGN(tuphdr->t_hoff))
237 : {
238 0 : int tuple_data_len;
239 0 : bytea *tuple_data_bytea;
240 :
241 : /* Copy null bitmask and OID, if present */
242 0 : if (tuphdr->t_infomask & HEAP_HASNULL)
243 : {
244 0 : int bitmaplen;
245 :
246 0 : bitmaplen = BITMAPLEN(HeapTupleHeaderGetNatts(tuphdr));
247 : /* better range-check the attribute count, too */
248 0 : if (bitmaplen <= tuphdr->t_hoff - SizeofHeapTupleHeader)
249 0 : values[11] =
250 0 : CStringGetTextDatum(bits_to_text(tuphdr->t_bits,
251 : bitmaplen * BITS_PER_BYTE));
252 : else
253 0 : nulls[11] = true;
254 0 : }
255 : else
256 0 : nulls[11] = true;
257 :
258 0 : if (tuphdr->t_infomask & HEAP_HASOID_OLD)
259 0 : values[12] = ObjectIdGetDatum(HeapTupleHeaderGetOidOld(tuphdr));
260 : else
261 0 : nulls[12] = true;
262 :
263 : /* Copy raw tuple data into bytea attribute */
264 0 : tuple_data_len = lp_len - tuphdr->t_hoff;
265 0 : tuple_data_bytea = (bytea *) palloc(tuple_data_len + VARHDRSZ);
266 0 : SET_VARSIZE(tuple_data_bytea, tuple_data_len + VARHDRSZ);
267 0 : if (tuple_data_len > 0)
268 0 : memcpy(VARDATA(tuple_data_bytea),
269 : (char *) tuphdr + tuphdr->t_hoff,
270 : tuple_data_len);
271 0 : values[13] = PointerGetDatum(tuple_data_bytea);
272 0 : }
273 : else
274 : {
275 0 : nulls[11] = true;
276 0 : nulls[12] = true;
277 0 : nulls[13] = true;
278 : }
279 0 : }
280 : else
281 : {
282 : /*
283 : * The line pointer is not used, or it's invalid. Set the rest of
284 : * the fields to NULL
285 : */
286 0 : int i;
287 :
288 0 : for (i = 4; i <= 13; i++)
289 0 : nulls[i] = true;
290 0 : }
291 :
292 : /* Build and return the result tuple. */
293 0 : resultTuple = heap_form_tuple(inter_call_data->tupd, values, nulls);
294 0 : result = HeapTupleGetDatum(resultTuple);
295 :
296 0 : inter_call_data->offset++;
297 :
298 0 : SRF_RETURN_NEXT(fctx, result);
299 0 : }
300 : else
301 0 : SRF_RETURN_DONE(fctx);
302 0 : }
303 :
304 : /*
305 : * tuple_data_split_internal
306 : *
307 : * Split raw tuple data taken directly from a page into an array of bytea
308 : * elements. This routine does a lookup on NULL values and creates array
309 : * elements accordingly. This is a reimplementation of nocachegetattr()
310 : * in heaptuple.c simplified for educational purposes.
311 : */
312 : static Datum
313 0 : tuple_data_split_internal(Oid relid, char *tupdata,
314 : uint16 tupdata_len, uint16 t_infomask,
315 : uint16 t_infomask2, bits8 *t_bits,
316 : bool do_detoast)
317 : {
318 0 : ArrayBuildState *raw_attrs;
319 0 : int nattrs;
320 0 : int i;
321 0 : int off = 0;
322 0 : Relation rel;
323 0 : TupleDesc tupdesc;
324 :
325 : /* Get tuple descriptor from relation OID */
326 0 : rel = relation_open(relid, AccessShareLock);
327 0 : tupdesc = RelationGetDescr(rel);
328 :
329 0 : raw_attrs = initArrayResult(BYTEAOID, CurrentMemoryContext, false);
330 0 : nattrs = tupdesc->natts;
331 :
332 : /*
333 : * Sequences always use heap AM, but they don't show that in the catalogs.
334 : */
335 0 : if (rel->rd_rel->relkind != RELKIND_SEQUENCE &&
336 0 : rel->rd_rel->relam != HEAP_TABLE_AM_OID)
337 0 : ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
338 : errmsg("only heap AM is supported")));
339 :
340 0 : if (nattrs < (t_infomask2 & HEAP_NATTS_MASK))
341 0 : ereport(ERROR,
342 : (errcode(ERRCODE_DATA_CORRUPTED),
343 : errmsg("number of attributes in tuple header is greater than number of attributes in tuple descriptor")));
344 :
345 0 : for (i = 0; i < nattrs; i++)
346 : {
347 0 : CompactAttribute *attr;
348 0 : bool is_null;
349 0 : bytea *attr_data = NULL;
350 :
351 0 : attr = TupleDescCompactAttr(tupdesc, i);
352 :
353 : /*
354 : * Tuple header can specify fewer attributes than tuple descriptor as
355 : * ALTER TABLE ADD COLUMN without DEFAULT keyword does not actually
356 : * change tuples in pages, so attributes with numbers greater than
357 : * (t_infomask2 & HEAP_NATTS_MASK) should be treated as NULL.
358 : */
359 0 : if (i >= (t_infomask2 & HEAP_NATTS_MASK))
360 0 : is_null = true;
361 : else
362 0 : is_null = (t_infomask & HEAP_HASNULL) && att_isnull(i, t_bits);
363 :
364 0 : if (!is_null)
365 : {
366 0 : int len;
367 :
368 0 : if (attr->attlen == -1)
369 : {
370 0 : off = att_pointer_alignby(off, attr->attalignby, -1,
371 : tupdata + off);
372 :
373 : /*
374 : * As VARSIZE_ANY throws an exception if it can't properly
375 : * detect the type of external storage in macros VARTAG_SIZE,
376 : * this check is repeated to have a nicer error handling.
377 : */
378 0 : if (VARATT_IS_EXTERNAL(tupdata + off) &&
379 0 : !VARATT_IS_EXTERNAL_ONDISK(tupdata + off) &&
380 0 : !VARATT_IS_EXTERNAL_INDIRECT(tupdata + off))
381 0 : ereport(ERROR,
382 : (errcode(ERRCODE_DATA_CORRUPTED),
383 : errmsg("first byte of varlena attribute is incorrect for attribute %d", i)));
384 :
385 0 : len = VARSIZE_ANY(tupdata + off);
386 0 : }
387 : else
388 : {
389 0 : off = att_nominal_alignby(off, attr->attalignby);
390 0 : len = attr->attlen;
391 : }
392 :
393 0 : if (tupdata_len < off + len)
394 0 : ereport(ERROR,
395 : (errcode(ERRCODE_DATA_CORRUPTED),
396 : errmsg("unexpected end of tuple data")));
397 :
398 0 : if (attr->attlen == -1 && do_detoast)
399 0 : attr_data = pg_detoast_datum_copy((struct varlena *) (tupdata + off));
400 : else
401 : {
402 0 : attr_data = (bytea *) palloc(len + VARHDRSZ);
403 0 : SET_VARSIZE(attr_data, len + VARHDRSZ);
404 0 : memcpy(VARDATA(attr_data), tupdata + off, len);
405 : }
406 :
407 0 : off = att_addlength_pointer(off, attr->attlen,
408 : tupdata + off);
409 0 : }
410 :
411 0 : raw_attrs = accumArrayResult(raw_attrs, PointerGetDatum(attr_data),
412 0 : is_null, BYTEAOID, CurrentMemoryContext);
413 0 : if (attr_data)
414 0 : pfree(attr_data);
415 0 : }
416 :
417 0 : if (tupdata_len != off)
418 0 : ereport(ERROR,
419 : (errcode(ERRCODE_DATA_CORRUPTED),
420 : errmsg("end of tuple reached without looking at all its data")));
421 :
422 0 : relation_close(rel, AccessShareLock);
423 :
424 0 : return makeArrayResult(raw_attrs, CurrentMemoryContext);
425 0 : }
426 :
427 : /*
428 : * tuple_data_split
429 : *
430 : * Split raw tuple data taken directly from page into distinct elements
431 : * taking into account null values.
432 : */
433 0 : PG_FUNCTION_INFO_V1(tuple_data_split);
434 :
435 : Datum
436 0 : tuple_data_split(PG_FUNCTION_ARGS)
437 : {
438 0 : Oid relid;
439 0 : bytea *raw_data;
440 0 : uint16 t_infomask;
441 0 : uint16 t_infomask2;
442 0 : char *t_bits_str;
443 0 : bool do_detoast = false;
444 0 : bits8 *t_bits = NULL;
445 0 : Datum res;
446 :
447 0 : relid = PG_GETARG_OID(0);
448 0 : raw_data = PG_ARGISNULL(1) ? NULL : PG_GETARG_BYTEA_P(1);
449 0 : t_infomask = PG_GETARG_INT16(2);
450 0 : t_infomask2 = PG_GETARG_INT16(3);
451 0 : t_bits_str = PG_ARGISNULL(4) ? NULL :
452 0 : text_to_cstring(PG_GETARG_TEXT_PP(4));
453 :
454 0 : if (PG_NARGS() >= 6)
455 0 : do_detoast = PG_GETARG_BOOL(5);
456 :
457 0 : if (!superuser())
458 0 : ereport(ERROR,
459 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
460 : errmsg("must be superuser to use raw page functions")));
461 :
462 0 : if (!raw_data)
463 0 : PG_RETURN_NULL();
464 :
465 : /*
466 : * Convert t_bits string back to the bits8 array as represented in the
467 : * tuple header.
468 : */
469 0 : if (t_infomask & HEAP_HASNULL)
470 : {
471 0 : size_t bits_str_len;
472 0 : size_t bits_len;
473 :
474 0 : bits_len = BITMAPLEN(t_infomask2 & HEAP_NATTS_MASK) * BITS_PER_BYTE;
475 0 : if (!t_bits_str)
476 0 : ereport(ERROR,
477 : (errcode(ERRCODE_DATA_CORRUPTED),
478 : errmsg("t_bits string must not be NULL")));
479 :
480 0 : bits_str_len = strlen(t_bits_str);
481 0 : if (bits_len != bits_str_len)
482 0 : ereport(ERROR,
483 : (errcode(ERRCODE_DATA_CORRUPTED),
484 : errmsg("unexpected length of t_bits string: %zu, expected %zu",
485 : bits_str_len, bits_len)));
486 :
487 : /* do the conversion */
488 0 : t_bits = text_to_bits(t_bits_str, bits_str_len);
489 0 : }
490 : else
491 : {
492 0 : if (t_bits_str)
493 0 : ereport(ERROR,
494 : (errcode(ERRCODE_DATA_CORRUPTED),
495 : errmsg("t_bits string is expected to be NULL, but instead it is %zu bytes long",
496 : strlen(t_bits_str))));
497 : }
498 :
499 : /* Split tuple data */
500 0 : res = tuple_data_split_internal(relid, (char *) raw_data + VARHDRSZ,
501 0 : VARSIZE(raw_data) - VARHDRSZ,
502 0 : t_infomask, t_infomask2, t_bits,
503 0 : do_detoast);
504 :
505 0 : if (t_bits)
506 0 : pfree(t_bits);
507 :
508 0 : PG_RETURN_DATUM(res);
509 0 : }
510 :
511 : /*
512 : * heap_tuple_infomask_flags
513 : *
514 : * Decode into a human-readable format t_infomask and t_infomask2 associated
515 : * to a tuple. All the flags are described in access/htup_details.h.
516 : */
517 0 : PG_FUNCTION_INFO_V1(heap_tuple_infomask_flags);
518 :
519 : Datum
520 0 : heap_tuple_infomask_flags(PG_FUNCTION_ARGS)
521 : {
522 : #define HEAP_TUPLE_INFOMASK_COLS 2
523 0 : Datum values[HEAP_TUPLE_INFOMASK_COLS] = {0};
524 0 : bool nulls[HEAP_TUPLE_INFOMASK_COLS] = {0};
525 0 : uint16 t_infomask = PG_GETARG_INT16(0);
526 0 : uint16 t_infomask2 = PG_GETARG_INT16(1);
527 0 : int cnt = 0;
528 0 : ArrayType *a;
529 0 : int bitcnt;
530 0 : Datum *flags;
531 0 : TupleDesc tupdesc;
532 0 : HeapTuple tuple;
533 :
534 0 : if (!superuser())
535 0 : ereport(ERROR,
536 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
537 : errmsg("must be superuser to use raw page functions")));
538 :
539 : /* Build a tuple descriptor for our result type */
540 0 : if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
541 0 : elog(ERROR, "return type must be a row type");
542 :
543 0 : bitcnt = pg_popcount((const char *) &t_infomask, sizeof(uint16)) +
544 0 : pg_popcount((const char *) &t_infomask2, sizeof(uint16));
545 :
546 : /* If no flags, return a set of empty arrays */
547 0 : if (bitcnt <= 0)
548 : {
549 0 : values[0] = PointerGetDatum(construct_empty_array(TEXTOID));
550 0 : values[1] = PointerGetDatum(construct_empty_array(TEXTOID));
551 0 : tuple = heap_form_tuple(tupdesc, values, nulls);
552 0 : PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
553 : }
554 :
555 : /* build set of raw flags */
556 0 : flags = palloc0_array(Datum, bitcnt);
557 :
558 : /* decode t_infomask */
559 0 : if ((t_infomask & HEAP_HASNULL) != 0)
560 0 : flags[cnt++] = CStringGetTextDatum("HEAP_HASNULL");
561 0 : if ((t_infomask & HEAP_HASVARWIDTH) != 0)
562 0 : flags[cnt++] = CStringGetTextDatum("HEAP_HASVARWIDTH");
563 0 : if ((t_infomask & HEAP_HASEXTERNAL) != 0)
564 0 : flags[cnt++] = CStringGetTextDatum("HEAP_HASEXTERNAL");
565 0 : if ((t_infomask & HEAP_HASOID_OLD) != 0)
566 0 : flags[cnt++] = CStringGetTextDatum("HEAP_HASOID_OLD");
567 0 : if ((t_infomask & HEAP_XMAX_KEYSHR_LOCK) != 0)
568 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_KEYSHR_LOCK");
569 0 : if ((t_infomask & HEAP_COMBOCID) != 0)
570 0 : flags[cnt++] = CStringGetTextDatum("HEAP_COMBOCID");
571 0 : if ((t_infomask & HEAP_XMAX_EXCL_LOCK) != 0)
572 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_EXCL_LOCK");
573 0 : if ((t_infomask & HEAP_XMAX_LOCK_ONLY) != 0)
574 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_LOCK_ONLY");
575 0 : if ((t_infomask & HEAP_XMIN_COMMITTED) != 0)
576 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_COMMITTED");
577 0 : if ((t_infomask & HEAP_XMIN_INVALID) != 0)
578 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_INVALID");
579 0 : if ((t_infomask & HEAP_XMAX_COMMITTED) != 0)
580 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_COMMITTED");
581 0 : if ((t_infomask & HEAP_XMAX_INVALID) != 0)
582 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_INVALID");
583 0 : if ((t_infomask & HEAP_XMAX_IS_MULTI) != 0)
584 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_IS_MULTI");
585 0 : if ((t_infomask & HEAP_UPDATED) != 0)
586 0 : flags[cnt++] = CStringGetTextDatum("HEAP_UPDATED");
587 0 : if ((t_infomask & HEAP_MOVED_OFF) != 0)
588 0 : flags[cnt++] = CStringGetTextDatum("HEAP_MOVED_OFF");
589 0 : if ((t_infomask & HEAP_MOVED_IN) != 0)
590 0 : flags[cnt++] = CStringGetTextDatum("HEAP_MOVED_IN");
591 :
592 : /* decode t_infomask2 */
593 0 : if ((t_infomask2 & HEAP_KEYS_UPDATED) != 0)
594 0 : flags[cnt++] = CStringGetTextDatum("HEAP_KEYS_UPDATED");
595 0 : if ((t_infomask2 & HEAP_HOT_UPDATED) != 0)
596 0 : flags[cnt++] = CStringGetTextDatum("HEAP_HOT_UPDATED");
597 0 : if ((t_infomask2 & HEAP_ONLY_TUPLE) != 0)
598 0 : flags[cnt++] = CStringGetTextDatum("HEAP_ONLY_TUPLE");
599 :
600 : /* build value */
601 0 : Assert(cnt <= bitcnt);
602 0 : a = construct_array_builtin(flags, cnt, TEXTOID);
603 0 : values[0] = PointerGetDatum(a);
604 :
605 : /*
606 : * Build set of combined flags. Use the same array as previously, this
607 : * keeps the code simple.
608 : */
609 0 : cnt = 0;
610 0 : MemSet(flags, 0, sizeof(Datum) * bitcnt);
611 :
612 : /* decode combined masks of t_infomask */
613 0 : if ((t_infomask & HEAP_XMAX_SHR_LOCK) == HEAP_XMAX_SHR_LOCK)
614 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_SHR_LOCK");
615 0 : if ((t_infomask & HEAP_XMIN_FROZEN) == HEAP_XMIN_FROZEN)
616 0 : flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_FROZEN");
617 0 : if ((t_infomask & HEAP_MOVED) == HEAP_MOVED)
618 0 : flags[cnt++] = CStringGetTextDatum("HEAP_MOVED");
619 :
620 : /* Build an empty array if there are no combined flags */
621 0 : if (cnt == 0)
622 0 : a = construct_empty_array(TEXTOID);
623 : else
624 0 : a = construct_array_builtin(flags, cnt, TEXTOID);
625 0 : pfree(flags);
626 0 : values[1] = PointerGetDatum(a);
627 :
628 : /* Returns the record as Datum */
629 0 : tuple = heap_form_tuple(tupdesc, values, nulls);
630 0 : PG_RETURN_DATUM(HeapTupleGetDatum(tuple));
631 0 : }
|
