LCOV - code coverage report
Current view: top level - src/backend/access/common - attmap.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 91 94 96.8 %
Date: 2025-04-01 14:15:22 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * attmap.c
       4             :  *    Attribute mapping support.
       5             :  *
       6             :  * This file provides utility routines to build and manage attribute
       7             :  * mappings by comparing input and output TupleDescs.  Such mappings
       8             :  * are typically used by DDL operating on inheritance and partition trees
       9             :  * to do a conversion between rowtypes logically equivalent but with
      10             :  * columns in a different order, taking into account dropped columns.
      11             :  * They are also used by the tuple conversion routines in tupconvert.c.
      12             :  *
      13             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
      14             :  * Portions Copyright (c) 1994, Regents of the University of California
      15             :  *
      16             :  *
      17             :  * IDENTIFICATION
      18             :  *    src/backend/access/common/attmap.c
      19             :  *
      20             :  *-------------------------------------------------------------------------
      21             :  */
      22             : 
      23             : #include "postgres.h"
      24             : 
      25             : #include "access/attmap.h"
      26             : #include "utils/builtins.h"
      27             : 
      28             : 
      29             : static bool check_attrmap_match(TupleDesc indesc,
      30             :                                 TupleDesc outdesc,
      31             :                                 AttrMap *attrMap);
      32             : 
      33             : /*
      34             :  * make_attrmap
      35             :  *
      36             :  * Utility routine to allocate an attribute map in the current memory
      37             :  * context.
      38             :  */
      39             : AttrMap *
      40       59846 : make_attrmap(int maplen)
      41             : {
      42             :     AttrMap    *res;
      43             : 
      44       59846 :     res = (AttrMap *) palloc0(sizeof(AttrMap));
      45       59846 :     res->maplen = maplen;
      46       59846 :     res->attnums = (AttrNumber *) palloc0(sizeof(AttrNumber) * maplen);
      47       59846 :     return res;
      48             : }
      49             : 
      50             : /*
      51             :  * free_attrmap
      52             :  *
      53             :  * Utility routine to release an attribute map.
      54             :  */
      55             : void
      56       33674 : free_attrmap(AttrMap *map)
      57             : {
      58       33674 :     pfree(map->attnums);
      59       33674 :     pfree(map);
      60       33674 : }
      61             : 
      62             : /*
      63             :  * build_attrmap_by_position
      64             :  *
      65             :  * Return a palloc'd bare attribute map for tuple conversion, matching input
      66             :  * and output columns by position.  Dropped columns are ignored in both input
      67             :  * and output, marked as 0.  This is normally a subroutine for
      68             :  * convert_tuples_by_position in tupconvert.c, but it can be used standalone.
      69             :  *
      70             :  * Note: the errdetail messages speak of indesc as the "returned" rowtype,
      71             :  * outdesc as the "expected" rowtype.  This is okay for current uses but
      72             :  * might need generalization in future.
      73             :  */
      74             : AttrMap *
      75        9540 : build_attrmap_by_position(TupleDesc indesc,
      76             :                           TupleDesc outdesc,
      77             :                           const char *msg)
      78             : {
      79             :     AttrMap    *attrMap;
      80             :     int         nincols;
      81             :     int         noutcols;
      82             :     int         n;
      83             :     int         i;
      84             :     int         j;
      85             :     bool        same;
      86             : 
      87             :     /*
      88             :      * The length is computed as the number of attributes of the expected
      89             :      * rowtype as it includes dropped attributes in its count.
      90             :      */
      91        9540 :     n = outdesc->natts;
      92        9540 :     attrMap = make_attrmap(n);
      93             : 
      94        9540 :     j = 0;                      /* j is next physical input attribute */
      95        9540 :     nincols = noutcols = 0;     /* these count non-dropped attributes */
      96        9540 :     same = true;
      97       34558 :     for (i = 0; i < n; i++)
      98             :     {
      99       25038 :         Form_pg_attribute outatt = TupleDescAttr(outdesc, i);
     100             : 
     101       25038 :         if (outatt->attisdropped)
     102         152 :             continue;           /* attrMap->attnums[i] is already 0 */
     103       24886 :         noutcols++;
     104       24904 :         for (; j < indesc->natts; j++)
     105             :         {
     106       24896 :             Form_pg_attribute inatt = TupleDescAttr(indesc, j);
     107             : 
     108       24896 :             if (inatt->attisdropped)
     109          18 :                 continue;
     110       24878 :             nincols++;
     111             : 
     112             :             /* Found matching column, now check type */
     113       24878 :             if (outatt->atttypid != inatt->atttypid ||
     114       24858 :                 (outatt->atttypmod != inatt->atttypmod && outatt->atttypmod >= 0))
     115          20 :                 ereport(ERROR,
     116             :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
     117             :                          errmsg_internal("%s", _(msg)),
     118             :                          errdetail("Returned type %s does not match expected type %s in column \"%s\" (position %d).",
     119             :                                    format_type_with_typemod(inatt->atttypid,
     120             :                                                             inatt->atttypmod),
     121             :                                    format_type_with_typemod(outatt->atttypid,
     122             :                                                             outatt->atttypmod),
     123             :                                    NameStr(outatt->attname),
     124             :                                    noutcols)));
     125       24858 :             attrMap->attnums[i] = (AttrNumber) (j + 1);
     126       24858 :             j++;
     127       24858 :             break;
     128             :         }
     129       24866 :         if (attrMap->attnums[i] == 0)
     130           8 :             same = false;       /* we'll complain below */
     131             :     }
     132             : 
     133             :     /* Check for unused input columns */
     134        9526 :     for (; j < indesc->natts; j++)
     135             :     {
     136           6 :         if (TupleDescCompactAttr(indesc, j)->attisdropped)
     137           0 :             continue;
     138           6 :         nincols++;
     139           6 :         same = false;           /* we'll complain below */
     140             :     }
     141             : 
     142             :     /* Report column count mismatch using the non-dropped-column counts */
     143        9520 :     if (!same)
     144          14 :         ereport(ERROR,
     145             :                 (errcode(ERRCODE_DATATYPE_MISMATCH),
     146             :                  errmsg_internal("%s", _(msg)),
     147             :                  errdetail("Number of returned columns (%d) does not match "
     148             :                            "expected column count (%d).",
     149             :                            nincols, noutcols)));
     150             : 
     151             :     /* Check if the map has a one-to-one match */
     152        9506 :     if (check_attrmap_match(indesc, outdesc, attrMap))
     153             :     {
     154             :         /* Runtime conversion is not needed */
     155        9410 :         free_attrmap(attrMap);
     156        9410 :         return NULL;
     157             :     }
     158             : 
     159          96 :     return attrMap;
     160             : }
     161             : 
     162             : /*
     163             :  * build_attrmap_by_name
     164             :  *
     165             :  * Return a palloc'd bare attribute map for tuple conversion, matching input
     166             :  * and output columns by name.  (Dropped columns are ignored in both input and
     167             :  * output.)  This is normally a subroutine for convert_tuples_by_name in
     168             :  * tupconvert.c, but can be used standalone.
     169             :  *
     170             :  * If 'missing_ok' is true, a column from 'outdesc' not being present in
     171             :  * 'indesc' is not flagged as an error; AttrMap.attnums[] entry for such an
     172             :  * outdesc column will be 0 in that case.
     173             :  */
     174             : AttrMap *
     175       39006 : build_attrmap_by_name(TupleDesc indesc,
     176             :                       TupleDesc outdesc,
     177             :                       bool missing_ok)
     178             : {
     179             :     AttrMap    *attrMap;
     180             :     int         outnatts;
     181             :     int         innatts;
     182             :     int         i;
     183       39006 :     int         nextindesc = -1;
     184             : 
     185       39006 :     outnatts = outdesc->natts;
     186       39006 :     innatts = indesc->natts;
     187             : 
     188       39006 :     attrMap = make_attrmap(outnatts);
     189      132234 :     for (i = 0; i < outnatts; i++)
     190             :     {
     191       93228 :         Form_pg_attribute outatt = TupleDescAttr(outdesc, i);
     192             :         char       *attname;
     193             :         Oid         atttypid;
     194             :         int32       atttypmod;
     195             :         int         j;
     196             : 
     197       93228 :         if (outatt->attisdropped)
     198        4272 :             continue;           /* attrMap->attnums[i] is already 0 */
     199       88956 :         attname = NameStr(outatt->attname);
     200       88956 :         atttypid = outatt->atttypid;
     201       88956 :         atttypmod = outatt->atttypmod;
     202             : 
     203             :         /*
     204             :          * Now search for an attribute with the same name in the indesc. It
     205             :          * seems likely that a partitioned table will have the attributes in
     206             :          * the same order as the partition, so the search below is optimized
     207             :          * for that case.  It is possible that columns are dropped in one of
     208             :          * the relations, but not the other, so we use the 'nextindesc'
     209             :          * counter to track the starting point of the search.  If the inner
     210             :          * loop encounters dropped columns then it will have to skip over
     211             :          * them, but it should leave 'nextindesc' at the correct position for
     212             :          * the next outer loop.
     213             :          */
     214      109618 :         for (j = 0; j < innatts; j++)
     215             :         {
     216             :             Form_pg_attribute inatt;
     217             : 
     218      109394 :             nextindesc++;
     219      109394 :             if (nextindesc >= innatts)
     220        6842 :                 nextindesc = 0;
     221             : 
     222      109394 :             inatt = TupleDescAttr(indesc, nextindesc);
     223      109394 :             if (inatt->attisdropped)
     224        3682 :                 continue;
     225      105712 :             if (strcmp(attname, NameStr(inatt->attname)) == 0)
     226             :             {
     227             :                 /* Found it, check type */
     228       88732 :                 if (atttypid != inatt->atttypid || atttypmod != inatt->atttypmod)
     229           0 :                     ereport(ERROR,
     230             :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
     231             :                              errmsg("could not convert row type"),
     232             :                              errdetail("Attribute \"%s\" of type %s does not match corresponding attribute of type %s.",
     233             :                                        attname,
     234             :                                        format_type_be(outdesc->tdtypeid),
     235             :                                        format_type_be(indesc->tdtypeid))));
     236       88732 :                 attrMap->attnums[i] = inatt->attnum;
     237       88732 :                 break;
     238             :             }
     239             :         }
     240       88956 :         if (attrMap->attnums[i] == 0 && !missing_ok)
     241           0 :             ereport(ERROR,
     242             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
     243             :                      errmsg("could not convert row type"),
     244             :                      errdetail("Attribute \"%s\" of type %s does not exist in type %s.",
     245             :                                attname,
     246             :                                format_type_be(outdesc->tdtypeid),
     247             :                                format_type_be(indesc->tdtypeid))));
     248             :     }
     249       39006 :     return attrMap;
     250             : }
     251             : 
     252             : /*
     253             :  * build_attrmap_by_name_if_req
     254             :  *
     255             :  * Returns mapping created by build_attrmap_by_name, or NULL if no
     256             :  * conversion is required.  This is a convenience routine for
     257             :  * convert_tuples_by_name() in tupconvert.c and other functions, but it
     258             :  * can be used standalone.
     259             :  */
     260             : AttrMap *
     261       15488 : build_attrmap_by_name_if_req(TupleDesc indesc,
     262             :                              TupleDesc outdesc,
     263             :                              bool missing_ok)
     264             : {
     265             :     AttrMap    *attrMap;
     266             : 
     267             :     /* Verify compatibility and prepare attribute-number map */
     268       15488 :     attrMap = build_attrmap_by_name(indesc, outdesc, missing_ok);
     269             : 
     270             :     /* Check if the map has a one-to-one match */
     271       15488 :     if (check_attrmap_match(indesc, outdesc, attrMap))
     272             :     {
     273             :         /* Runtime conversion is not needed */
     274       12324 :         free_attrmap(attrMap);
     275       12324 :         return NULL;
     276             :     }
     277             : 
     278        3164 :     return attrMap;
     279             : }
     280             : 
     281             : /*
     282             :  * check_attrmap_match
     283             :  *
     284             :  * Check to see if the map is a one-to-one match, in which case we need
     285             :  * not to do a tuple conversion, and the attribute map is not necessary.
     286             :  */
     287             : static bool
     288       24994 : check_attrmap_match(TupleDesc indesc,
     289             :                     TupleDesc outdesc,
     290             :                     AttrMap *attrMap)
     291             : {
     292             :     int         i;
     293             : 
     294             :     /* no match if attribute numbers are not the same */
     295       24994 :     if (indesc->natts != outdesc->natts)
     296        1454 :         return false;
     297             : 
     298       77136 :     for (i = 0; i < attrMap->maplen; i++)
     299             :     {
     300       55402 :         CompactAttribute *inatt = TupleDescCompactAttr(indesc, i);
     301             :         CompactAttribute *outatt;
     302             : 
     303             :         /*
     304             :          * If the input column has a missing attribute, we need a conversion.
     305             :          */
     306       55402 :         if (inatt->atthasmissing)
     307          50 :             return false;
     308             : 
     309       55352 :         if (attrMap->attnums[i] == (i + 1))
     310       53536 :             continue;
     311             : 
     312        1816 :         outatt = TupleDescCompactAttr(outdesc, i);
     313             : 
     314             :         /*
     315             :          * If it's a dropped column and the corresponding input column is also
     316             :          * dropped, we don't need a conversion.  However, attlen and
     317             :          * attalignby must agree.
     318             :          */
     319        1816 :         if (attrMap->attnums[i] == 0 &&
     320          92 :             inatt->attisdropped &&
     321          60 :             inatt->attlen == outatt->attlen &&
     322          60 :             inatt->attalignby == outatt->attalignby)
     323          60 :             continue;
     324             : 
     325        1756 :         return false;
     326             :     }
     327             : 
     328       21734 :     return true;
     329             : }

Generated by: LCOV version 1.14