PostgreSQL Source Code git master
heapfuncs.c
Go to the documentation of this file.
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-2025, 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 */
45static inline Oid
47{
48 if (tup->t_infomask & HEAP_HASOID_OLD)
49 return *((Oid *) ((char *) (tup) + (tup)->t_hoff - sizeof(Oid)));
50 else
51 return InvalidOid;
52}
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 */
61static char *
63{
64 int i;
65 char *str;
66
67 str = palloc(len + 1);
68
69 for (i = 0; i < len; i++)
70 str[i] = (bits[(i / 8)] & (1 << (i % 8))) ? '1' : '0';
71
72 str[i] = '\0';
73
74 return str;
75}
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 */
84static bits8 *
85text_to_bits(char *str, int len)
86{
87 bits8 *bits;
88 int off = 0;
89 char byte = 0;
90
91 bits = palloc(len + 1);
92
93 while (off < len)
94 {
95 if (off % 8 == 0)
96 byte = 0;
97
98 if ((str[off] == '0') || (str[off] == '1'))
99 byte = byte | ((str[off] - '0') << off % 8);
100 else
103 errmsg("invalid character \"%.*s\" in t_bits string",
104 pg_mblen(str + off), str + off)));
105
106 if (off % 8 == 7)
107 bits[off / 8] = byte;
108
109 off++;
110 }
111
112 return bits;
113}
114
115/*
116 * heap_page_items
117 *
118 * Allows inspection of line pointers and tuple headers of a heap page.
119 */
121
123{
128
129Datum
131{
132 bytea *raw_page = PG_GETARG_BYTEA_P(0);
133 heap_page_items_state *inter_call_data = NULL;
134 FuncCallContext *fctx;
135 int raw_page_size;
136
137 if (!superuser())
139 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
140 errmsg("must be superuser to use raw page functions")));
141
142 raw_page_size = VARSIZE(raw_page) - VARHDRSZ;
143
144 if (SRF_IS_FIRSTCALL())
145 {
146 TupleDesc tupdesc;
147 MemoryContext mctx;
148
149 if (raw_page_size < SizeOfPageHeaderData)
151 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
152 errmsg("input page too small (%d bytes)", raw_page_size)));
153
154 fctx = SRF_FIRSTCALL_INIT();
156
157 inter_call_data = palloc(sizeof(heap_page_items_state));
158
159 /* Build a tuple descriptor for our result type */
160 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
161 elog(ERROR, "return type must be a row type");
162
163 inter_call_data->tupd = tupdesc;
164
165 inter_call_data->offset = FirstOffsetNumber;
166 inter_call_data->page = VARDATA(raw_page);
167
168 fctx->max_calls = PageGetMaxOffsetNumber(inter_call_data->page);
169 fctx->user_fctx = inter_call_data;
170
172 }
173
174 fctx = SRF_PERCALL_SETUP();
175 inter_call_data = fctx->user_fctx;
176
177 if (fctx->call_cntr < fctx->max_calls)
178 {
179 Page page = inter_call_data->page;
180 HeapTuple resultTuple;
181 Datum result;
182 ItemId id;
183 Datum values[14];
184 bool nulls[14];
185 uint16 lp_offset;
186 uint16 lp_flags;
187 uint16 lp_len;
188
189 memset(nulls, 0, sizeof(nulls));
190
191 /* Extract information from the line pointer */
192
193 id = PageGetItemId(page, inter_call_data->offset);
194
195 lp_offset = ItemIdGetOffset(id);
196 lp_flags = ItemIdGetFlags(id);
197 lp_len = ItemIdGetLength(id);
198
199 values[0] = UInt16GetDatum(inter_call_data->offset);
200 values[1] = UInt16GetDatum(lp_offset);
201 values[2] = UInt16GetDatum(lp_flags);
202 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 if (ItemIdHasStorage(id) &&
210 lp_len >= MinHeapTupleSize &&
211 lp_offset == MAXALIGN(lp_offset) &&
212 lp_offset + lp_len <= raw_page_size)
213 {
214 HeapTupleHeader tuphdr;
215 bytea *tuple_data_bytea;
216 int tuple_data_len;
217
218 /* Extract information from the tuple header */
219
220 tuphdr = (HeapTupleHeader) PageGetItem(page, id);
221
224 /* shared with xvac */
226 values[7] = PointerGetDatum(&tuphdr->t_ctid);
227 values[8] = UInt32GetDatum(tuphdr->t_infomask2);
228 values[9] = UInt32GetDatum(tuphdr->t_infomask);
229 values[10] = UInt8GetDatum(tuphdr->t_hoff);
230
231 /* Copy raw tuple data into bytea attribute */
232 tuple_data_len = lp_len - tuphdr->t_hoff;
233 tuple_data_bytea = (bytea *) palloc(tuple_data_len + VARHDRSZ);
234 SET_VARSIZE(tuple_data_bytea, tuple_data_len + VARHDRSZ);
235 memcpy(VARDATA(tuple_data_bytea), (char *) tuphdr + tuphdr->t_hoff,
236 tuple_data_len);
237 values[13] = PointerGetDatum(tuple_data_bytea);
238
239 /*
240 * We already checked that the item is completely within the raw
241 * page passed to us, with the length given in the line pointer.
242 * Let's check that t_hoff doesn't point over lp_len, before using
243 * it to access t_bits and oid.
244 */
245 if (tuphdr->t_hoff >= SizeofHeapTupleHeader &&
246 tuphdr->t_hoff <= lp_len &&
247 tuphdr->t_hoff == MAXALIGN(tuphdr->t_hoff))
248 {
249 if (tuphdr->t_infomask & HEAP_HASNULL)
250 {
251 int bits_len;
252
253 bits_len =
255 values[11] = CStringGetTextDatum(bits_to_text(tuphdr->t_bits, bits_len));
256 }
257 else
258 nulls[11] = true;
259
260 if (tuphdr->t_infomask & HEAP_HASOID_OLD)
261 values[12] = HeapTupleHeaderGetOidOld(tuphdr);
262 else
263 nulls[12] = true;
264 }
265 else
266 {
267 nulls[11] = true;
268 nulls[12] = true;
269 }
270 }
271 else
272 {
273 /*
274 * The line pointer is not used, or it's invalid. Set the rest of
275 * the fields to NULL
276 */
277 int i;
278
279 for (i = 4; i <= 13; i++)
280 nulls[i] = true;
281 }
282
283 /* Build and return the result tuple. */
284 resultTuple = heap_form_tuple(inter_call_data->tupd, values, nulls);
285 result = HeapTupleGetDatum(resultTuple);
286
287 inter_call_data->offset++;
288
289 SRF_RETURN_NEXT(fctx, result);
290 }
291 else
292 SRF_RETURN_DONE(fctx);
293}
294
295/*
296 * tuple_data_split_internal
297 *
298 * Split raw tuple data taken directly from a page into an array of bytea
299 * elements. This routine does a lookup on NULL values and creates array
300 * elements accordingly. This is a reimplementation of nocachegetattr()
301 * in heaptuple.c simplified for educational purposes.
302 */
303static Datum
304tuple_data_split_internal(Oid relid, char *tupdata,
305 uint16 tupdata_len, uint16 t_infomask,
306 uint16 t_infomask2, bits8 *t_bits,
307 bool do_detoast)
308{
309 ArrayBuildState *raw_attrs;
310 int nattrs;
311 int i;
312 int off = 0;
313 Relation rel;
314 TupleDesc tupdesc;
315
316 /* Get tuple descriptor from relation OID */
317 rel = relation_open(relid, AccessShareLock);
318 tupdesc = RelationGetDescr(rel);
319
320 raw_attrs = initArrayResult(BYTEAOID, CurrentMemoryContext, false);
321 nattrs = tupdesc->natts;
322
323 /*
324 * Sequences always use heap AM, but they don't show that in the catalogs.
325 */
326 if (rel->rd_rel->relkind != RELKIND_SEQUENCE &&
327 rel->rd_rel->relam != HEAP_TABLE_AM_OID)
328 ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
329 errmsg("only heap AM is supported")));
330
331 if (nattrs < (t_infomask2 & HEAP_NATTS_MASK))
334 errmsg("number of attributes in tuple header is greater than number of attributes in tuple descriptor")));
335
336 for (i = 0; i < nattrs; i++)
337 {
338 CompactAttribute *attr;
339 bool is_null;
340 bytea *attr_data = NULL;
341
342 attr = TupleDescCompactAttr(tupdesc, i);
343
344 /*
345 * Tuple header can specify fewer attributes than tuple descriptor as
346 * ALTER TABLE ADD COLUMN without DEFAULT keyword does not actually
347 * change tuples in pages, so attributes with numbers greater than
348 * (t_infomask2 & HEAP_NATTS_MASK) should be treated as NULL.
349 */
350 if (i >= (t_infomask2 & HEAP_NATTS_MASK))
351 is_null = true;
352 else
353 is_null = (t_infomask & HEAP_HASNULL) && att_isnull(i, t_bits);
354
355 if (!is_null)
356 {
357 int len;
358
359 if (attr->attlen == -1)
360 {
361 off = att_pointer_alignby(off, attr->attalignby, -1,
362 tupdata + off);
363
364 /*
365 * As VARSIZE_ANY throws an exception if it can't properly
366 * detect the type of external storage in macros VARTAG_SIZE,
367 * this check is repeated to have a nicer error handling.
368 */
369 if (VARATT_IS_EXTERNAL(tupdata + off) &&
370 !VARATT_IS_EXTERNAL_ONDISK(tupdata + off) &&
371 !VARATT_IS_EXTERNAL_INDIRECT(tupdata + off))
374 errmsg("first byte of varlena attribute is incorrect for attribute %d", i)));
375
376 len = VARSIZE_ANY(tupdata + off);
377 }
378 else
379 {
380 off = att_nominal_alignby(off, attr->attalignby);
381 len = attr->attlen;
382 }
383
384 if (tupdata_len < off + len)
387 errmsg("unexpected end of tuple data")));
388
389 if (attr->attlen == -1 && do_detoast)
390 attr_data = pg_detoast_datum_copy((struct varlena *) (tupdata + off));
391 else
392 {
393 attr_data = (bytea *) palloc(len + VARHDRSZ);
394 SET_VARSIZE(attr_data, len + VARHDRSZ);
395 memcpy(VARDATA(attr_data), tupdata + off, len);
396 }
397
398 off = att_addlength_pointer(off, attr->attlen,
399 tupdata + off);
400 }
401
402 raw_attrs = accumArrayResult(raw_attrs, PointerGetDatum(attr_data),
403 is_null, BYTEAOID, CurrentMemoryContext);
404 if (attr_data)
405 pfree(attr_data);
406 }
407
408 if (tupdata_len != off)
411 errmsg("end of tuple reached without looking at all its data")));
412
414
415 return makeArrayResult(raw_attrs, CurrentMemoryContext);
416}
417
418/*
419 * tuple_data_split
420 *
421 * Split raw tuple data taken directly from page into distinct elements
422 * taking into account null values.
423 */
425
426Datum
428{
429 Oid relid;
430 bytea *raw_data;
431 uint16 t_infomask;
432 uint16 t_infomask2;
433 char *t_bits_str;
434 bool do_detoast = false;
435 bits8 *t_bits = NULL;
436 Datum res;
437
438 relid = PG_GETARG_OID(0);
439 raw_data = PG_ARGISNULL(1) ? NULL : PG_GETARG_BYTEA_P(1);
440 t_infomask = PG_GETARG_INT16(2);
441 t_infomask2 = PG_GETARG_INT16(3);
442 t_bits_str = PG_ARGISNULL(4) ? NULL :
444
445 if (PG_NARGS() >= 6)
446 do_detoast = PG_GETARG_BOOL(5);
447
448 if (!superuser())
450 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
451 errmsg("must be superuser to use raw page functions")));
452
453 if (!raw_data)
455
456 /*
457 * Convert t_bits string back to the bits8 array as represented in the
458 * tuple header.
459 */
460 if (t_infomask & HEAP_HASNULL)
461 {
462 size_t bits_str_len;
463 size_t bits_len;
464
465 bits_len = BITMAPLEN(t_infomask2 & HEAP_NATTS_MASK) * BITS_PER_BYTE;
466 if (!t_bits_str)
469 errmsg("t_bits string must not be NULL")));
470
471 bits_str_len = strlen(t_bits_str);
472 if (bits_len != bits_str_len)
475 errmsg("unexpected length of t_bits string: %zu, expected %zu",
476 bits_str_len, bits_len)));
477
478 /* do the conversion */
479 t_bits = text_to_bits(t_bits_str, bits_str_len);
480 }
481 else
482 {
483 if (t_bits_str)
486 errmsg("t_bits string is expected to be NULL, but instead it is %zu bytes long",
487 strlen(t_bits_str))));
488 }
489
490 /* Split tuple data */
491 res = tuple_data_split_internal(relid, (char *) raw_data + VARHDRSZ,
492 VARSIZE(raw_data) - VARHDRSZ,
493 t_infomask, t_infomask2, t_bits,
494 do_detoast);
495
496 if (t_bits)
497 pfree(t_bits);
498
500}
501
502/*
503 * heap_tuple_infomask_flags
504 *
505 * Decode into a human-readable format t_infomask and t_infomask2 associated
506 * to a tuple. All the flags are described in access/htup_details.h.
507 */
509
510Datum
512{
513#define HEAP_TUPLE_INFOMASK_COLS 2
515 bool nulls[HEAP_TUPLE_INFOMASK_COLS] = {0};
516 uint16 t_infomask = PG_GETARG_INT16(0);
517 uint16 t_infomask2 = PG_GETARG_INT16(1);
518 int cnt = 0;
519 ArrayType *a;
520 int bitcnt;
521 Datum *flags;
522 TupleDesc tupdesc;
523 HeapTuple tuple;
524
525 if (!superuser())
527 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
528 errmsg("must be superuser to use raw page functions")));
529
530 /* Build a tuple descriptor for our result type */
531 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
532 elog(ERROR, "return type must be a row type");
533
534 bitcnt = pg_popcount((const char *) &t_infomask, sizeof(uint16)) +
535 pg_popcount((const char *) &t_infomask2, sizeof(uint16));
536
537 /* If no flags, return a set of empty arrays */
538 if (bitcnt <= 0)
539 {
542 tuple = heap_form_tuple(tupdesc, values, nulls);
544 }
545
546 /* build set of raw flags */
547 flags = (Datum *) palloc0(sizeof(Datum) * bitcnt);
548
549 /* decode t_infomask */
550 if ((t_infomask & HEAP_HASNULL) != 0)
551 flags[cnt++] = CStringGetTextDatum("HEAP_HASNULL");
552 if ((t_infomask & HEAP_HASVARWIDTH) != 0)
553 flags[cnt++] = CStringGetTextDatum("HEAP_HASVARWIDTH");
554 if ((t_infomask & HEAP_HASEXTERNAL) != 0)
555 flags[cnt++] = CStringGetTextDatum("HEAP_HASEXTERNAL");
556 if ((t_infomask & HEAP_HASOID_OLD) != 0)
557 flags[cnt++] = CStringGetTextDatum("HEAP_HASOID_OLD");
558 if ((t_infomask & HEAP_XMAX_KEYSHR_LOCK) != 0)
559 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_KEYSHR_LOCK");
560 if ((t_infomask & HEAP_COMBOCID) != 0)
561 flags[cnt++] = CStringGetTextDatum("HEAP_COMBOCID");
562 if ((t_infomask & HEAP_XMAX_EXCL_LOCK) != 0)
563 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_EXCL_LOCK");
564 if ((t_infomask & HEAP_XMAX_LOCK_ONLY) != 0)
565 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_LOCK_ONLY");
566 if ((t_infomask & HEAP_XMIN_COMMITTED) != 0)
567 flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_COMMITTED");
568 if ((t_infomask & HEAP_XMIN_INVALID) != 0)
569 flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_INVALID");
570 if ((t_infomask & HEAP_XMAX_COMMITTED) != 0)
571 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_COMMITTED");
572 if ((t_infomask & HEAP_XMAX_INVALID) != 0)
573 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_INVALID");
574 if ((t_infomask & HEAP_XMAX_IS_MULTI) != 0)
575 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_IS_MULTI");
576 if ((t_infomask & HEAP_UPDATED) != 0)
577 flags[cnt++] = CStringGetTextDatum("HEAP_UPDATED");
578 if ((t_infomask & HEAP_MOVED_OFF) != 0)
579 flags[cnt++] = CStringGetTextDatum("HEAP_MOVED_OFF");
580 if ((t_infomask & HEAP_MOVED_IN) != 0)
581 flags[cnt++] = CStringGetTextDatum("HEAP_MOVED_IN");
582
583 /* decode t_infomask2 */
584 if ((t_infomask2 & HEAP_KEYS_UPDATED) != 0)
585 flags[cnt++] = CStringGetTextDatum("HEAP_KEYS_UPDATED");
586 if ((t_infomask2 & HEAP_HOT_UPDATED) != 0)
587 flags[cnt++] = CStringGetTextDatum("HEAP_HOT_UPDATED");
588 if ((t_infomask2 & HEAP_ONLY_TUPLE) != 0)
589 flags[cnt++] = CStringGetTextDatum("HEAP_ONLY_TUPLE");
590
591 /* build value */
592 Assert(cnt <= bitcnt);
593 a = construct_array_builtin(flags, cnt, TEXTOID);
595
596 /*
597 * Build set of combined flags. Use the same array as previously, this
598 * keeps the code simple.
599 */
600 cnt = 0;
601 MemSet(flags, 0, sizeof(Datum) * bitcnt);
602
603 /* decode combined masks of t_infomask */
604 if ((t_infomask & HEAP_XMAX_SHR_LOCK) == HEAP_XMAX_SHR_LOCK)
605 flags[cnt++] = CStringGetTextDatum("HEAP_XMAX_SHR_LOCK");
606 if ((t_infomask & HEAP_XMIN_FROZEN) == HEAP_XMIN_FROZEN)
607 flags[cnt++] = CStringGetTextDatum("HEAP_XMIN_FROZEN");
608 if ((t_infomask & HEAP_MOVED) == HEAP_MOVED)
609 flags[cnt++] = CStringGetTextDatum("HEAP_MOVED");
610
611 /* Build an empty array if there are no combined flags */
612 if (cnt == 0)
613 a = construct_empty_array(TEXTOID);
614 else
615 a = construct_array_builtin(flags, cnt, TEXTOID);
616 pfree(flags);
618
619 /* Returns the record as Datum */
620 tuple = heap_form_tuple(tupdesc, values, nulls);
622}
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5350
ArrayType * construct_empty_array(Oid elmtype)
Definition: arrayfuncs.c:3580
ArrayBuildState * initArrayResult(Oid element_type, MemoryContext rcontext, bool subcontext)
Definition: arrayfuncs.c:5293
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3381
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5420
static Datum values[MAXATTR]
Definition: bootstrap.c:151
static Item PageGetItem(const PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:354
#define SizeOfPageHeaderData
Definition: bufpage.h:217
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:244
PageData * Page
Definition: bufpage.h:82
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition: bufpage.h:372
#define CStringGetTextDatum(s)
Definition: builtins.h:97
#define MAXALIGN(LEN)
Definition: c.h:768
#define VARHDRSZ
Definition: c.h:649
#define Assert(condition)
Definition: c.h:815
uint8 bits8
Definition: c.h:495
uint16_t uint16
Definition: c.h:487
#define MemSet(start, val, len)
Definition: c.h:977
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
struct varlena * pg_detoast_datum_copy(struct varlena *datum)
Definition: fmgr.c:1841
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define PG_ARGISNULL(n)
Definition: fmgr.h:209
#define PG_NARGS()
Definition: fmgr.h:203
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:274
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
#define PG_GETARG_BYTEA_P(n)
Definition: fmgr.h:335
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_GETARG_INT16(n)
Definition: fmgr.h:271
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:276
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:304
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:308
@ TYPEFUNC_COMPOSITE
Definition: funcapi.h:149
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:310
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:306
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition: funcapi.h:230
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:328
const char * str
#define HEAP_TUPLE_INFOMASK_COLS
PG_FUNCTION_INFO_V1(heap_page_items)
Datum heap_page_items(PG_FUNCTION_ARGS)
Definition: heapfuncs.c:130
struct heap_page_items_state heap_page_items_state
static Datum tuple_data_split_internal(Oid relid, char *tupdata, uint16 tupdata_len, uint16 t_infomask, uint16 t_infomask2, bits8 *t_bits, bool do_detoast)
Definition: heapfuncs.c:304
static bits8 * text_to_bits(char *str, int len)
Definition: heapfuncs.c:85
static char * bits_to_text(bits8 *bits, int len)
Definition: heapfuncs.c:62
Datum heap_tuple_infomask_flags(PG_FUNCTION_ARGS)
Definition: heapfuncs.c:511
static Oid HeapTupleHeaderGetOidOld(const HeapTupleHeaderData *tup)
Definition: heapfuncs.c:46
Datum tuple_data_split(PG_FUNCTION_ARGS)
Definition: heapfuncs.c:427
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1117
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define HEAP_HASVARWIDTH
Definition: htup_details.h:191
#define HEAP_MOVED_OFF
Definition: htup_details.h:211
#define HEAP_XMAX_SHR_LOCK
Definition: htup_details.h:200
#define HEAP_XMIN_FROZEN
Definition: htup_details.h:206
#define HEAP_XMIN_COMMITTED
Definition: htup_details.h:204
#define HeapTupleHeaderGetNatts(tup)
Definition: htup_details.h:577
#define HEAP_NATTS_MASK
Definition: htup_details.h:287
#define SizeofHeapTupleHeader
Definition: htup_details.h:185
#define HEAP_KEYS_UPDATED
Definition: htup_details.h:289
#define MinHeapTupleSize
Definition: htup_details.h:611
#define HEAP_HOT_UPDATED
Definition: htup_details.h:290
#define HEAP_HASNULL
Definition: htup_details.h:190
static int BITMAPLEN(int NATTS)
Definition: htup_details.h:594
#define HEAP_XMAX_LOCK_ONLY
Definition: htup_details.h:197
#define HEAP_MOVED_IN
Definition: htup_details.h:212
static CommandId HeapTupleHeaderGetRawCommandId(const HeapTupleHeaderData *tup)
Definition: htup_details.h:415
#define HEAP_HASOID_OLD
Definition: htup_details.h:193
static TransactionId HeapTupleHeaderGetRawXmax(const HeapTupleHeaderData *tup)
Definition: htup_details.h:377
#define HEAP_MOVED
Definition: htup_details.h:213
#define HEAP_XMAX_IS_MULTI
Definition: htup_details.h:209
#define HEAP_XMAX_COMMITTED
Definition: htup_details.h:207
#define HEAP_COMBOCID
Definition: htup_details.h:195
#define HEAP_XMIN_INVALID
Definition: htup_details.h:205
#define HEAP_HASEXTERNAL
Definition: htup_details.h:192
#define HEAP_XMAX_EXCL_LOCK
Definition: htup_details.h:196
#define HEAP_XMAX_INVALID
Definition: htup_details.h:208
static TransactionId HeapTupleHeaderGetRawXmin(const HeapTupleHeaderData *tup)
Definition: htup_details.h:318
#define HEAP_UPDATED
Definition: htup_details.h:210
#define HEAP_XMAX_KEYSHR_LOCK
Definition: htup_details.h:194
#define HEAP_ONLY_TUPLE
Definition: htup_details.h:291
int a
Definition: isn.c:68
int i
Definition: isn.c:72
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
#define ItemIdGetOffset(itemId)
Definition: itemid.h:65
#define ItemIdGetFlags(itemId)
Definition: itemid.h:71
#define ItemIdHasStorage(itemId)
Definition: itemid.h:120
#define AccessShareLock
Definition: lockdefs.h:36
int pg_mblen(const char *mbstr)
Definition: mbutils.c:1023
void pfree(void *pointer)
Definition: mcxt.c:1521
void * palloc0(Size size)
Definition: mcxt.c:1347
void * palloc(Size size)
Definition: mcxt.c:1317
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
#define FirstOffsetNumber
Definition: off.h:27
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:41
static uint64 pg_popcount(const char *buf, int bytes)
Definition: pg_bitutils.h:337
#define BITS_PER_BYTE
const void size_t len
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:327
uintptr_t Datum
Definition: postgres.h:69
static Datum UInt16GetDatum(uint16 X)
Definition: postgres.h:197
static Datum UInt8GetDatum(uint8 X)
Definition: postgres.h:157
static Datum UInt32GetDatum(uint32 X)
Definition: postgres.h:237
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
#define RelationGetDescr(relation)
Definition: rel.h:538
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47
uint8 attalignby
Definition: tupdesc.h:80
int16 attlen
Definition: tupdesc.h:71
void * user_fctx
Definition: funcapi.h:82
uint64 max_calls
Definition: funcapi.h:74
uint64 call_cntr
Definition: funcapi.h:65
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
ItemPointerData t_ctid
Definition: htup_details.h:161
bits8 t_bits[FLEXIBLE_ARRAY_MEMBER]
Definition: htup_details.h:178
Form_pg_class rd_rel
Definition: rel.h:111
Definition: c.h:644
bool superuser(void)
Definition: superuser.c:46
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:169
#define att_nominal_alignby(cur_offset, attalignby)
Definition: tupmacs.h:165
static bool att_isnull(int ATT, const bits8 *BITS)
Definition: tupmacs.h:26
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:185
#define att_pointer_alignby(cur_offset, attalignby, attlen, attptr)
Definition: tupmacs.h:129
#define VARATT_IS_EXTERNAL_ONDISK(PTR)
Definition: varatt.h:290
#define VARATT_IS_EXTERNAL_INDIRECT(PTR)
Definition: varatt.h:292
#define VARSIZE_ANY(PTR)
Definition: varatt.h:311
#define VARDATA(PTR)
Definition: varatt.h:278
#define SET_VARSIZE(PTR, len)
Definition: varatt.h:305
#define VARSIZE(PTR)
Definition: varatt.h:279
#define VARATT_IS_EXTERNAL(PTR)
Definition: varatt.h:289
char * text_to_cstring(const text *t)
Definition: varlena.c:217