LCOV - code coverage report
Current view: top level - contrib/pageinspect - heapfuncs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 209 238 87.8 %
Date: 2019-11-15 22:06:47 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13