LCOV - code coverage report
Current view: top level - src/backend/access/common - tupconvert.c (source / functions) Hit Total Coverage
Test: PostgreSQL 16devel Lines: 88 88 100.0 %
Date: 2022-08-17 03:10:30 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * tupconvert.c
       4             :  *    Tuple conversion support.
       5             :  *
       6             :  * These functions provide conversion between rowtypes that are logically
       7             :  * equivalent but might have columns in a different order or different sets of
       8             :  * dropped columns.
       9             :  *
      10             :  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
      11             :  * Portions Copyright (c) 1994, Regents of the University of California
      12             :  *
      13             :  *
      14             :  * IDENTIFICATION
      15             :  *    src/backend/access/common/tupconvert.c
      16             :  *
      17             :  *-------------------------------------------------------------------------
      18             :  */
      19             : #include "postgres.h"
      20             : 
      21             : #include "access/tupconvert.h"
      22             : #include "executor/tuptable.h"
      23             : 
      24             : 
      25             : /*
      26             :  * The conversion setup routines have the following common API:
      27             :  *
      28             :  * The setup routine checks using attmap.c whether the given source and
      29             :  * destination tuple descriptors are logically compatible.  If not, it throws
      30             :  * an error.  If so, it returns NULL if they are physically compatible (ie, no
      31             :  * conversion is needed), else a TupleConversionMap that can be used by
      32             :  * execute_attr_map_tuple or execute_attr_map_slot to perform the conversion.
      33             :  *
      34             :  * The TupleConversionMap, if needed, is palloc'd in the caller's memory
      35             :  * context.  Also, the given tuple descriptors are referenced by the map,
      36             :  * so they must survive as long as the map is needed.
      37             :  *
      38             :  * The caller must supply a suitable primary error message to be used if
      39             :  * a compatibility error is thrown.  Recommended coding practice is to use
      40             :  * gettext_noop() on this string, so that it is translatable but won't
      41             :  * actually be translated unless the error gets thrown.
      42             :  *
      43             :  *
      44             :  * Implementation notes:
      45             :  *
      46             :  * The key component of a TupleConversionMap is an attrMap[] array with
      47             :  * one entry per output column.  This entry contains the 1-based index of
      48             :  * the corresponding input column, or zero to force a NULL value (for
      49             :  * a dropped output column).  The TupleConversionMap also contains workspace
      50             :  * arrays.
      51             :  */
      52             : 
      53             : 
      54             : /*
      55             :  * Set up for tuple conversion, matching input and output columns by
      56             :  * position.  (Dropped columns are ignored in both input and output.)
      57             :  */
      58             : TupleConversionMap *
      59        9494 : convert_tuples_by_position(TupleDesc indesc,
      60             :                            TupleDesc outdesc,
      61             :                            const char *msg)
      62             : {
      63             :     TupleConversionMap *map;
      64             :     int         n;
      65             :     AttrMap    *attrMap;
      66             : 
      67             :     /* Verify compatibility and prepare attribute-number map */
      68        9494 :     attrMap = build_attrmap_by_position(indesc, outdesc, msg);
      69             : 
      70        9462 :     if (attrMap == NULL)
      71             :     {
      72             :         /* runtime conversion is not needed */
      73        9368 :         return NULL;
      74             :     }
      75             : 
      76             :     /* Prepare the map structure */
      77          94 :     map = (TupleConversionMap *) palloc(sizeof(TupleConversionMap));
      78          94 :     map->indesc = indesc;
      79          94 :     map->outdesc = outdesc;
      80          94 :     map->attrMap = attrMap;
      81             :     /* preallocate workspace for Datum arrays */
      82          94 :     n = outdesc->natts + 1;      /* +1 for NULL */
      83          94 :     map->outvalues = (Datum *) palloc(n * sizeof(Datum));
      84          94 :     map->outisnull = (bool *) palloc(n * sizeof(bool));
      85          94 :     n = indesc->natts + 1;       /* +1 for NULL */
      86          94 :     map->invalues = (Datum *) palloc(n * sizeof(Datum));
      87          94 :     map->inisnull = (bool *) palloc(n * sizeof(bool));
      88          94 :     map->invalues[0] = (Datum) 0;    /* set up the NULL entry */
      89          94 :     map->inisnull[0] = true;
      90             : 
      91          94 :     return map;
      92             : }
      93             : 
      94             : /*
      95             :  * Set up for tuple conversion, matching input and output columns by name.
      96             :  * (Dropped columns are ignored in both input and output.)  This is intended
      97             :  * for use when the rowtypes are related by inheritance, so we expect an exact
      98             :  * match of both type and typmod.  The error messages will be a bit unhelpful
      99             :  * unless both rowtypes are named composite types.
     100             :  */
     101             : TupleConversionMap *
     102        8702 : convert_tuples_by_name(TupleDesc indesc,
     103             :                        TupleDesc outdesc)
     104             : {
     105             :     TupleConversionMap *map;
     106             :     AttrMap    *attrMap;
     107        8702 :     int         n = outdesc->natts;
     108             : 
     109             :     /* Verify compatibility and prepare attribute-number map */
     110        8702 :     attrMap = build_attrmap_by_name_if_req(indesc, outdesc);
     111             : 
     112        8702 :     if (attrMap == NULL)
     113             :     {
     114             :         /* runtime conversion is not needed */
     115        6782 :         return NULL;
     116             :     }
     117             : 
     118             :     /* Prepare the map structure */
     119        1920 :     map = (TupleConversionMap *) palloc(sizeof(TupleConversionMap));
     120        1920 :     map->indesc = indesc;
     121        1920 :     map->outdesc = outdesc;
     122        1920 :     map->attrMap = attrMap;
     123             :     /* preallocate workspace for Datum arrays */
     124        1920 :     map->outvalues = (Datum *) palloc(n * sizeof(Datum));
     125        1920 :     map->outisnull = (bool *) palloc(n * sizeof(bool));
     126        1920 :     n = indesc->natts + 1;       /* +1 for NULL */
     127        1920 :     map->invalues = (Datum *) palloc(n * sizeof(Datum));
     128        1920 :     map->inisnull = (bool *) palloc(n * sizeof(bool));
     129        1920 :     map->invalues[0] = (Datum) 0;    /* set up the NULL entry */
     130        1920 :     map->inisnull[0] = true;
     131             : 
     132        1920 :     return map;
     133             : }
     134             : 
     135             : /*
     136             :  * Perform conversion of a tuple according to the map.
     137             :  */
     138             : HeapTuple
     139      106734 : execute_attr_map_tuple(HeapTuple tuple, TupleConversionMap *map)
     140             : {
     141      106734 :     AttrMap    *attrMap = map->attrMap;
     142      106734 :     Datum      *invalues = map->invalues;
     143      106734 :     bool       *inisnull = map->inisnull;
     144      106734 :     Datum      *outvalues = map->outvalues;
     145      106734 :     bool       *outisnull = map->outisnull;
     146             :     int         i;
     147             : 
     148             :     /*
     149             :      * Extract all the values of the old tuple, offsetting the arrays so that
     150             :      * invalues[0] is left NULL and invalues[1] is the first source attribute;
     151             :      * this exactly matches the numbering convention in attrMap.
     152             :      */
     153      106734 :     heap_deform_tuple(tuple, map->indesc, invalues + 1, inisnull + 1);
     154             : 
     155             :     /*
     156             :      * Transpose into proper fields of the new tuple.
     157             :      */
     158             :     Assert(attrMap->maplen == map->outdesc->natts);
     159      424652 :     for (i = 0; i < attrMap->maplen; i++)
     160             :     {
     161      317918 :         int         j = attrMap->attnums[i];
     162             : 
     163      317918 :         outvalues[i] = invalues[j];
     164      317918 :         outisnull[i] = inisnull[j];
     165             :     }
     166             : 
     167             :     /*
     168             :      * Now form the new tuple.
     169             :      */
     170      106734 :     return heap_form_tuple(map->outdesc, outvalues, outisnull);
     171             : }
     172             : 
     173             : /*
     174             :  * Perform conversion of a tuple slot according to the map.
     175             :  */
     176             : TupleTableSlot *
     177      143342 : execute_attr_map_slot(AttrMap *attrMap,
     178             :                       TupleTableSlot *in_slot,
     179             :                       TupleTableSlot *out_slot)
     180             : {
     181             :     Datum      *invalues;
     182             :     bool       *inisnull;
     183             :     Datum      *outvalues;
     184             :     bool       *outisnull;
     185             :     int         outnatts;
     186             :     int         i;
     187             : 
     188             :     /* Sanity checks */
     189             :     Assert(in_slot->tts_tupleDescriptor != NULL &&
     190             :            out_slot->tts_tupleDescriptor != NULL);
     191             :     Assert(in_slot->tts_values != NULL && out_slot->tts_values != NULL);
     192             : 
     193      143342 :     outnatts = out_slot->tts_tupleDescriptor->natts;
     194             : 
     195             :     /* Extract all the values of the in slot. */
     196      143342 :     slot_getallattrs(in_slot);
     197             : 
     198             :     /* Before doing the mapping, clear any old contents from the out slot */
     199      143342 :     ExecClearTuple(out_slot);
     200             : 
     201      143342 :     invalues = in_slot->tts_values;
     202      143342 :     inisnull = in_slot->tts_isnull;
     203      143342 :     outvalues = out_slot->tts_values;
     204      143342 :     outisnull = out_slot->tts_isnull;
     205             : 
     206             :     /* Transpose into proper fields of the out slot. */
     207      578030 :     for (i = 0; i < outnatts; i++)
     208             :     {
     209      434688 :         int         j = attrMap->attnums[i] - 1;
     210             : 
     211             :         /* attrMap->attnums[i] == 0 means it's a NULL datum. */
     212      434688 :         if (j == -1)
     213             :         {
     214        2460 :             outvalues[i] = (Datum) 0;
     215        2460 :             outisnull[i] = true;
     216             :         }
     217             :         else
     218             :         {
     219      432228 :             outvalues[i] = invalues[j];
     220      432228 :             outisnull[i] = inisnull[j];
     221             :         }
     222             :     }
     223             : 
     224      143342 :     ExecStoreVirtualTuple(out_slot);
     225             : 
     226      143342 :     return out_slot;
     227             : }
     228             : 
     229             : /*
     230             :  * Perform conversion of bitmap of columns according to the map.
     231             :  *
     232             :  * The input and output bitmaps are offset by
     233             :  * FirstLowInvalidHeapAttributeNumber to accommodate system cols, like the
     234             :  * column-bitmaps in RangeTblEntry.
     235             :  */
     236             : Bitmapset *
     237         116 : execute_attr_map_cols(AttrMap *attrMap, Bitmapset *in_cols)
     238             : {
     239             :     Bitmapset  *out_cols;
     240             :     int         out_attnum;
     241             : 
     242             :     /* fast path for the common trivial case */
     243         116 :     if (in_cols == NULL)
     244          58 :         return NULL;
     245             : 
     246             :     /*
     247             :      * For each output column, check which input column it corresponds to.
     248             :      */
     249          58 :     out_cols = NULL;
     250             : 
     251          58 :     for (out_attnum = FirstLowInvalidHeapAttributeNumber;
     252         688 :          out_attnum <= attrMap->maplen;
     253         630 :          out_attnum++)
     254             :     {
     255             :         int         in_attnum;
     256             : 
     257         630 :         if (out_attnum < 0)
     258             :         {
     259             :             /* System column. No mapping. */
     260         406 :             in_attnum = out_attnum;
     261             :         }
     262         224 :         else if (out_attnum == 0)
     263          58 :             continue;
     264             :         else
     265             :         {
     266             :             /* normal user column */
     267         166 :             in_attnum = attrMap->attnums[out_attnum - 1];
     268             : 
     269         166 :             if (in_attnum == 0)
     270          22 :                 continue;
     271             :         }
     272             : 
     273         550 :         if (bms_is_member(in_attnum - FirstLowInvalidHeapAttributeNumber, in_cols))
     274          86 :             out_cols = bms_add_member(out_cols, out_attnum - FirstLowInvalidHeapAttributeNumber);
     275             :     }
     276             : 
     277          58 :     return out_cols;
     278             : }
     279             : 
     280             : /*
     281             :  * Free a TupleConversionMap structure.
     282             :  */
     283             : void
     284         134 : free_conversion_map(TupleConversionMap *map)
     285             : {
     286             :     /* indesc and outdesc are not ours to free */
     287         134 :     free_attrmap(map->attrMap);
     288         134 :     pfree(map->invalues);
     289         134 :     pfree(map->inisnull);
     290         134 :     pfree(map->outvalues);
     291         134 :     pfree(map->outisnull);
     292         134 :     pfree(map);
     293         134 : }

Generated by: LCOV version 1.14