LCOV - code coverage report
Current view: top level - src/backend/access/common - attmap.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 93 96 96.9 %
Date: 2020-06-01 09:07:10 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-2020, 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 "access/htup_details.h"
      27             : #include "utils/builtins.h"
      28             : 
      29             : 
      30             : static bool check_attrmap_match(TupleDesc indesc,
      31             :                                 TupleDesc outdesc,
      32             :                                 AttrMap *attrMap);
      33             : 
      34             : /*
      35             :  * make_attrmap
      36             :  *
      37             :  * Utility routine to allocate an attribute map in the current memory
      38             :  * context.
      39             :  */
      40             : AttrMap *
      41       26974 : make_attrmap(int maplen)
      42             : {
      43             :     AttrMap    *res;
      44             : 
      45       26974 :     res = (AttrMap *) palloc0(sizeof(AttrMap));
      46       26974 :     res->maplen = maplen;
      47       26974 :     res->attnums = (AttrNumber *) palloc0(sizeof(AttrNumber) * maplen);
      48       26974 :     return res;
      49             : }
      50             : 
      51             : /*
      52             :  * free_attrmap
      53             :  *
      54             :  * Utility routine to release an attribute map.
      55             :  */
      56             : void
      57       12248 : free_attrmap(AttrMap *map)
      58             : {
      59       12248 :     pfree(map->attnums);
      60       12248 :     pfree(map);
      61       12248 : }
      62             : 
      63             : /*
      64             :  * build_attrmap_by_position
      65             :  *
      66             :  * Return a palloc'd bare attribute map for tuple conversion, matching input
      67             :  * and output columns by position.  Dropped columns are ignored in both input
      68             :  * and output, marked as 0.  This is normally a subroutine for
      69             :  * convert_tuples_by_position in tupconvert.c, but it can be used standalone.
      70             :  *
      71             :  * Note: the errdetail messages speak of indesc as the "returned" rowtype,
      72             :  * outdesc as the "expected" rowtype.  This is okay for current uses but
      73             :  * might need generalization in future.
      74             :  */
      75             : AttrMap *
      76        1560 : build_attrmap_by_position(TupleDesc indesc,
      77             :                           TupleDesc outdesc,
      78             :                           const char *msg)
      79             : {
      80             :     AttrMap    *attrMap;
      81             :     int         nincols;
      82             :     int         noutcols;
      83             :     int         n;
      84             :     int         i;
      85             :     int         j;
      86             :     bool        same;
      87             : 
      88             :     /*
      89             :      * The length is computed as the number of attributes of the expected
      90             :      * rowtype as it includes dropped attributes in its count.
      91             :      */
      92        1560 :     n = outdesc->natts;
      93        1560 :     attrMap = make_attrmap(n);
      94             : 
      95        1560 :     j = 0;                      /* j is next physical input attribute */
      96        1560 :     nincols = noutcols = 0;     /* these count non-dropped attributes */
      97        1560 :     same = true;
      98        4656 :     for (i = 0; i < n; i++)
      99             :     {
     100        3112 :         Form_pg_attribute att = TupleDescAttr(outdesc, i);
     101             :         Oid         atttypid;
     102             :         int32       atttypmod;
     103             : 
     104        3112 :         if (att->attisdropped)
     105          96 :             continue;           /* attrMap->attnums[i] is already 0 */
     106        3016 :         noutcols++;
     107        3016 :         atttypid = att->atttypid;
     108        3016 :         atttypmod = att->atttypmod;
     109        3034 :         for (; j < indesc->natts; j++)
     110             :         {
     111        3026 :             att = TupleDescAttr(indesc, j);
     112        3026 :             if (att->attisdropped)
     113          18 :                 continue;
     114        3008 :             nincols++;
     115             : 
     116             :             /* Found matching column, now check type */
     117        3008 :             if (atttypid != att->atttypid ||
     118        2992 :                 (atttypmod != att->atttypmod && atttypmod >= 0))
     119          16 :                 ereport(ERROR,
     120             :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
     121             :                          errmsg_internal("%s", _(msg)),
     122             :                          errdetail("Returned type %s does not match expected type %s in column %d.",
     123             :                                    format_type_with_typemod(att->atttypid,
     124             :                                                             att->atttypmod),
     125             :                                    format_type_with_typemod(atttypid,
     126             :                                                             atttypmod),
     127             :                                    noutcols)));
     128        2992 :             attrMap->attnums[i] = (AttrNumber) (j + 1);
     129        2992 :             j++;
     130        2992 :             break;
     131             :         }
     132        3000 :         if (attrMap->attnums[i] == 0)
     133           8 :             same = false;       /* we'll complain below */
     134             :     }
     135             : 
     136             :     /* Check for unused input columns */
     137        1550 :     for (; j < indesc->natts; j++)
     138             :     {
     139           6 :         if (TupleDescAttr(indesc, j)->attisdropped)
     140           0 :             continue;
     141           6 :         nincols++;
     142           6 :         same = false;           /* we'll complain below */
     143             :     }
     144             : 
     145             :     /* Report column count mismatch using the non-dropped-column counts */
     146        1544 :     if (!same)
     147          14 :         ereport(ERROR,
     148             :                 (errcode(ERRCODE_DATATYPE_MISMATCH),
     149             :                  errmsg_internal("%s", _(msg)),
     150             :                  errdetail("Number of returned columns (%d) does not match "
     151             :                            "expected column count (%d).",
     152             :                            nincols, noutcols)));
     153             : 
     154             :     /* Check if the map has a one-to-one match */
     155        1530 :     if (check_attrmap_match(indesc, outdesc, attrMap))
     156             :     {
     157             :         /* Runtime conversion is not needed */
     158        1470 :         free_attrmap(attrMap);
     159        1470 :         return NULL;
     160             :     }
     161             : 
     162          60 :     return attrMap;
     163             : }
     164             : 
     165             : /*
     166             :  * build_attrmap_by_name
     167             :  *
     168             :  * Return a palloc'd bare attribute map for tuple conversion, matching input
     169             :  * and output columns by name.  (Dropped columns are ignored in both input and
     170             :  * output.)  This is normally a subroutine for convert_tuples_by_name in
     171             :  * tupconvert.c, but can be used standalone.
     172             :  */
     173             : AttrMap *
     174       19680 : build_attrmap_by_name(TupleDesc indesc,
     175             :                       TupleDesc outdesc)
     176             : {
     177             :     AttrMap    *attrMap;
     178             :     int         outnatts;
     179             :     int         innatts;
     180             :     int         i;
     181       19680 :     int         nextindesc = -1;
     182             : 
     183       19680 :     outnatts = outdesc->natts;
     184       19680 :     innatts = indesc->natts;
     185             : 
     186       19680 :     attrMap = make_attrmap(outnatts);
     187       71134 :     for (i = 0; i < outnatts; i++)
     188             :     {
     189       51454 :         Form_pg_attribute outatt = TupleDescAttr(outdesc, i);
     190             :         char       *attname;
     191             :         Oid         atttypid;
     192             :         int32       atttypmod;
     193             :         int         j;
     194             : 
     195       51454 :         if (outatt->attisdropped)
     196        3044 :             continue;           /* attrMap->attnums[i] is already 0 */
     197       48410 :         attname = NameStr(outatt->attname);
     198       48410 :         atttypid = outatt->atttypid;
     199       48410 :         atttypmod = outatt->atttypmod;
     200             : 
     201             :         /*
     202             :          * Now search for an attribute with the same name in the indesc. It
     203             :          * seems likely that a partitioned table will have the attributes in
     204             :          * the same order as the partition, so the search below is optimized
     205             :          * for that case.  It is possible that columns are dropped in one of
     206             :          * the relations, but not the other, so we use the 'nextindesc'
     207             :          * counter to track the starting point of the search.  If the inner
     208             :          * loop encounters dropped columns then it will have to skip over
     209             :          * them, but it should leave 'nextindesc' at the correct position for
     210             :          * the next outer loop.
     211             :          */
     212       62946 :         for (j = 0; j < innatts; j++)
     213             :         {
     214             :             Form_pg_attribute inatt;
     215             : 
     216       62946 :             nextindesc++;
     217       62946 :             if (nextindesc >= innatts)
     218        4196 :                 nextindesc = 0;
     219             : 
     220       62946 :             inatt = TupleDescAttr(indesc, nextindesc);
     221       62946 :             if (inatt->attisdropped)
     222        2320 :                 continue;
     223       60626 :             if (strcmp(attname, NameStr(inatt->attname)) == 0)
     224             :             {
     225             :                 /* Found it, check type */
     226       48410 :                 if (atttypid != inatt->atttypid || atttypmod != inatt->atttypmod)
     227           0 :                     ereport(ERROR,
     228             :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
     229             :                              errmsg("could not convert row type"),
     230             :                              errdetail("Attribute \"%s\" of type %s does not match corresponding attribute of type %s.",
     231             :                                        attname,
     232             :                                        format_type_be(outdesc->tdtypeid),
     233             :                                        format_type_be(indesc->tdtypeid))));
     234       48410 :                 attrMap->attnums[i] = inatt->attnum;
     235       48410 :                 break;
     236             :             }
     237             :         }
     238       48410 :         if (attrMap->attnums[i] == 0)
     239           0 :             ereport(ERROR,
     240             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
     241             :                      errmsg("could not convert row type"),
     242             :                      errdetail("Attribute \"%s\" of type %s does not exist in type %s.",
     243             :                                attname,
     244             :                                format_type_be(outdesc->tdtypeid),
     245             :                                format_type_be(indesc->tdtypeid))));
     246             :     }
     247       19680 :     return attrMap;
     248             : }
     249             : 
     250             : /*
     251             :  * build_attrmap_by_name_if_req
     252             :  *
     253             :  * Returns mapping created by build_attrmap_by_name, or NULL if no
     254             :  * conversion is required.  This is a convenience routine for
     255             :  * convert_tuples_by_name() in tupconvert.c and other functions, but it
     256             :  * can be used standalone.
     257             :  */
     258             : AttrMap *
     259        6936 : build_attrmap_by_name_if_req(TupleDesc indesc,
     260             :                              TupleDesc outdesc)
     261             : {
     262             :     AttrMap    *attrMap;
     263             : 
     264             :     /* Verify compatibility and prepare attribute-number map */
     265        6936 :     attrMap = build_attrmap_by_name(indesc, outdesc);
     266             : 
     267             :     /* Check if the map has a one-to-one match */
     268        6936 :     if (check_attrmap_match(indesc, outdesc, attrMap))
     269             :     {
     270             :         /* Runtime conversion is not needed */
     271        4878 :         free_attrmap(attrMap);
     272        4878 :         return NULL;
     273             :     }
     274             : 
     275        2058 :     return attrMap;
     276             : }
     277             : 
     278             : /*
     279             :  * check_attrmap_match
     280             :  *
     281             :  * Check to see if the map is a one-to-one match, in which case we need
     282             :  * not to do a tuple conversion, and the attribute map is not necessary.
     283             :  */
     284             : static bool
     285        8466 : check_attrmap_match(TupleDesc indesc,
     286             :                     TupleDesc outdesc,
     287             :                     AttrMap *attrMap)
     288             : {
     289             :     int         i;
     290             : 
     291             :     /* no match if attribute numbers are not the same */
     292        8466 :     if (indesc->natts != outdesc->natts)
     293         896 :         return false;
     294             : 
     295       22812 :     for (i = 0; i < attrMap->maplen; i++)
     296             :     {
     297       16464 :         Form_pg_attribute inatt = TupleDescAttr(indesc, i);
     298       16464 :         Form_pg_attribute outatt = TupleDescAttr(outdesc, i);
     299             : 
     300             :         /*
     301             :          * If the input column has a missing attribute, we need a conversion.
     302             :          */
     303       16464 :         if (inatt->atthasmissing)
     304          32 :             return false;
     305             : 
     306       16432 :         if (attrMap->attnums[i] == (i + 1))
     307       15192 :             continue;
     308             : 
     309             :         /*
     310             :          * If it's a dropped column and the corresponding input column is also
     311             :          * dropped, we don't need a conversion.  However, attlen and attalign
     312             :          * must agree.
     313             :          */
     314        1240 :         if (attrMap->attnums[i] == 0 &&
     315          74 :             inatt->attisdropped &&
     316          50 :             inatt->attlen == outatt->attlen &&
     317          50 :             inatt->attalign == outatt->attalign)
     318          50 :             continue;
     319             : 
     320        1190 :         return false;
     321             :     }
     322             : 
     323        6348 :     return true;
     324             : }

Generated by: LCOV version 1.13