LCOV - code coverage report
Current view: top level - src/backend/access/common - tupdesc.c (source / functions) Hit Total Coverage
Test: PostgreSQL 11devel Lines: 299 315 94.9 %
Date: 2017-11-22 12:18:04 Functions: 16 16 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 127 153 83.0 %

           Branch data     Line data    Source code
       1                 :            : /*-------------------------------------------------------------------------
       2                 :            :  *
       3                 :            :  * tupdesc.c
       4                 :            :  *    POSTGRES tuple descriptor support code
       5                 :            :  *
       6                 :            :  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
       7                 :            :  * Portions Copyright (c) 1994, Regents of the University of California
       8                 :            :  *
       9                 :            :  *
      10                 :            :  * IDENTIFICATION
      11                 :            :  *    src/backend/access/common/tupdesc.c
      12                 :            :  *
      13                 :            :  * NOTES
      14                 :            :  *    some of the executor utility code such as "ExecTypeFromTL" should be
      15                 :            :  *    moved here.
      16                 :            :  *
      17                 :            :  *-------------------------------------------------------------------------
      18                 :            :  */
      19                 :            : 
      20                 :            : #include "postgres.h"
      21                 :            : 
      22                 :            : #include "access/hash.h"
      23                 :            : #include "access/htup_details.h"
      24                 :            : #include "catalog/pg_collation.h"
      25                 :            : #include "catalog/pg_type.h"
      26                 :            : #include "miscadmin.h"
      27                 :            : #include "parser/parse_type.h"
      28                 :            : #include "utils/acl.h"
      29                 :            : #include "utils/builtins.h"
      30                 :            : #include "utils/hashutils.h"
      31                 :            : #include "utils/resowner_private.h"
      32                 :            : #include "utils/syscache.h"
      33                 :            : 
      34                 :            : 
      35                 :            : /*
      36                 :            :  * CreateTemplateTupleDesc
      37                 :            :  *      This function allocates an empty tuple descriptor structure.
      38                 :            :  *
      39                 :            :  * Tuple type ID information is initially set for an anonymous record type;
      40                 :            :  * caller can overwrite this if needed.
      41                 :            :  */
      42                 :            : TupleDesc
      43                 :    4870678 : CreateTemplateTupleDesc(int natts, bool hasoid)
      44                 :            : {
      45                 :            :     TupleDesc   desc;
      46                 :            : 
      47                 :            :     /*
      48                 :            :      * sanity checks
      49                 :            :      */
      50                 :            :     AssertArg(natts >= 0);
      51                 :            : 
      52                 :            :     /*
      53                 :            :      * Allocate enough memory for the tuple descriptor, including the
      54                 :            :      * attribute rows.
      55                 :            :      */
      56                 :    4870678 :     desc = (TupleDesc) palloc(offsetof(struct tupleDesc, attrs) +
      57                 :    4870678 :                               natts * sizeof(FormData_pg_attribute));
      58                 :            : 
      59                 :            :     /*
      60                 :            :      * Initialize other fields of the tupdesc.
      61                 :            :      */
      62                 :    4870678 :     desc->natts = natts;
      63                 :    4870678 :     desc->constr = NULL;
      64                 :    4870678 :     desc->tdtypeid = RECORDOID;
      65                 :    4870678 :     desc->tdtypmod = -1;
      66                 :    4870678 :     desc->tdhasoid = hasoid;
      67                 :    4870678 :     desc->tdrefcount = -1;       /* assume not reference-counted */
      68                 :            : 
      69                 :    4870678 :     return desc;
      70                 :            : }
      71                 :            : 
      72                 :            : /*
      73                 :            :  * CreateTupleDesc
      74                 :            :  *      This function allocates a new TupleDesc by copying a given
      75                 :            :  *      Form_pg_attribute array.
      76                 :            :  *
      77                 :            :  * Tuple type ID information is initially set for an anonymous record type;
      78                 :            :  * caller can overwrite this if needed.
      79                 :            :  */
      80                 :            : TupleDesc
      81                 :    1515932 : CreateTupleDesc(int natts, bool hasoid, Form_pg_attribute *attrs)
      82                 :            : {
      83                 :            :     TupleDesc   desc;
      84                 :            :     int         i;
      85                 :            : 
      86                 :    1515932 :     desc = CreateTemplateTupleDesc(natts, hasoid);
      87                 :            : 
      88         [ +  + ]:   31692044 :     for (i = 0; i < natts; ++i)
      89                 :   30176112 :         memcpy(TupleDescAttr(desc, i), attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
      90                 :            : 
      91                 :    1515932 :     return desc;
      92                 :            : }
      93                 :            : 
      94                 :            : /*
      95                 :            :  * CreateTupleDescCopy
      96                 :            :  *      This function creates a new TupleDesc by copying from an existing
      97                 :            :  *      TupleDesc.
      98                 :            :  *
      99                 :            :  * !!! Constraints and defaults are not copied !!!
     100                 :            :  */
     101                 :            : TupleDesc
     102                 :     241782 : CreateTupleDescCopy(TupleDesc tupdesc)
     103                 :            : {
     104                 :            :     TupleDesc   desc;
     105                 :            :     int         i;
     106                 :            : 
     107                 :     241782 :     desc = CreateTemplateTupleDesc(tupdesc->natts, tupdesc->tdhasoid);
     108                 :            : 
     109         [ +  + ]:    1172630 :     for (i = 0; i < desc->natts; i++)
     110                 :            :     {
     111                 :     930848 :         Form_pg_attribute att = TupleDescAttr(desc, i);
     112                 :            : 
     113                 :     930848 :         memcpy(att, &tupdesc->attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
     114                 :     930848 :         att->attnotnull = false;
     115                 :     930848 :         att->atthasdef = false;
     116                 :     930848 :         att->attidentity = '\0';
     117                 :            :     }
     118                 :            : 
     119                 :     241782 :     desc->tdtypeid = tupdesc->tdtypeid;
     120                 :     241782 :     desc->tdtypmod = tupdesc->tdtypmod;
     121                 :            : 
     122                 :     241782 :     return desc;
     123                 :            : }
     124                 :            : 
     125                 :            : /*
     126                 :            :  * CreateTupleDescCopyConstr
     127                 :            :  *      This function creates a new TupleDesc by copying from an existing
     128                 :            :  *      TupleDesc (including its constraints and defaults).
     129                 :            :  */
     130                 :            : TupleDesc
     131                 :     186222 : CreateTupleDescCopyConstr(TupleDesc tupdesc)
     132                 :            : {
     133                 :            :     TupleDesc   desc;
     134                 :     186222 :     TupleConstr *constr = tupdesc->constr;
     135                 :            :     int         i;
     136                 :            : 
     137                 :     186222 :     desc = CreateTemplateTupleDesc(tupdesc->natts, tupdesc->tdhasoid);
     138                 :            : 
     139         [ +  + ]:    2404060 :     for (i = 0; i < desc->natts; i++)
     140                 :            :     {
     141                 :    2217838 :         memcpy(TupleDescAttr(desc, i),
     142                 :    2217838 :                TupleDescAttr(tupdesc, i),
     143                 :            :                ATTRIBUTE_FIXED_PART_SIZE);
     144                 :            :     }
     145                 :            : 
     146         [ +  + ]:     186222 :     if (constr)
     147                 :            :     {
     148                 :     168042 :         TupleConstr *cpy = (TupleConstr *) palloc0(sizeof(TupleConstr));
     149                 :            : 
     150                 :     168042 :         cpy->has_not_null = constr->has_not_null;
     151                 :            : 
     152         [ +  + ]:     168042 :         if ((cpy->num_defval = constr->num_defval) > 0)
     153                 :            :         {
     154                 :         26 :             cpy->defval = (AttrDefault *) palloc(cpy->num_defval * sizeof(AttrDefault));
     155                 :         26 :             memcpy(cpy->defval, constr->defval, cpy->num_defval * sizeof(AttrDefault));
     156         [ +  + ]:         52 :             for (i = cpy->num_defval - 1; i >= 0; i--)
     157                 :            :             {
     158         [ +  - ]:         26 :                 if (constr->defval[i].adbin)
     159                 :         26 :                     cpy->defval[i].adbin = pstrdup(constr->defval[i].adbin);
     160                 :            :             }
     161                 :            :         }
     162                 :            : 
     163         [ +  + ]:     168042 :         if ((cpy->num_check = constr->num_check) > 0)
     164                 :            :         {
     165                 :          8 :             cpy->check = (ConstrCheck *) palloc(cpy->num_check * sizeof(ConstrCheck));
     166                 :          8 :             memcpy(cpy->check, constr->check, cpy->num_check * sizeof(ConstrCheck));
     167         [ +  + ]:         16 :             for (i = cpy->num_check - 1; i >= 0; i--)
     168                 :            :             {
     169         [ +  - ]:          8 :                 if (constr->check[i].ccname)
     170                 :          8 :                     cpy->check[i].ccname = pstrdup(constr->check[i].ccname);
     171         [ +  - ]:          8 :                 if (constr->check[i].ccbin)
     172                 :          8 :                     cpy->check[i].ccbin = pstrdup(constr->check[i].ccbin);
     173                 :          8 :                 cpy->check[i].ccvalid = constr->check[i].ccvalid;
     174                 :          8 :                 cpy->check[i].ccnoinherit = constr->check[i].ccnoinherit;
     175                 :            :             }
     176                 :            :         }
     177                 :            : 
     178                 :     168042 :         desc->constr = cpy;
     179                 :            :     }
     180                 :            : 
     181                 :     186222 :     desc->tdtypeid = tupdesc->tdtypeid;
     182                 :     186222 :     desc->tdtypmod = tupdesc->tdtypmod;
     183                 :            : 
     184                 :     186222 :     return desc;
     185                 :            : }
     186                 :            : 
     187                 :            : /*
     188                 :            :  * TupleDescCopy
     189                 :            :  *      Copy a tuple descriptor into caller-supplied memory.
     190                 :            :  *      The memory may be shared memory mapped at any address, and must
     191                 :            :  *      be sufficient to hold TupleDescSize(src) bytes.
     192                 :            :  *
     193                 :            :  * !!! Constraints and defaults are not copied !!!
     194                 :            :  */
     195                 :            : void
     196                 :         20 : TupleDescCopy(TupleDesc dst, TupleDesc src)
     197                 :            : {
     198                 :         20 :     memcpy(dst, src, TupleDescSize(src));
     199                 :         20 :     dst->constr = NULL;
     200                 :         20 :     dst->tdrefcount = -1;
     201                 :         20 : }
     202                 :            : 
     203                 :            : /*
     204                 :            :  * TupleDescCopyEntry
     205                 :            :  *      This function copies a single attribute structure from one tuple
     206                 :            :  *      descriptor to another.
     207                 :            :  *
     208                 :            :  * !!! Constraints and defaults are not copied !!!
     209                 :            :  */
     210                 :            : void
     211                 :      13766 : TupleDescCopyEntry(TupleDesc dst, AttrNumber dstAttno,
     212                 :            :                    TupleDesc src, AttrNumber srcAttno)
     213                 :            : {
     214                 :      13766 :     Form_pg_attribute dstAtt = TupleDescAttr(dst, dstAttno - 1);
     215                 :      13766 :     Form_pg_attribute srcAtt = TupleDescAttr(src, srcAttno - 1);
     216                 :            : 
     217                 :            :     /*
     218                 :            :      * sanity checks
     219                 :            :      */
     220                 :            :     AssertArg(PointerIsValid(src));
     221                 :            :     AssertArg(PointerIsValid(dst));
     222                 :            :     AssertArg(srcAttno >= 1);
     223                 :            :     AssertArg(srcAttno <= src->natts);
     224                 :            :     AssertArg(dstAttno >= 1);
     225                 :            :     AssertArg(dstAttno <= dst->natts);
     226                 :            : 
     227                 :      13766 :     memcpy(dstAtt, srcAtt, ATTRIBUTE_FIXED_PART_SIZE);
     228                 :            : 
     229                 :            :     /*
     230                 :            :      * Aside from updating the attno, we'd better reset attcacheoff.
     231                 :            :      *
     232                 :            :      * XXX Actually, to be entirely safe we'd need to reset the attcacheoff of
     233                 :            :      * all following columns in dst as well.  Current usage scenarios don't
     234                 :            :      * require that though, because all following columns will get initialized
     235                 :            :      * by other uses of this function or TupleDescInitEntry.  So we cheat a
     236                 :            :      * bit to avoid a useless O(N^2) penalty.
     237                 :            :      */
     238                 :      13766 :     dstAtt->attnum = dstAttno;
     239                 :      13766 :     dstAtt->attcacheoff = -1;
     240                 :            : 
     241                 :            :     /* since we're not copying constraints or defaults, clear these */
     242                 :      13766 :     dstAtt->attnotnull = false;
     243                 :      13766 :     dstAtt->atthasdef = false;
     244                 :      13766 :     dstAtt->attidentity = '\0';
     245                 :      13766 : }
     246                 :            : 
     247                 :            : /*
     248                 :            :  * Free a TupleDesc including all substructure
     249                 :            :  */
     250                 :            : void
     251                 :     910652 : FreeTupleDesc(TupleDesc tupdesc)
     252                 :            : {
     253                 :            :     int         i;
     254                 :            : 
     255                 :            :     /*
     256                 :            :      * Possibly this should assert tdrefcount == 0, to disallow explicit
     257                 :            :      * freeing of un-refcounted tupdescs?
     258                 :            :      */
     259                 :            :     Assert(tupdesc->tdrefcount <= 0);
     260                 :            : 
     261         [ +  + ]:     910652 :     if (tupdesc->constr)
     262                 :            :     {
     263         [ +  + ]:     124928 :         if (tupdesc->constr->num_defval > 0)
     264                 :            :         {
     265                 :       5836 :             AttrDefault *attrdef = tupdesc->constr->defval;
     266                 :            : 
     267         [ +  + ]:      12980 :             for (i = tupdesc->constr->num_defval - 1; i >= 0; i--)
     268                 :            :             {
     269         [ +  - ]:       7144 :                 if (attrdef[i].adbin)
     270                 :       7144 :                     pfree(attrdef[i].adbin);
     271                 :            :             }
     272                 :       5836 :             pfree(attrdef);
     273                 :            :         }
     274         [ +  + ]:     124928 :         if (tupdesc->constr->num_check > 0)
     275                 :            :         {
     276                 :       3706 :             ConstrCheck *check = tupdesc->constr->check;
     277                 :            : 
     278         [ +  + ]:       8640 :             for (i = tupdesc->constr->num_check - 1; i >= 0; i--)
     279                 :            :             {
     280         [ +  - ]:       4934 :                 if (check[i].ccname)
     281                 :       4934 :                     pfree(check[i].ccname);
     282         [ +  - ]:       4934 :                 if (check[i].ccbin)
     283                 :       4934 :                     pfree(check[i].ccbin);
     284                 :            :             }
     285                 :       3706 :             pfree(check);
     286                 :            :         }
     287                 :     124928 :         pfree(tupdesc->constr);
     288                 :            :     }
     289                 :            : 
     290                 :     910652 :     pfree(tupdesc);
     291                 :     910652 : }
     292                 :            : 
     293                 :            : /*
     294                 :            :  * Increment the reference count of a tupdesc, and log the reference in
     295                 :            :  * CurrentResourceOwner.
     296                 :            :  *
     297                 :            :  * Do not apply this to tupdescs that are not being refcounted.  (Use the
     298                 :            :  * macro PinTupleDesc for tupdescs of uncertain status.)
     299                 :            :  */
     300                 :            : void
     301                 :    2427264 : IncrTupleDescRefCount(TupleDesc tupdesc)
     302                 :            : {
     303                 :            :     Assert(tupdesc->tdrefcount >= 0);
     304                 :            : 
     305                 :    2427264 :     ResourceOwnerEnlargeTupleDescs(CurrentResourceOwner);
     306                 :    2427264 :     tupdesc->tdrefcount++;
     307                 :    2427264 :     ResourceOwnerRememberTupleDesc(CurrentResourceOwner, tupdesc);
     308                 :    2427264 : }
     309                 :            : 
     310                 :            : /*
     311                 :            :  * Decrement the reference count of a tupdesc, remove the corresponding
     312                 :            :  * reference from CurrentResourceOwner, and free the tupdesc if no more
     313                 :            :  * references remain.
     314                 :            :  *
     315                 :            :  * Do not apply this to tupdescs that are not being refcounted.  (Use the
     316                 :            :  * macro ReleaseTupleDesc for tupdescs of uncertain status.)
     317                 :            :  */
     318                 :            : void
     319                 :    2427264 : DecrTupleDescRefCount(TupleDesc tupdesc)
     320                 :            : {
     321                 :            :     Assert(tupdesc->tdrefcount > 0);
     322                 :            : 
     323                 :    2427264 :     ResourceOwnerForgetTupleDesc(CurrentResourceOwner, tupdesc);
     324         [ +  + ]:    2427264 :     if (--tupdesc->tdrefcount == 0)
     325                 :         92 :         FreeTupleDesc(tupdesc);
     326                 :    2427264 : }
     327                 :            : 
     328                 :            : /*
     329                 :            :  * Compare two TupleDesc structures for logical equality
     330                 :            :  *
     331                 :            :  * Note: we deliberately do not check the attrelid and tdtypmod fields.
     332                 :            :  * This allows typcache.c to use this routine to see if a cached record type
     333                 :            :  * matches a requested type, and is harmless for relcache.c's uses.
     334                 :            :  * We don't compare tdrefcount, either.
     335                 :            :  */
     336                 :            : bool
     337                 :     239708 : equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
     338                 :            : {
     339                 :            :     int         i,
     340                 :            :                 j,
     341                 :            :                 n;
     342                 :            : 
     343         [ +  + ]:     239708 :     if (tupdesc1->natts != tupdesc2->natts)
     344                 :        952 :         return false;
     345         [ +  + ]:     238756 :     if (tupdesc1->tdtypeid != tupdesc2->tdtypeid)
     346                 :      13560 :         return false;
     347         [ +  + ]:     225196 :     if (tupdesc1->tdhasoid != tupdesc2->tdhasoid)
     348                 :         82 :         return false;
     349                 :            : 
     350         [ +  + ]:    1693812 :     for (i = 0; i < tupdesc1->natts; i++)
     351                 :            :     {
     352                 :    1475320 :         Form_pg_attribute attr1 = TupleDescAttr(tupdesc1, i);
     353                 :    1475320 :         Form_pg_attribute attr2 = TupleDescAttr(tupdesc2, i);
     354                 :            : 
     355                 :            :         /*
     356                 :            :          * We do not need to check every single field here: we can disregard
     357                 :            :          * attrelid and attnum (which were used to place the row in the attrs
     358                 :            :          * array in the first place).  It might look like we could dispense
     359                 :            :          * with checking attlen/attbyval/attalign, since these are derived
     360                 :            :          * from atttypid; but in the case of dropped columns we must check
     361                 :            :          * them (since atttypid will be zero for all dropped columns) and in
     362                 :            :          * general it seems safer to check them always.
     363                 :            :          *
     364                 :            :          * attcacheoff must NOT be checked since it's possibly not set in both
     365                 :            :          * copies.
     366                 :            :          */
     367         [ +  + ]:    1475320 :         if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
     368                 :       4086 :             return false;
     369         [ +  + ]:    1471234 :         if (attr1->atttypid != attr2->atttypid)
     370                 :        340 :             return false;
     371         [ +  + ]:    1470894 :         if (attr1->attstattarget != attr2->attstattarget)
     372                 :         34 :             return false;
     373         [ +  + ]:    1470860 :         if (attr1->attlen != attr2->attlen)
     374                 :         10 :             return false;
     375         [ -  + ]:    1470850 :         if (attr1->attndims != attr2->attndims)
     376                 :          0 :             return false;
     377         [ +  + ]:    1470850 :         if (attr1->atttypmod != attr2->atttypmod)
     378                 :         10 :             return false;
     379         [ +  + ]:    1470840 :         if (attr1->attbyval != attr2->attbyval)
     380                 :         32 :             return false;
     381         [ +  + ]:    1470808 :         if (attr1->attstorage != attr2->attstorage)
     382                 :         72 :             return false;
     383         [ -  + ]:    1470736 :         if (attr1->attalign != attr2->attalign)
     384                 :          0 :             return false;
     385         [ +  + ]:    1470736 :         if (attr1->attnotnull != attr2->attnotnull)
     386                 :        238 :             return false;
     387         [ +  + ]:    1470498 :         if (attr1->atthasdef != attr2->atthasdef)
     388                 :        878 :             return false;
     389         [ +  + ]:    1469620 :         if (attr1->attidentity != attr2->attidentity)
     390                 :         42 :             return false;
     391         [ -  + ]:    1469578 :         if (attr1->attisdropped != attr2->attisdropped)
     392                 :          0 :             return false;
     393         [ +  + ]:    1469578 :         if (attr1->attislocal != attr2->attislocal)
     394                 :        598 :             return false;
     395         [ +  + ]:    1468980 :         if (attr1->attinhcount != attr2->attinhcount)
     396                 :        282 :             return false;
     397         [ -  + ]:    1468698 :         if (attr1->attcollation != attr2->attcollation)
     398                 :          0 :             return false;
     399                 :            :         /* attacl, attoptions and attfdwoptions are not even present... */
     400                 :            :     }
     401                 :            : 
     402         [ +  + ]:     218492 :     if (tupdesc1->constr != NULL)
     403                 :            :     {
     404                 :      30898 :         TupleConstr *constr1 = tupdesc1->constr;
     405                 :      30898 :         TupleConstr *constr2 = tupdesc2->constr;
     406                 :            : 
     407         [ +  + ]:      30898 :         if (constr2 == NULL)
     408                 :         72 :             return false;
     409         [ -  + ]:      30826 :         if (constr1->has_not_null != constr2->has_not_null)
     410                 :          0 :             return false;
     411                 :      30826 :         n = constr1->num_defval;
     412         [ -  + ]:      30826 :         if (n != (int) constr2->num_defval)
     413                 :          0 :             return false;
     414         [ +  + ]:      32866 :         for (i = 0; i < n; i++)
     415                 :            :         {
     416                 :       2040 :             AttrDefault *defval1 = constr1->defval + i;
     417                 :       2040 :             AttrDefault *defval2 = constr2->defval;
     418                 :            : 
     419                 :            :             /*
     420                 :            :              * We can't assume that the items are always read from the system
     421                 :            :              * catalogs in the same order; so use the adnum field to identify
     422                 :            :              * the matching item to compare.
     423                 :            :              */
     424         [ +  - ]:       2572 :             for (j = 0; j < n; defval2++, j++)
     425                 :            :             {
     426         [ +  + ]:       2572 :                 if (defval1->adnum == defval2->adnum)
     427                 :       2040 :                     break;
     428                 :            :             }
     429         [ -  + ]:       2040 :             if (j >= n)
     430                 :          0 :                 return false;
     431         [ -  + ]:       2040 :             if (strcmp(defval1->adbin, defval2->adbin) != 0)
     432                 :          0 :                 return false;
     433                 :            :         }
     434                 :      30826 :         n = constr1->num_check;
     435         [ +  + ]:      30826 :         if (n != (int) constr2->num_check)
     436                 :        560 :             return false;
     437         [ +  + ]:      31012 :         for (i = 0; i < n; i++)
     438                 :            :         {
     439                 :        774 :             ConstrCheck *check1 = constr1->check + i;
     440                 :        774 :             ConstrCheck *check2 = constr2->check;
     441                 :            : 
     442                 :            :             /*
     443                 :            :              * Similarly, don't assume that the checks are always read in the
     444                 :            :              * same order; match them up by name and contents. (The name
     445                 :            :              * *should* be unique, but...)
     446                 :            :              */
     447         [ +  + ]:       1006 :             for (j = 0; j < n; check2++, j++)
     448                 :            :             {
     449 [ +  + ][ +  - ]:        978 :                 if (strcmp(check1->ccname, check2->ccname) == 0 &&
     450         [ +  + ]:        774 :                     strcmp(check1->ccbin, check2->ccbin) == 0 &&
     451         [ +  - ]:        746 :                     check1->ccvalid == check2->ccvalid &&
     452                 :        746 :                     check1->ccnoinherit == check2->ccnoinherit)
     453                 :        746 :                     break;
     454                 :            :             }
     455         [ +  + ]:        774 :             if (j >= n)
     456                 :         28 :                 return false;
     457                 :            :         }
     458                 :            :     }
     459         [ +  + ]:     187594 :     else if (tupdesc2->constr != NULL)
     460                 :        390 :         return false;
     461                 :     217442 :     return true;
     462                 :            : }
     463                 :            : 
     464                 :            : /*
     465                 :            :  * hashTupleDesc
     466                 :            :  *      Compute a hash value for a tuple descriptor.
     467                 :            :  *
     468                 :            :  * If two tuple descriptors would be considered equal by equalTupleDescs()
     469                 :            :  * then their hash value will be equal according to this function.
     470                 :            :  *
     471                 :            :  * Note that currently contents of constraint are not hashed - it'd be a bit
     472                 :            :  * painful to do so, and conflicts just due to constraints are unlikely.
     473                 :            :  */
     474                 :            : uint32
     475                 :     120710 : hashTupleDesc(TupleDesc desc)
     476                 :            : {
     477                 :            :     uint32      s;
     478                 :            :     int         i;
     479                 :            : 
     480                 :     120710 :     s = hash_combine(0, hash_uint32(desc->natts));
     481                 :     120710 :     s = hash_combine(s, hash_uint32(desc->tdtypeid));
     482                 :     120710 :     s = hash_combine(s, hash_uint32(desc->tdhasoid));
     483         [ +  + ]:    1062074 :     for (i = 0; i < desc->natts; ++i)
     484                 :     941364 :         s = hash_combine(s, hash_uint32(TupleDescAttr(desc, i)->atttypid));
     485                 :            : 
     486                 :     120710 :     return s;
     487                 :            : }
     488                 :            : 
     489                 :            : /*
     490                 :            :  * TupleDescInitEntry
     491                 :            :  *      This function initializes a single attribute structure in
     492                 :            :  *      a previously allocated tuple descriptor.
     493                 :            :  *
     494                 :            :  * If attributeName is NULL, the attname field is set to an empty string
     495                 :            :  * (this is for cases where we don't know or need a name for the field).
     496                 :            :  * Also, some callers use this function to change the datatype-related fields
     497                 :            :  * in an existing tupdesc; they pass attributeName = NameStr(att->attname)
     498                 :            :  * to indicate that the attname field shouldn't be modified.
     499                 :            :  *
     500                 :            :  * Note that attcollation is set to the default for the specified datatype.
     501                 :            :  * If a nondefault collation is needed, insert it afterwards using
     502                 :            :  * TupleDescInitEntryCollation.
     503                 :            :  */
     504                 :            : void
     505                 :    4206524 : TupleDescInitEntry(TupleDesc desc,
     506                 :            :                    AttrNumber attributeNumber,
     507                 :            :                    const char *attributeName,
     508                 :            :                    Oid oidtypeid,
     509                 :            :                    int32 typmod,
     510                 :            :                    int attdim)
     511                 :            : {
     512                 :            :     HeapTuple   tuple;
     513                 :            :     Form_pg_type typeForm;
     514                 :            :     Form_pg_attribute att;
     515                 :            : 
     516                 :            :     /*
     517                 :            :      * sanity checks
     518                 :            :      */
     519                 :            :     AssertArg(PointerIsValid(desc));
     520                 :            :     AssertArg(attributeNumber >= 1);
     521                 :            :     AssertArg(attributeNumber <= desc->natts);
     522                 :            : 
     523                 :            :     /*
     524                 :            :      * initialize the attribute fields
     525                 :            :      */
     526                 :    4206524 :     att = TupleDescAttr(desc, attributeNumber - 1);
     527                 :            : 
     528                 :    4206524 :     att->attrelid = 0;           /* dummy value */
     529                 :            : 
     530                 :            :     /*
     531                 :            :      * Note: attributeName can be NULL, because the planner doesn't always
     532                 :            :      * fill in valid resname values in targetlists, particularly for resjunk
     533                 :            :      * attributes. Also, do nothing if caller wants to re-use the old attname.
     534                 :            :      */
     535         [ +  + ]:    4206524 :     if (attributeName == NULL)
     536 [ +  + ][ +  - ]:    3945724 :         MemSet(NameStr(att->attname), 0, NAMEDATALEN);
         [ +  - ][ +  - ]
                 [ +  + ]
     537         [ +  + ]:    3329936 :     else if (attributeName != NameStr(att->attname))
     538                 :    3324806 :         namestrcpy(&(att->attname), attributeName);
     539                 :            : 
     540                 :    4206524 :     att->attstattarget = -1;
     541                 :    4206524 :     att->attcacheoff = -1;
     542                 :    4206524 :     att->atttypmod = typmod;
     543                 :            : 
     544                 :    4206524 :     att->attnum = attributeNumber;
     545                 :    4206524 :     att->attndims = attdim;
     546                 :            : 
     547                 :    4206524 :     att->attnotnull = false;
     548                 :    4206524 :     att->atthasdef = false;
     549                 :    4206524 :     att->attidentity = '\0';
     550                 :    4206524 :     att->attisdropped = false;
     551                 :    4206524 :     att->attislocal = true;
     552                 :    4206524 :     att->attinhcount = 0;
     553                 :            :     /* attacl, attoptions and attfdwoptions are not present in tupledescs */
     554                 :            : 
     555                 :    4206524 :     tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(oidtypeid));
     556         [ -  + ]:    4206524 :     if (!HeapTupleIsValid(tuple))
     557                 :          0 :         elog(ERROR, "cache lookup failed for type %u", oidtypeid);
     558                 :    4206524 :     typeForm = (Form_pg_type) GETSTRUCT(tuple);
     559                 :            : 
     560                 :    4206524 :     att->atttypid = oidtypeid;
     561                 :    4206524 :     att->attlen = typeForm->typlen;
     562                 :    4206524 :     att->attbyval = typeForm->typbyval;
     563                 :    4206524 :     att->attalign = typeForm->typalign;
     564                 :    4206524 :     att->attstorage = typeForm->typstorage;
     565                 :    4206524 :     att->attcollation = typeForm->typcollation;
     566                 :            : 
     567                 :    4206524 :     ReleaseSysCache(tuple);
     568                 :    4206524 : }
     569                 :            : 
     570                 :            : /*
     571                 :            :  * TupleDescInitBuiltinEntry
     572                 :            :  *      Initialize a tuple descriptor without catalog access.  Only
     573                 :            :  *      a limited range of builtin types are supported.
     574                 :            :  */
     575                 :            : void
     576                 :       2354 : TupleDescInitBuiltinEntry(TupleDesc desc,
     577                 :            :                           AttrNumber attributeNumber,
     578                 :            :                           const char *attributeName,
     579                 :            :                           Oid oidtypeid,
     580                 :            :                           int32 typmod,
     581                 :            :                           int attdim)
     582                 :            : {
     583                 :            :     Form_pg_attribute att;
     584                 :            : 
     585                 :            :     /* sanity checks */
     586                 :            :     AssertArg(PointerIsValid(desc));
     587                 :            :     AssertArg(attributeNumber >= 1);
     588                 :            :     AssertArg(attributeNumber <= desc->natts);
     589                 :            : 
     590                 :            :     /* initialize the attribute fields */
     591                 :       2354 :     att = TupleDescAttr(desc, attributeNumber - 1);
     592                 :       2354 :     att->attrelid = 0;           /* dummy value */
     593                 :            : 
     594                 :            :     /* unlike TupleDescInitEntry, we require an attribute name */
     595                 :            :     Assert(attributeName != NULL);
     596                 :       2354 :     namestrcpy(&(att->attname), attributeName);
     597                 :            : 
     598                 :       2354 :     att->attstattarget = -1;
     599                 :       2354 :     att->attcacheoff = -1;
     600                 :       2354 :     att->atttypmod = typmod;
     601                 :            : 
     602                 :       2354 :     att->attnum = attributeNumber;
     603                 :       2354 :     att->attndims = attdim;
     604                 :            : 
     605                 :       2354 :     att->attnotnull = false;
     606                 :       2354 :     att->atthasdef = false;
     607                 :       2354 :     att->attidentity = '\0';
     608                 :       2354 :     att->attisdropped = false;
     609                 :       2354 :     att->attislocal = true;
     610                 :       2354 :     att->attinhcount = 0;
     611                 :            :     /* attacl, attoptions and attfdwoptions are not present in tupledescs */
     612                 :            : 
     613                 :       2354 :     att->atttypid = oidtypeid;
     614                 :            : 
     615                 :            :     /*
     616                 :            :      * Our goal here is to support just enough types to let basic builtin
     617                 :            :      * commands work without catalog access - e.g. so that we can do certain
     618                 :            :      * things even in processes that are not connected to a database.
     619                 :            :      */
     620   [ +  -  +  +  :       2354 :     switch (oidtypeid)
                      - ]
     621                 :            :     {
     622                 :            :         case TEXTOID:
     623                 :            :         case TEXTARRAYOID:
     624                 :       2012 :             att->attlen = -1;
     625                 :       2012 :             att->attbyval = false;
     626                 :       2012 :             att->attalign = 'i';
     627                 :       2012 :             att->attstorage = 'x';
     628                 :       2012 :             att->attcollation = DEFAULT_COLLATION_OID;
     629                 :       2012 :             break;
     630                 :            : 
     631                 :            :         case BOOLOID:
     632                 :          0 :             att->attlen = 1;
     633                 :          0 :             att->attbyval = true;
     634                 :          0 :             att->attalign = 'c';
     635                 :          0 :             att->attstorage = 'p';
     636                 :          0 :             att->attcollation = InvalidOid;
     637                 :          0 :             break;
     638                 :            : 
     639                 :            :         case INT4OID:
     640                 :        328 :             att->attlen = 4;
     641                 :        328 :             att->attbyval = true;
     642                 :        328 :             att->attalign = 'i';
     643                 :        328 :             att->attstorage = 'p';
     644                 :        328 :             att->attcollation = InvalidOid;
     645                 :        328 :             break;
     646                 :            : 
     647                 :            :         case INT8OID:
     648                 :         14 :             att->attlen = 8;
     649                 :         14 :             att->attbyval = FLOAT8PASSBYVAL;
     650                 :         14 :             att->attalign = 'd';
     651                 :         14 :             att->attstorage = 'p';
     652                 :         14 :             att->attcollation = InvalidOid;
     653                 :         14 :             break;
     654                 :            :     }
     655                 :       2354 : }
     656                 :            : 
     657                 :            : /*
     658                 :            :  * TupleDescInitEntryCollation
     659                 :            :  *
     660                 :            :  * Assign a nondefault collation to a previously initialized tuple descriptor
     661                 :            :  * entry.
     662                 :            :  */
     663                 :            : void
     664                 :    2627096 : TupleDescInitEntryCollation(TupleDesc desc,
     665                 :            :                             AttrNumber attributeNumber,
     666                 :            :                             Oid collationid)
     667                 :            : {
     668                 :            :     /*
     669                 :            :      * sanity checks
     670                 :            :      */
     671                 :            :     AssertArg(PointerIsValid(desc));
     672                 :            :     AssertArg(attributeNumber >= 1);
     673                 :            :     AssertArg(attributeNumber <= desc->natts);
     674                 :            : 
     675                 :    2627096 :     TupleDescAttr(desc, attributeNumber - 1)->attcollation = collationid;
     676                 :    2627096 : }
     677                 :            : 
     678                 :            : 
     679                 :            : /*
     680                 :            :  * BuildDescForRelation
     681                 :            :  *
     682                 :            :  * Given a relation schema (list of ColumnDef nodes), build a TupleDesc.
     683                 :            :  *
     684                 :            :  * Note: the default assumption is no OIDs; caller may modify the returned
     685                 :            :  * TupleDesc if it wants OIDs.  Also, tdtypeid will need to be filled in
     686                 :            :  * later on.
     687                 :            :  */
     688                 :            : TupleDesc
     689                 :      48270 : BuildDescForRelation(List *schema)
     690                 :            : {
     691                 :            :     int         natts;
     692                 :            :     AttrNumber  attnum;
     693                 :            :     ListCell   *l;
     694                 :            :     TupleDesc   desc;
     695                 :            :     bool        has_not_null;
     696                 :            :     char       *attname;
     697                 :            :     Oid         atttypid;
     698                 :            :     int32       atttypmod;
     699                 :            :     Oid         attcollation;
     700                 :            :     int         attdim;
     701                 :            : 
     702                 :            :     /*
     703                 :            :      * allocate a new tuple descriptor
     704                 :            :      */
     705                 :      48270 :     natts = list_length(schema);
     706                 :      48270 :     desc = CreateTemplateTupleDesc(natts, false);
     707                 :      48270 :     has_not_null = false;
     708                 :            : 
     709                 :      48270 :     attnum = 0;
     710                 :            : 
     711         [ +  + ]:     399920 :     foreach(l, schema)
     712                 :            :     {
     713                 :     351666 :         ColumnDef  *entry = lfirst(l);
     714                 :            :         AclResult   aclresult;
     715                 :            :         Form_pg_attribute att;
     716                 :            : 
     717                 :            :         /*
     718                 :            :          * for each entry in the list, get the name and type information from
     719                 :            :          * the list and have TupleDescInitEntry fill in the attribute
     720                 :            :          * information we need.
     721                 :            :          */
     722                 :     351666 :         attnum++;
     723                 :            : 
     724                 :     351666 :         attname = entry->colname;
     725                 :     351666 :         typenameTypeIdAndMod(NULL, entry->typeName, &atttypid, &atttypmod);
     726                 :            : 
     727                 :     351666 :         aclresult = pg_type_aclcheck(atttypid, GetUserId(), ACL_USAGE);
     728         [ +  + ]:     351666 :         if (aclresult != ACLCHECK_OK)
     729                 :         16 :             aclcheck_error_type(aclresult, atttypid);
     730                 :            : 
     731                 :     351650 :         attcollation = GetColumnDefCollation(NULL, entry, atttypid);
     732                 :     351650 :         attdim = list_length(entry->typeName->arrayBounds);
     733                 :            : 
     734         [ -  + ]:     351650 :         if (entry->typeName->setof)
     735         [ #  # ]:          0 :             ereport(ERROR,
     736                 :            :                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
     737                 :            :                      errmsg("column \"%s\" cannot be declared SETOF",
     738                 :            :                             attname)));
     739                 :            : 
     740                 :     351650 :         TupleDescInitEntry(desc, attnum, attname,
     741                 :            :                            atttypid, atttypmod, attdim);
     742                 :     351650 :         att = TupleDescAttr(desc, attnum - 1);
     743                 :            : 
     744                 :            :         /* Override TupleDescInitEntry's settings as requested */
     745                 :     351650 :         TupleDescInitEntryCollation(desc, attnum, attcollation);
     746         [ +  + ]:     351650 :         if (entry->storage)
     747                 :       3686 :             att->attstorage = entry->storage;
     748                 :            : 
     749                 :            :         /* Fill in additional stuff not handled by TupleDescInitEntry */
     750                 :     351650 :         att->attnotnull = entry->is_not_null;
     751                 :     351650 :         has_not_null |= entry->is_not_null;
     752                 :     351650 :         att->attislocal = entry->is_local;
     753                 :     351650 :         att->attinhcount = entry->inhcount;
     754                 :            :     }
     755                 :            : 
     756         [ +  + ]:      48254 :     if (has_not_null)
     757                 :            :     {
     758                 :       5132 :         TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
     759                 :            : 
     760                 :       5132 :         constr->has_not_null = true;
     761                 :       5132 :         constr->defval = NULL;
     762                 :       5132 :         constr->num_defval = 0;
     763                 :       5132 :         constr->check = NULL;
     764                 :       5132 :         constr->num_check = 0;
     765                 :       5132 :         desc->constr = constr;
     766                 :            :     }
     767                 :            :     else
     768                 :            :     {
     769                 :      43122 :         desc->constr = NULL;
     770                 :            :     }
     771                 :            : 
     772                 :      48254 :     return desc;
     773                 :            : }
     774                 :            : 
     775                 :            : /*
     776                 :            :  * BuildDescFromLists
     777                 :            :  *
     778                 :            :  * Build a TupleDesc given lists of column names (as String nodes),
     779                 :            :  * column type OIDs, typmods, and collation OIDs.
     780                 :            :  *
     781                 :            :  * No constraints are generated.
     782                 :            :  *
     783                 :            :  * This is essentially a cut-down version of BuildDescForRelation for use
     784                 :            :  * with functions returning RECORD.
     785                 :            :  */
     786                 :            : TupleDesc
     787                 :        546 : BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
     788                 :            : {
     789                 :            :     int         natts;
     790                 :            :     AttrNumber  attnum;
     791                 :            :     ListCell   *l1;
     792                 :            :     ListCell   *l2;
     793                 :            :     ListCell   *l3;
     794                 :            :     ListCell   *l4;
     795                 :            :     TupleDesc   desc;
     796                 :            : 
     797                 :        546 :     natts = list_length(names);
     798                 :            :     Assert(natts == list_length(types));
     799                 :            :     Assert(natts == list_length(typmods));
     800                 :            :     Assert(natts == list_length(collations));
     801                 :            : 
     802                 :            :     /*
     803                 :            :      * allocate a new tuple descriptor
     804                 :            :      */
     805                 :        546 :     desc = CreateTemplateTupleDesc(natts, false);
     806                 :            : 
     807                 :        546 :     attnum = 0;
     808                 :            : 
     809                 :        546 :     l2 = list_head(types);
     810                 :        546 :     l3 = list_head(typmods);
     811                 :        546 :     l4 = list_head(collations);
     812         [ +  + ]:       2146 :     foreach(l1, names)
     813                 :            :     {
     814                 :       1600 :         char       *attname = strVal(lfirst(l1));
     815                 :            :         Oid         atttypid;
     816                 :            :         int32       atttypmod;
     817                 :            :         Oid         attcollation;
     818                 :            : 
     819                 :       1600 :         atttypid = lfirst_oid(l2);
     820                 :       1600 :         l2 = lnext(l2);
     821                 :       1600 :         atttypmod = lfirst_int(l3);
     822                 :       1600 :         l3 = lnext(l3);
     823                 :       1600 :         attcollation = lfirst_oid(l4);
     824                 :       1600 :         l4 = lnext(l4);
     825                 :            : 
     826                 :       1600 :         attnum++;
     827                 :            : 
     828                 :       1600 :         TupleDescInitEntry(desc, attnum, attname, atttypid, atttypmod, 0);
     829                 :       1600 :         TupleDescInitEntryCollation(desc, attnum, attcollation);
     830                 :            :     }
     831                 :            : 
     832                 :        546 :     return desc;
     833                 :            : }

Generated by: LCOV version 1.13