granicus.if.org Git - postgresql/blob - src/backend/parser/parse_relation.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * parse_relation.c
   4  *        parser support routines dealing with relations
   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/parser/parse_relation.c
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 #include "postgres.h"
  16
  17 #include <ctype.h>
  18
  19 #include "access/htup_details.h"
  20 #include "access/sysattr.h"
  21 #include "catalog/heap.h"
  22 #include "catalog/namespace.h"
  23 #include "catalog/pg_type.h"
  24 #include "funcapi.h"
  25 #include "nodes/makefuncs.h"
  26 #include "nodes/nodeFuncs.h"
  27 #include "parser/parsetree.h"
  28 #include "parser/parse_enr.h"
  29 #include "parser/parse_relation.h"
  30 #include "parser/parse_type.h"
  31 #include "utils/builtins.h"
  32 #include "utils/lsyscache.h"
  33 #include "utils/rel.h"
  34 #include "utils/syscache.h"
  35 #include "utils/varlena.h"
  36
  37
  38 #define MAX_FUZZY_DISTANCE                              3
  39
  40 static RangeTblEntry *scanNameSpaceForRefname(ParseState *pstate,
  41                                                 const char *refname, int location);
  42 static RangeTblEntry *scanNameSpaceForRelid(ParseState *pstate, Oid relid,
  43                                           int location);
  44 static void check_lateral_ref_ok(ParseState *pstate, ParseNamespaceItem *nsitem,
  45                                          int location);
  46 static void markRTEForSelectPriv(ParseState *pstate, RangeTblEntry *rte,
  47                                          int rtindex, AttrNumber col);
  48 static void expandRelation(Oid relid, Alias *eref,
  49                            int rtindex, int sublevels_up,
  50                            int location, bool include_dropped,
  51                            List **colnames, List **colvars);
  52 static void expandTupleDesc(TupleDesc tupdesc, Alias *eref,
  53                                 int count, int offset,
  54                                 int rtindex, int sublevels_up,
  55                                 int location, bool include_dropped,
  56                                 List **colnames, List **colvars);
  57 static int      specialAttNum(const char *attname);
  58 static bool isQueryUsingTempRelation_walker(Node *node, void *context);
  59
  60
  61 /*
  62  * refnameRangeTblEntry
  63  *        Given a possibly-qualified refname, look to see if it matches any RTE.
  64  *        If so, return a pointer to the RangeTblEntry; else return NULL.
  65  *
  66  *        Optionally get RTE's nesting depth (0 = current) into *sublevels_up.
  67  *        If sublevels_up is NULL, only consider items at the current nesting
  68  *        level.
  69  *
  70  * An unqualified refname (schemaname == NULL) can match any RTE with matching
  71  * alias, or matching unqualified relname in the case of alias-less relation
  72  * RTEs.  It is possible that such a refname matches multiple RTEs in the
  73  * nearest nesting level that has a match; if so, we report an error via
  74  * ereport().
  75  *
  76  * A qualified refname (schemaname != NULL) can only match a relation RTE
  77  * that (a) has no alias and (b) is for the same relation identified by
  78  * schemaname.refname.  In this case we convert schemaname.refname to a
  79  * relation OID and search by relid, rather than by alias name.  This is
  80  * peculiar, but it's what SQL says to do.
  81  */
  82 RangeTblEntry *
  83 refnameRangeTblEntry(ParseState *pstate,
  84                                          const char *schemaname,
  85                                          const char *refname,
  86                                          int location,
  87                                          int *sublevels_up)
  88 {
  89         Oid                     relId = InvalidOid;
  90
  91         if (sublevels_up)
  92                 *sublevels_up = 0;
  93
  94         if (schemaname != NULL)
  95         {
  96                 Oid                     namespaceId;
  97
  98                 /*
  99                  * We can use LookupNamespaceNoError() here because we are only
 100                  * interested in finding existing RTEs.  Checking USAGE permission on
 101                  * the schema is unnecessary since it would have already been checked
 102                  * when the RTE was made.  Furthermore, we want to report "RTE not
 103                  * found", not "no permissions for schema", if the name happens to
 104                  * match a schema name the user hasn't got access to.
 105                  */
 106                 namespaceId = LookupNamespaceNoError(schemaname);
 107                 if (!OidIsValid(namespaceId))
 108                         return NULL;
 109                 relId = get_relname_relid(refname, namespaceId);
 110                 if (!OidIsValid(relId))
 111                         return NULL;
 112         }
 113
 114         while (pstate != NULL)
 115         {
 116                 RangeTblEntry *result;
 117
 118                 if (OidIsValid(relId))
 119                         result = scanNameSpaceForRelid(pstate, relId, location);
 120                 else
 121                         result = scanNameSpaceForRefname(pstate, refname, location);
 122
 123                 if (result)
 124                         return result;
 125
 126                 if (sublevels_up)
 127                         (*sublevels_up)++;
 128                 else
 129                         break;
 130
 131                 pstate = pstate->parentParseState;
 132         }
 133         return NULL;
 134 }
 135
 136 /*
 137  * Search the query's table namespace for an RTE matching the
 138  * given unqualified refname.  Return the RTE if a unique match, or NULL
 139  * if no match.  Raise error if multiple matches.
 140  *
 141  * Note: it might seem that we shouldn't have to worry about the possibility
 142  * of multiple matches; after all, the SQL standard disallows duplicate table
 143  * aliases within a given SELECT level.  Historically, however, Postgres has
 144  * been laxer than that.  For example, we allow
 145  *              SELECT ... FROM tab1 x CROSS JOIN (tab2 x CROSS JOIN tab3 y) z
 146  * on the grounds that the aliased join (z) hides the aliases within it,
 147  * therefore there is no conflict between the two RTEs named "x".  However,
 148  * if tab3 is a LATERAL subquery, then from within the subquery both "x"es
 149  * are visible.  Rather than rejecting queries that used to work, we allow
 150  * this situation, and complain only if there's actually an ambiguous
 151  * reference to "x".
 152  */
 153 static RangeTblEntry *
 154 scanNameSpaceForRefname(ParseState *pstate, const char *refname, int location)
 155 {
 156         RangeTblEntry *result = NULL;
 157         ListCell   *l;
 158
 159         foreach(l, pstate->p_namespace)
 160         {
 161                 ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
 162                 RangeTblEntry *rte = nsitem->p_rte;
 163
 164                 /* Ignore columns-only items */
 165                 if (!nsitem->p_rel_visible)
 166                         continue;
 167                 /* If not inside LATERAL, ignore lateral-only items */
 168                 if (nsitem->p_lateral_only && !pstate->p_lateral_active)
 169                         continue;
 170
 171                 if (strcmp(rte->eref->aliasname, refname) == 0)
 172                 {
 173                         if (result)
 174                                 ereport(ERROR,
 175                                                 (errcode(ERRCODE_AMBIGUOUS_ALIAS),
 176                                                  errmsg("table reference \"%s\" is ambiguous",
 177                                                                 refname),
 178                                                  parser_errposition(pstate, location)));
 179                         check_lateral_ref_ok(pstate, nsitem, location);
 180                         result = rte;
 181                 }
 182         }
 183         return result;
 184 }
 185
 186 /*
 187  * Search the query's table namespace for a relation RTE matching the
 188  * given relation OID.  Return the RTE if a unique match, or NULL
 189  * if no match.  Raise error if multiple matches.
 190  *
 191  * See the comments for refnameRangeTblEntry to understand why this
 192  * acts the way it does.
 193  */
 194 static RangeTblEntry *
 195 scanNameSpaceForRelid(ParseState *pstate, Oid relid, int location)
 196 {
 197         RangeTblEntry *result = NULL;
 198         ListCell   *l;
 199
 200         foreach(l, pstate->p_namespace)
 201         {
 202                 ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
 203                 RangeTblEntry *rte = nsitem->p_rte;
 204
 205                 /* Ignore columns-only items */
 206                 if (!nsitem->p_rel_visible)
 207                         continue;
 208                 /* If not inside LATERAL, ignore lateral-only items */
 209                 if (nsitem->p_lateral_only && !pstate->p_lateral_active)
 210                         continue;
 211
 212                 /* yes, the test for alias == NULL should be there... */
 213                 if (rte->rtekind == RTE_RELATION &&
 214                         rte->relid == relid &&
 215                         rte->alias == NULL)
 216                 {
 217                         if (result)
 218                                 ereport(ERROR,
 219                                                 (errcode(ERRCODE_AMBIGUOUS_ALIAS),
 220                                                  errmsg("table reference %u is ambiguous",
 221                                                                 relid),
 222                                                  parser_errposition(pstate, location)));
 223                         check_lateral_ref_ok(pstate, nsitem, location);
 224                         result = rte;
 225                 }
 226         }
 227         return result;
 228 }
 229
 230 /*
 231  * Search the query's CTE namespace for a CTE matching the given unqualified
 232  * refname.  Return the CTE (and its levelsup count) if a match, or NULL
 233  * if no match.  We need not worry about multiple matches, since parse_cte.c
 234  * rejects WITH lists containing duplicate CTE names.
 235  */
 236 CommonTableExpr *
 237 scanNameSpaceForCTE(ParseState *pstate, const char *refname,
 238                                         Index *ctelevelsup)
 239 {
 240         Index           levelsup;
 241
 242         for (levelsup = 0;
 243                  pstate != NULL;
 244                  pstate = pstate->parentParseState, levelsup++)
 245         {
 246                 ListCell   *lc;
 247
 248                 foreach(lc, pstate->p_ctenamespace)
 249                 {
 250                         CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 251
 252                         if (strcmp(cte->ctename, refname) == 0)
 253                         {
 254                                 *ctelevelsup = levelsup;
 255                                 return cte;
 256                         }
 257                 }
 258         }
 259         return NULL;
 260 }
 261
 262 /*
 263  * Search for a possible "future CTE", that is one that is not yet in scope
 264  * according to the WITH scoping rules.  This has nothing to do with valid
 265  * SQL semantics, but it's important for error reporting purposes.
 266  */
 267 static bool
 268 isFutureCTE(ParseState *pstate, const char *refname)
 269 {
 270         for (; pstate != NULL; pstate = pstate->parentParseState)
 271         {
 272                 ListCell   *lc;
 273
 274                 foreach(lc, pstate->p_future_ctes)
 275                 {
 276                         CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 277
 278                         if (strcmp(cte->ctename, refname) == 0)
 279                                 return true;
 280                 }
 281         }
 282         return false;
 283 }
 284
 285 /*
 286  * Search the query's ephemeral named relation namespace for a relation
 287  * matching the given unqualified refname.
 288  */
 289 bool
 290 scanNameSpaceForENR(ParseState *pstate, const char *refname)
 291 {
 292         return name_matches_visible_ENR(pstate, refname);
 293 }
 294
 295 /*
 296  * searchRangeTableForRel
 297  *        See if any RangeTblEntry could possibly match the RangeVar.
 298  *        If so, return a pointer to the RangeTblEntry; else return NULL.
 299  *
 300  * This is different from refnameRangeTblEntry in that it considers every
 301  * entry in the ParseState's rangetable(s), not only those that are currently
 302  * visible in the p_namespace list(s).  This behavior is invalid per the SQL
 303  * spec, and it may give ambiguous results (there might be multiple equally
 304  * valid matches, but only one will be returned).  This must be used ONLY
 305  * as a heuristic in giving suitable error messages.  See errorMissingRTE.
 306  *
 307  * Notice that we consider both matches on actual relation (or CTE) name
 308  * and matches on alias.
 309  */
 310 static RangeTblEntry *
 311 searchRangeTableForRel(ParseState *pstate, RangeVar *relation)
 312 {
 313         const char *refname = relation->relname;
 314         Oid                     relId = InvalidOid;
 315         CommonTableExpr *cte = NULL;
 316         bool            isenr = false;
 317         Index           ctelevelsup = 0;
 318         Index           levelsup;
 319
 320         /*
 321          * If it's an unqualified name, check for possible CTE matches. A CTE
 322          * hides any real relation matches.  If no CTE, look for a matching
 323          * relation.
 324          *
 325          * NB: It's not critical that RangeVarGetRelid return the correct answer
 326          * here in the face of concurrent DDL.  If it doesn't, the worst case
 327          * scenario is a less-clear error message.  Also, the tables involved in
 328          * the query are already locked, which reduces the number of cases in
 329          * which surprising behavior can occur.  So we do the name lookup
 330          * unlocked.
 331          */
 332         if (!relation->schemaname)
 333         {
 334                 cte = scanNameSpaceForCTE(pstate, refname, &ctelevelsup);
 335                 if (!cte)
 336                         isenr = scanNameSpaceForENR(pstate, refname);
 337         }
 338
 339         if (!cte && !isenr)
 340                 relId = RangeVarGetRelid(relation, NoLock, true);
 341
 342         /* Now look for RTEs matching either the relation/CTE/ENR or the alias */
 343         for (levelsup = 0;
 344                  pstate != NULL;
 345                  pstate = pstate->parentParseState, levelsup++)
 346         {
 347                 ListCell   *l;
 348
 349                 foreach(l, pstate->p_rtable)
 350                 {
 351                         RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
 352
 353                         if (rte->rtekind == RTE_RELATION &&
 354                                 OidIsValid(relId) &&
 355                                 rte->relid == relId)
 356                                 return rte;
 357                         if (rte->rtekind == RTE_CTE &&
 358                                 cte != NULL &&
 359                                 rte->ctelevelsup + levelsup == ctelevelsup &&
 360                                 strcmp(rte->ctename, refname) == 0)
 361                                 return rte;
 362                         if (rte->rtekind == RTE_NAMEDTUPLESTORE &&
 363                                 isenr &&
 364                                 strcmp(rte->enrname, refname) == 0)
 365                                 return rte;
 366                         if (strcmp(rte->eref->aliasname, refname) == 0)
 367                                 return rte;
 368                 }
 369         }
 370         return NULL;
 371 }
 372
 373 /*
 374  * Check for relation-name conflicts between two namespace lists.
 375  * Raise an error if any is found.
 376  *
 377  * Note: we assume that each given argument does not contain conflicts
 378  * itself; we just want to know if the two can be merged together.
 379  *
 380  * Per SQL, two alias-less plain relation RTEs do not conflict even if
 381  * they have the same eref->aliasname (ie, same relation name), if they
 382  * are for different relation OIDs (implying they are in different schemas).
 383  *
 384  * We ignore the lateral-only flags in the namespace items: the lists must
 385  * not conflict, even when all items are considered visible.  However,
 386  * columns-only items should be ignored.
 387  */
 388 void
 389 checkNameSpaceConflicts(ParseState *pstate, List *namespace1,
 390                                                 List *namespace2)
 391 {
 392         ListCell   *l1;
 393
 394         foreach(l1, namespace1)
 395         {
 396                 ParseNamespaceItem *nsitem1 = (ParseNamespaceItem *) lfirst(l1);
 397                 RangeTblEntry *rte1 = nsitem1->p_rte;
 398                 const char *aliasname1 = rte1->eref->aliasname;
 399                 ListCell   *l2;
 400
 401                 if (!nsitem1->p_rel_visible)
 402                         continue;
 403
 404                 foreach(l2, namespace2)
 405                 {
 406                         ParseNamespaceItem *nsitem2 = (ParseNamespaceItem *) lfirst(l2);
 407                         RangeTblEntry *rte2 = nsitem2->p_rte;
 408
 409                         if (!nsitem2->p_rel_visible)
 410                                 continue;
 411                         if (strcmp(rte2->eref->aliasname, aliasname1) != 0)
 412                                 continue;               /* definitely no conflict */
 413                         if (rte1->rtekind == RTE_RELATION && rte1->alias == NULL &&
 414                                 rte2->rtekind == RTE_RELATION && rte2->alias == NULL &&
 415                                 rte1->relid != rte2->relid)
 416                                 continue;               /* no conflict per SQL rule */
 417                         ereport(ERROR,
 418                                         (errcode(ERRCODE_DUPLICATE_ALIAS),
 419                                          errmsg("table name \"%s\" specified more than once",
 420                                                         aliasname1)));
 421                 }
 422         }
 423 }
 424
 425 /*
 426  * Complain if a namespace item is currently disallowed as a LATERAL reference.
 427  * This enforces both SQL:2008's rather odd idea of what to do with a LATERAL
 428  * reference to the wrong side of an outer join, and our own prohibition on
 429  * referencing the target table of an UPDATE or DELETE as a lateral reference
 430  * in a FROM/USING clause.
 431  *
 432  * Convenience subroutine to avoid multiple copies of a rather ugly ereport.
 433  */
 434 static void
 435 check_lateral_ref_ok(ParseState *pstate, ParseNamespaceItem *nsitem,
 436                                          int location)
 437 {
 438         if (nsitem->p_lateral_only && !nsitem->p_lateral_ok)
 439         {
 440                 /* SQL:2008 demands this be an error, not an invisible item */
 441                 RangeTblEntry *rte = nsitem->p_rte;
 442                 char       *refname = rte->eref->aliasname;
 443
 444                 ereport(ERROR,
 445                                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
 446                                  errmsg("invalid reference to FROM-clause entry for table \"%s\"",
 447                                                 refname),
 448                                  (rte == pstate->p_target_rangetblentry) ?
 449                                  errhint("There is an entry for table \"%s\", but it cannot be referenced from this part of the query.",
 450                                                  refname) :
 451                                  errdetail("The combining JOIN type must be INNER or LEFT for a LATERAL reference."),
 452                                  parser_errposition(pstate, location)));
 453         }
 454 }
 455
 456 /*
 457  * given an RTE, return RT index (starting with 1) of the entry,
 458  * and optionally get its nesting depth (0 = current).  If sublevels_up
 459  * is NULL, only consider rels at the current nesting level.
 460  * Raises error if RTE not found.
 461  */
 462 int
 463 RTERangeTablePosn(ParseState *pstate, RangeTblEntry *rte, int *sublevels_up)
 464 {
 465         int                     index;
 466         ListCell   *l;
 467
 468         if (sublevels_up)
 469                 *sublevels_up = 0;
 470
 471         while (pstate != NULL)
 472         {
 473                 index = 1;
 474                 foreach(l, pstate->p_rtable)
 475                 {
 476                         if (rte == (RangeTblEntry *) lfirst(l))
 477                                 return index;
 478                         index++;
 479                 }
 480                 pstate = pstate->parentParseState;
 481                 if (sublevels_up)
 482                         (*sublevels_up)++;
 483                 else
 484                         break;
 485         }
 486
 487         elog(ERROR, "RTE not found (internal error)");
 488         return 0;                                       /* keep compiler quiet */
 489 }
 490
 491 /*
 492  * Given an RT index and nesting depth, find the corresponding RTE.
 493  * This is the inverse of RTERangeTablePosn.
 494  */
 495 RangeTblEntry *
 496 GetRTEByRangeTablePosn(ParseState *pstate,
 497                                            int varno,
 498                                            int sublevels_up)
 499 {
 500         while (sublevels_up-- > 0)
 501         {
 502                 pstate = pstate->parentParseState;
 503                 Assert(pstate != NULL);
 504         }
 505         Assert(varno > 0 && varno <= list_length(pstate->p_rtable));
 506         return rt_fetch(varno, pstate->p_rtable);
 507 }
 508
 509 /*
 510  * Fetch the CTE for a CTE-reference RTE.
 511  *
 512  * rtelevelsup is the number of query levels above the given pstate that the
 513  * RTE came from.  Callers that don't have this information readily available
 514  * may pass -1 instead.
 515  */
 516 CommonTableExpr *
 517 GetCTEForRTE(ParseState *pstate, RangeTblEntry *rte, int rtelevelsup)
 518 {
 519         Index           levelsup;
 520         ListCell   *lc;
 521
 522         /* Determine RTE's levelsup if caller didn't know it */
 523         if (rtelevelsup < 0)
 524                 (void) RTERangeTablePosn(pstate, rte, &rtelevelsup);
 525
 526         Assert(rte->rtekind == RTE_CTE);
 527         levelsup = rte->ctelevelsup + rtelevelsup;
 528         while (levelsup-- > 0)
 529         {
 530                 pstate = pstate->parentParseState;
 531                 if (!pstate)                    /* shouldn't happen */
 532                         elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
 533         }
 534         foreach(lc, pstate->p_ctenamespace)
 535         {
 536                 CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 537
 538                 if (strcmp(cte->ctename, rte->ctename) == 0)
 539                         return cte;
 540         }
 541         /* shouldn't happen */
 542         elog(ERROR, "could not find CTE \"%s\"", rte->ctename);
 543         return NULL;                            /* keep compiler quiet */
 544 }
 545
 546 /*
 547  * updateFuzzyAttrMatchState
 548  *        Using Levenshtein distance, consider if column is best fuzzy match.
 549  */
 550 static void
 551 updateFuzzyAttrMatchState(int fuzzy_rte_penalty,
 552                                                   FuzzyAttrMatchState *fuzzystate, RangeTblEntry *rte,
 553                                                   const char *actual, const char *match, int attnum)
 554 {
 555         int                     columndistance;
 556         int                     matchlen;
 557
 558         /* Bail before computing the Levenshtein distance if there's no hope. */
 559         if (fuzzy_rte_penalty > fuzzystate->distance)
 560                 return;
 561
 562         /*
 563          * Outright reject dropped columns, which can appear here with apparent
 564          * empty actual names, per remarks within scanRTEForColumn().
 565          */
 566         if (actual[0] == '\0')
 567                 return;
 568
 569         /* Use Levenshtein to compute match distance. */
 570         matchlen = strlen(match);
 571         columndistance =
 572                 varstr_levenshtein_less_equal(actual, strlen(actual), match, matchlen,
 573                                                                           1, 1, 1,
 574                                                                           fuzzystate->distance + 1
 575                                                                           - fuzzy_rte_penalty,
 576                                                                           true);
 577
 578         /*
 579          * If more than half the characters are different, don't treat it as a
 580          * match, to avoid making ridiculous suggestions.
 581          */
 582         if (columndistance > matchlen / 2)
 583                 return;
 584
 585         /*
 586          * From this point on, we can ignore the distinction between the RTE-name
 587          * distance and the column-name distance.
 588          */
 589         columndistance += fuzzy_rte_penalty;
 590
 591         /*
 592          * If the new distance is less than or equal to that of the best match
 593          * found so far, update fuzzystate.
 594          */
 595         if (columndistance < fuzzystate->distance)
 596         {
 597                 /* Store new lowest observed distance for RTE */
 598                 fuzzystate->distance = columndistance;
 599                 fuzzystate->rfirst = rte;
 600                 fuzzystate->first = attnum;
 601                 fuzzystate->rsecond = NULL;
 602                 fuzzystate->second = InvalidAttrNumber;
 603         }
 604         else if (columndistance == fuzzystate->distance)
 605         {
 606                 /*
 607                  * This match distance may equal a prior match within this same range
 608                  * table.  When that happens, the prior match may also be given, but
 609                  * only if there is no more than two equally distant matches from the
 610                  * RTE (in turn, our caller will only accept two equally distant
 611                  * matches overall).
 612                  */
 613                 if (AttributeNumberIsValid(fuzzystate->second))
 614                 {
 615                         /* Too many RTE-level matches */
 616                         fuzzystate->rfirst = NULL;
 617                         fuzzystate->first = InvalidAttrNumber;
 618                         fuzzystate->rsecond = NULL;
 619                         fuzzystate->second = InvalidAttrNumber;
 620                         /* Clearly, distance is too low a bar (for *any* RTE) */
 621                         fuzzystate->distance = columndistance - 1;
 622                 }
 623                 else if (AttributeNumberIsValid(fuzzystate->first))
 624                 {
 625                         /* Record as provisional second match for RTE */
 626                         fuzzystate->rsecond = rte;
 627                         fuzzystate->second = attnum;
 628                 }
 629                 else if (fuzzystate->distance <= MAX_FUZZY_DISTANCE)
 630                 {
 631                         /*
 632                          * Record as provisional first match (this can occasionally occur
 633                          * because previous lowest distance was "too low a bar", rather
 634                          * than being associated with a real match)
 635                          */
 636                         fuzzystate->rfirst = rte;
 637                         fuzzystate->first = attnum;
 638                 }
 639         }
 640 }
 641
 642 /*
 643  * scanRTEForColumn
 644  *        Search the column names of a single RTE for the given name.
 645  *        If found, return an appropriate Var node, else return NULL.
 646  *        If the name proves ambiguous within this RTE, raise error.
 647  *
 648  * Side effect: if we find a match, mark the RTE as requiring read access
 649  * for the column.
 650  *
 651  * Additional side effect: if fuzzystate is non-NULL, check non-system columns
 652  * for an approximate match and update fuzzystate accordingly.
 653  */
 654 Node *
 655 scanRTEForColumn(ParseState *pstate, RangeTblEntry *rte, char *colname,
 656                                  int location, int fuzzy_rte_penalty,
 657                                  FuzzyAttrMatchState *fuzzystate)
 658 {
 659         Node       *result = NULL;
 660         int                     attnum = 0;
 661         Var                *var;
 662         ListCell   *c;
 663
 664         /*
 665          * Scan the user column names (or aliases) for a match. Complain if
 666          * multiple matches.
 667          *
 668          * Note: eref->colnames may include entries for dropped columns, but those
 669          * will be empty strings that cannot match any legal SQL identifier, so we
 670          * don't bother to test for that case here.
 671          *
 672          * Should this somehow go wrong and we try to access a dropped column,
 673          * we'll still catch it by virtue of the checks in
 674          * get_rte_attribute_type(), which is called by make_var().  That routine
 675          * has to do a cache lookup anyway, so the check there is cheap.  Callers
 676          * interested in finding match with shortest distance need to defend
 677          * against this directly, though.
 678          */
 679         foreach(c, rte->eref->colnames)
 680         {
 681                 const char *attcolname = strVal(lfirst(c));
 682
 683                 attnum++;
 684                 if (strcmp(attcolname, colname) == 0)
 685                 {
 686                         if (result)
 687                                 ereport(ERROR,
 688                                                 (errcode(ERRCODE_AMBIGUOUS_COLUMN),
 689                                                  errmsg("column reference \"%s\" is ambiguous",
 690                                                                 colname),
 691                                                  parser_errposition(pstate, location)));
 692                         var = make_var(pstate, rte, attnum, location);
 693                         /* Require read access to the column */
 694                         markVarForSelectPriv(pstate, var, rte);
 695                         result = (Node *) var;
 696                 }
 697
 698                 /* Updating fuzzy match state, if provided. */
 699                 if (fuzzystate != NULL)
 700                         updateFuzzyAttrMatchState(fuzzy_rte_penalty, fuzzystate,
 701                                                                           rte, attcolname, colname, attnum);
 702         }
 703
 704         /*
 705          * If we have a unique match, return it.  Note that this allows a user
 706          * alias to override a system column name (such as OID) without error.
 707          */
 708         if (result)
 709                 return result;
 710
 711         /*
 712          * If the RTE represents a real relation, consider system column names.
 713          * Composites are only used for pseudo-relations like ON CONFLICT's
 714          * excluded.
 715          */
 716         if (rte->rtekind == RTE_RELATION &&
 717                 rte->relkind != RELKIND_COMPOSITE_TYPE)
 718         {
 719                 /* quick check to see if name could be a system column */
 720                 attnum = specialAttNum(colname);
 721
 722                 /* In constraint check, no system column is allowed except tableOid */
 723                 if (pstate->p_expr_kind == EXPR_KIND_CHECK_CONSTRAINT &&
 724                         attnum < InvalidAttrNumber && attnum != TableOidAttributeNumber)
 725                         ereport(ERROR,
 726                                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
 727                                          errmsg("system column \"%s\" reference in check constraint is invalid",
 728                                                         colname),
 729                                          parser_errposition(pstate, location)));
 730
 731                 if (attnum != InvalidAttrNumber)
 732                 {
 733                         /* now check to see if column actually is defined */
 734                         if (SearchSysCacheExists2(ATTNUM,
 735                                                                           ObjectIdGetDatum(rte->relid),
 736                                                                           Int16GetDatum(attnum)))
 737                         {
 738                                 var = make_var(pstate, rte, attnum, location);
 739                                 /* Require read access to the column */
 740                                 markVarForSelectPriv(pstate, var, rte);
 741                                 result = (Node *) var;
 742                         }
 743                 }
 744         }
 745
 746         return result;
 747 }
 748
 749 /*
 750  * colNameToVar
 751  *        Search for an unqualified column name.
 752  *        If found, return the appropriate Var node (or expression).
 753  *        If not found, return NULL.  If the name proves ambiguous, raise error.
 754  *        If localonly is true, only names in the innermost query are considered.
 755  */
 756 Node *
 757 colNameToVar(ParseState *pstate, char *colname, bool localonly,
 758                          int location)
 759 {
 760         Node       *result = NULL;
 761         ParseState *orig_pstate = pstate;
 762
 763         while (pstate != NULL)
 764         {
 765                 ListCell   *l;
 766
 767                 foreach(l, pstate->p_namespace)
 768                 {
 769                         ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
 770                         RangeTblEntry *rte = nsitem->p_rte;
 771                         Node       *newresult;
 772
 773                         /* Ignore table-only items */
 774                         if (!nsitem->p_cols_visible)
 775                                 continue;
 776                         /* If not inside LATERAL, ignore lateral-only items */
 777                         if (nsitem->p_lateral_only && !pstate->p_lateral_active)
 778                                 continue;
 779
 780                         /* use orig_pstate here to get the right sublevels_up */
 781                         newresult = scanRTEForColumn(orig_pstate, rte, colname, location,
 782                                                                                  0, NULL);
 783
 784                         if (newresult)
 785                         {
 786                                 if (result)
 787                                         ereport(ERROR,
 788                                                         (errcode(ERRCODE_AMBIGUOUS_COLUMN),
 789                                                          errmsg("column reference \"%s\" is ambiguous",
 790                                                                         colname),
 791                                                          parser_errposition(pstate, location)));
 792                                 check_lateral_ref_ok(pstate, nsitem, location);
 793                                 result = newresult;
 794                         }
 795                 }
 796
 797                 if (result != NULL || localonly)
 798                         break;                          /* found, or don't want to look at parent */
 799
 800                 pstate = pstate->parentParseState;
 801         }
 802
 803         return result;
 804 }
 805
 806 /*
 807  * searchRangeTableForCol
 808  *        See if any RangeTblEntry could possibly provide the given column name (or
 809  *        find the best match available).  Returns state with relevant details.
 810  *
 811  * This is different from colNameToVar in that it considers every entry in
 812  * the ParseState's rangetable(s), not only those that are currently visible
 813  * in the p_namespace list(s).  This behavior is invalid per the SQL spec,
 814  * and it may give ambiguous results (there might be multiple equally valid
 815  * matches, but only one will be returned).  This must be used ONLY as a
 816  * heuristic in giving suitable error messages.  See errorMissingColumn.
 817  *
 818  * This function is also different in that it will consider approximate
 819  * matches -- if the user entered an alias/column pair that is only slightly
 820  * different from a valid pair, we may be able to infer what they meant to
 821  * type and provide a reasonable hint.
 822  *
 823  * The FuzzyAttrMatchState will have 'rfirst' pointing to the best RTE
 824  * containing the most promising match for the alias and column name.  If
 825  * the alias and column names match exactly, 'first' will be InvalidAttrNumber;
 826  * otherwise, it will be the attribute number for the match.  In the latter
 827  * case, 'rsecond' may point to a second, equally close approximate match,
 828  * and 'second' will contain the attribute number for the second match.
 829  */
 830 static FuzzyAttrMatchState *
 831 searchRangeTableForCol(ParseState *pstate, const char *alias, char *colname,
 832                                            int location)
 833 {
 834         ParseState *orig_pstate = pstate;
 835         FuzzyAttrMatchState *fuzzystate = palloc(sizeof(FuzzyAttrMatchState));
 836
 837         fuzzystate->distance = MAX_FUZZY_DISTANCE + 1;
 838         fuzzystate->rfirst = NULL;
 839         fuzzystate->rsecond = NULL;
 840         fuzzystate->first = InvalidAttrNumber;
 841         fuzzystate->second = InvalidAttrNumber;
 842
 843         while (pstate != NULL)
 844         {
 845                 ListCell   *l;
 846
 847                 foreach(l, pstate->p_rtable)
 848                 {
 849                         RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
 850                         int                     fuzzy_rte_penalty = 0;
 851
 852                         /*
 853                          * Typically, it is not useful to look for matches within join
 854                          * RTEs; they effectively duplicate other RTEs for our purposes,
 855                          * and if a match is chosen from a join RTE, an unhelpful alias is
 856                          * displayed in the final diagnostic message.
 857                          */
 858                         if (rte->rtekind == RTE_JOIN)
 859                                 continue;
 860
 861                         /*
 862                          * If the user didn't specify an alias, then matches against one
 863                          * RTE are as good as another.  But if the user did specify an
 864                          * alias, then we want at least a fuzzy - and preferably an exact
 865                          * - match for the range table entry.
 866                          */
 867                         if (alias != NULL)
 868                                 fuzzy_rte_penalty =
 869                                         varstr_levenshtein_less_equal(alias, strlen(alias),
 870                                                                                                   rte->eref->aliasname,
 871                                                                                                   strlen(rte->eref->aliasname),
 872                                                                                                   1, 1, 1,
 873                                                                                                   MAX_FUZZY_DISTANCE + 1,
 874                                                                                                   true);
 875
 876                         /*
 877                          * Scan for a matching column; if we find an exact match, we're
 878                          * done.  Otherwise, update fuzzystate.
 879                          */
 880                         if (scanRTEForColumn(orig_pstate, rte, colname, location,
 881                                                                  fuzzy_rte_penalty, fuzzystate)
 882                                 && fuzzy_rte_penalty == 0)
 883                         {
 884                                 fuzzystate->rfirst = rte;
 885                                 fuzzystate->first = InvalidAttrNumber;
 886                                 fuzzystate->rsecond = NULL;
 887                                 fuzzystate->second = InvalidAttrNumber;
 888                                 return fuzzystate;
 889                         }
 890                 }
 891
 892                 pstate = pstate->parentParseState;
 893         }
 894
 895         return fuzzystate;
 896 }
 897
 898 /*
 899  * markRTEForSelectPriv
 900  *         Mark the specified column of an RTE as requiring SELECT privilege
 901  *
 902  * col == InvalidAttrNumber means a "whole row" reference
 903  *
 904  * The caller should pass the actual RTE if it has it handy; otherwise pass
 905  * NULL, and we'll look it up here.  (This uglification of the API is
 906  * worthwhile because nearly all external callers have the RTE at hand.)
 907  */
 908 static void
 909 markRTEForSelectPriv(ParseState *pstate, RangeTblEntry *rte,
 910                                          int rtindex, AttrNumber col)
 911 {
 912         if (rte == NULL)
 913                 rte = rt_fetch(rtindex, pstate->p_rtable);
 914
 915         if (rte->rtekind == RTE_RELATION)
 916         {
 917                 /* Make sure the rel as a whole is marked for SELECT access */
 918                 rte->requiredPerms |= ACL_SELECT;
 919                 /* Must offset the attnum to fit in a bitmapset */
 920                 rte->selectedCols = bms_add_member(rte->selectedCols,
 921                                                                                    col - FirstLowInvalidHeapAttributeNumber);
 922         }
 923         else if (rte->rtekind == RTE_JOIN)
 924         {
 925                 if (col == InvalidAttrNumber)
 926                 {
 927                         /*
 928                          * A whole-row reference to a join has to be treated as whole-row
 929                          * references to the two inputs.
 930                          */
 931                         JoinExpr   *j;
 932
 933                         if (rtindex > 0 && rtindex <= list_length(pstate->p_joinexprs))
 934                                 j = list_nth_node(JoinExpr, pstate->p_joinexprs, rtindex - 1);
 935                         else
 936                                 j = NULL;
 937                         if (j == NULL)
 938                                 elog(ERROR, "could not find JoinExpr for whole-row reference");
 939
 940                         /* Note: we can't see FromExpr here */
 941                         if (IsA(j->larg, RangeTblRef))
 942                         {
 943                                 int                     varno = ((RangeTblRef *) j->larg)->rtindex;
 944
 945                                 markRTEForSelectPriv(pstate, NULL, varno, InvalidAttrNumber);
 946                         }
 947                         else if (IsA(j->larg, JoinExpr))
 948                         {
 949                                 int                     varno = ((JoinExpr *) j->larg)->rtindex;
 950
 951                                 markRTEForSelectPriv(pstate, NULL, varno, InvalidAttrNumber);
 952                         }
 953                         else
 954                                 elog(ERROR, "unrecognized node type: %d",
 955                                          (int) nodeTag(j->larg));
 956                         if (IsA(j->rarg, RangeTblRef))
 957                         {
 958                                 int                     varno = ((RangeTblRef *) j->rarg)->rtindex;
 959
 960                                 markRTEForSelectPriv(pstate, NULL, varno, InvalidAttrNumber);
 961                         }
 962                         else if (IsA(j->rarg, JoinExpr))
 963                         {
 964                                 int                     varno = ((JoinExpr *) j->rarg)->rtindex;
 965
 966                                 markRTEForSelectPriv(pstate, NULL, varno, InvalidAttrNumber);
 967                         }
 968                         else
 969                                 elog(ERROR, "unrecognized node type: %d",
 970                                          (int) nodeTag(j->rarg));
 971                 }
 972                 else
 973                 {
 974                         /*
 975                          * Regular join attribute, look at the alias-variable list.
 976                          *
 977                          * The aliasvar could be either a Var or a COALESCE expression,
 978                          * but in the latter case we should already have marked the two
 979                          * referent variables as being selected, due to their use in the
 980                          * JOIN clause.  So we need only be concerned with the Var case.
 981                          * But we do need to drill down through implicit coercions.
 982                          */
 983                         Var                *aliasvar;
 984
 985                         Assert(col > 0 && col <= list_length(rte->joinaliasvars));
 986                         aliasvar = (Var *) list_nth(rte->joinaliasvars, col - 1);
 987                         aliasvar = (Var *) strip_implicit_coercions((Node *) aliasvar);
 988                         if (aliasvar && IsA(aliasvar, Var))
 989                                 markVarForSelectPriv(pstate, aliasvar, NULL);
 990                 }
 991         }
 992         /* other RTE types don't require privilege marking */
 993 }
 994
 995 /*
 996  * markVarForSelectPriv
 997  *         Mark the RTE referenced by a Var as requiring SELECT privilege
 998  *
 999  * The caller should pass the Var's referenced RTE if it has it handy
1000  * (nearly all do); otherwise pass NULL.
1001  */
1002 void
1003 markVarForSelectPriv(ParseState *pstate, Var *var, RangeTblEntry *rte)
1004 {
1005         Index           lv;
1006
1007         Assert(IsA(var, Var));
1008         /* Find the appropriate pstate if it's an uplevel Var */
1009         for (lv = 0; lv < var->varlevelsup; lv++)
1010                 pstate = pstate->parentParseState;
1011         markRTEForSelectPriv(pstate, rte, var->varno, var->varattno);
1012 }
1013
1014 /*
1015  * buildRelationAliases
1016  *              Construct the eref column name list for a relation RTE.
1017  *              This code is also used for function RTEs.
1018  *
1019  * tupdesc: the physical column information
1020  * alias: the user-supplied alias, or NULL if none
1021  * eref: the eref Alias to store column names in
1022  *
1023  * eref->colnames is filled in.  Also, alias->colnames is rebuilt to insert
1024  * empty strings for any dropped columns, so that it will be one-to-one with
1025  * physical column numbers.
1026  *
1027  * It is an error for there to be more aliases present than required.
1028  */
1029 static void
1030 buildRelationAliases(TupleDesc tupdesc, Alias *alias, Alias *eref)
1031 {
1032         int                     maxattrs = tupdesc->natts;
1033         ListCell   *aliaslc;
1034         int                     numaliases;
1035         int                     varattno;
1036         int                     numdropped = 0;
1037
1038         Assert(eref->colnames == NIL);
1039
1040         if (alias)
1041         {
1042                 aliaslc = list_head(alias->colnames);
1043                 numaliases = list_length(alias->colnames);
1044                 /* We'll rebuild the alias colname list */
1045                 alias->colnames = NIL;
1046         }
1047         else
1048         {
1049                 aliaslc = NULL;
1050                 numaliases = 0;
1051         }
1052
1053         for (varattno = 0; varattno < maxattrs; varattno++)
1054         {
1055                 Form_pg_attribute attr = TupleDescAttr(tupdesc, varattno);
1056                 Value      *attrname;
1057
1058                 if (attr->attisdropped)
1059                 {
1060                         /* Always insert an empty string for a dropped column */
1061                         attrname = makeString(pstrdup(""));
1062                         if (aliaslc)
1063                                 alias->colnames = lappend(alias->colnames, attrname);
1064                         numdropped++;
1065                 }
1066                 else if (aliaslc)
1067                 {
1068                         /* Use the next user-supplied alias */
1069                         attrname = (Value *) lfirst(aliaslc);
1070                         aliaslc = lnext(aliaslc);
1071                         alias->colnames = lappend(alias->colnames, attrname);
1072                 }
1073                 else
1074                 {
1075                         attrname = makeString(pstrdup(NameStr(attr->attname)));
1076                         /* we're done with the alias if any */
1077                 }
1078
1079                 eref->colnames = lappend(eref->colnames, attrname);
1080         }
1081
1082         /* Too many user-supplied aliases? */
1083         if (aliaslc)
1084                 ereport(ERROR,
1085                                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1086                                  errmsg("table \"%s\" has %d columns available but %d columns specified",
1087                                                 eref->aliasname, maxattrs - numdropped, numaliases)));
1088 }
1089
1090 /*
1091  * chooseScalarFunctionAlias
1092  *              Select the column alias for a function in a function RTE,
1093  *              when the function returns a scalar type (not composite or RECORD).
1094  *
1095  * funcexpr: transformed expression tree for the function call
1096  * funcname: function name (as determined by FigureColname)
1097  * alias: the user-supplied alias for the RTE, or NULL if none
1098  * nfuncs: the number of functions appearing in the function RTE
1099  *
1100  * Note that the name we choose might be overridden later, if the user-given
1101  * alias includes column alias names.  That's of no concern here.
1102  */
1103 static char *
1104 chooseScalarFunctionAlias(Node *funcexpr, char *funcname,
1105                                                   Alias *alias, int nfuncs)
1106 {
1107         char       *pname;
1108
1109         /*
1110          * If the expression is a simple function call, and the function has a
1111          * single OUT parameter that is named, use the parameter's name.
1112          */
1113         if (funcexpr && IsA(funcexpr, FuncExpr))
1114         {
1115                 pname = get_func_result_name(((FuncExpr *) funcexpr)->funcid);
1116                 if (pname)
1117                         return pname;
1118         }
1119
1120         /*
1121          * If there's just one function in the RTE, and the user gave an RTE alias
1122          * name, use that name.  (This makes FROM func() AS foo use "foo" as the
1123          * column name as well as the table alias.)
1124          */
1125         if (nfuncs == 1 && alias)
1126                 return alias->aliasname;
1127
1128         /*
1129          * Otherwise use the function name.
1130          */
1131         return funcname;
1132 }
1133
1134 /*
1135  * Open a table during parse analysis
1136  *
1137  * This is essentially just the same as heap_openrv(), except that it caters
1138  * to some parser-specific error reporting needs, notably that it arranges
1139  * to include the RangeVar's parse location in any resulting error.
1140  *
1141  * Note: properly, lockmode should be declared LOCKMODE not int, but that
1142  * would require importing storage/lock.h into parse_relation.h.  Since
1143  * LOCKMODE is typedef'd as int anyway, that seems like overkill.
1144  */
1145 Relation
1146 parserOpenTable(ParseState *pstate, const RangeVar *relation, int lockmode)
1147 {
1148         Relation        rel;
1149         ParseCallbackState pcbstate;
1150
1151         setup_parser_errposition_callback(&pcbstate, pstate, relation->location);
1152         rel = heap_openrv_extended(relation, lockmode, true);
1153         if (rel == NULL)
1154         {
1155                 if (relation->schemaname)
1156                         ereport(ERROR,
1157                                         (errcode(ERRCODE_UNDEFINED_TABLE),
1158                                          errmsg("relation \"%s.%s\" does not exist",
1159                                                         relation->schemaname, relation->relname)));
1160                 else
1161                 {
1162                         /*
1163                          * An unqualified name might have been meant as a reference to
1164                          * some not-yet-in-scope CTE.  The bare "does not exist" message
1165                          * has proven remarkably unhelpful for figuring out such problems,
1166                          * so we take pains to offer a specific hint.
1167                          */
1168                         if (isFutureCTE(pstate, relation->relname))
1169                                 ereport(ERROR,
1170                                                 (errcode(ERRCODE_UNDEFINED_TABLE),
1171                                                  errmsg("relation \"%s\" does not exist",
1172                                                                 relation->relname),
1173                                                  errdetail("There is a WITH item named \"%s\", but it cannot be referenced from this part of the query.",
1174                                                                    relation->relname),
1175                                                  errhint("Use WITH RECURSIVE, or re-order the WITH items to remove forward references.")));
1176                         else
1177                                 ereport(ERROR,
1178                                                 (errcode(ERRCODE_UNDEFINED_TABLE),
1179                                                  errmsg("relation \"%s\" does not exist",
1180                                                                 relation->relname)));
1181                 }
1182         }
1183         cancel_parser_errposition_callback(&pcbstate);
1184         return rel;
1185 }
1186
1187 /*
1188  * Add an entry for a relation to the pstate's range table (p_rtable).
1189  *
1190  * Note: formerly this checked for refname conflicts, but that's wrong.
1191  * Caller is responsible for checking for conflicts in the appropriate scope.
1192  */
1193 RangeTblEntry *
1194 addRangeTableEntry(ParseState *pstate,
1195                                    RangeVar *relation,
1196                                    Alias *alias,
1197                                    bool inh,
1198                                    bool inFromCl)
1199 {
1200         RangeTblEntry *rte = makeNode(RangeTblEntry);
1201         char       *refname = alias ? alias->aliasname : relation->relname;
1202         LOCKMODE        lockmode;
1203         Relation        rel;
1204
1205         Assert(pstate != NULL);
1206
1207         rte->rtekind = RTE_RELATION;
1208         rte->alias = alias;
1209
1210         /*
1211          * Get the rel's OID.  This access also ensures that we have an up-to-date
1212          * relcache entry for the rel.  Since this is typically the first access
1213          * to a rel in a statement, be careful to get the right access level
1214          * depending on whether we're doing SELECT FOR UPDATE/SHARE.
1215          */
1216         lockmode = isLockedRefname(pstate, refname) ? RowShareLock : AccessShareLock;
1217         rel = parserOpenTable(pstate, relation, lockmode);
1218         rte->relid = RelationGetRelid(rel);
1219         rte->relkind = rel->rd_rel->relkind;
1220
1221         /*
1222          * Build the list of effective column names using user-supplied aliases
1223          * and/or actual column names.
1224          */
1225         rte->eref = makeAlias(refname, NIL);
1226         buildRelationAliases(rel->rd_att, alias, rte->eref);
1227
1228         /*
1229          * Drop the rel refcount, but keep the access lock till end of transaction
1230          * so that the table can't be deleted or have its schema modified
1231          * underneath us.
1232          */
1233         heap_close(rel, NoLock);
1234
1235         /*
1236          * Set flags and access permissions.
1237          *
1238          * The initial default on access checks is always check-for-READ-access,
1239          * which is the right thing for all except target tables.
1240          */
1241         rte->lateral = false;
1242         rte->inh = inh;
1243         rte->inFromCl = inFromCl;
1244
1245         rte->requiredPerms = ACL_SELECT;
1246         rte->checkAsUser = InvalidOid;  /* not set-uid by default, either */
1247         rte->selectedCols = NULL;
1248         rte->insertedCols = NULL;
1249         rte->updatedCols = NULL;
1250
1251         /*
1252          * Add completed RTE to pstate's range table list, but not to join list
1253          * nor namespace --- caller must do that if appropriate.
1254          */
1255         pstate->p_rtable = lappend(pstate->p_rtable, rte);
1256
1257         return rte;
1258 }
1259
1260 /*
1261  * Add an entry for a relation to the pstate's range table (p_rtable).
1262  *
1263  * This is just like addRangeTableEntry() except that it makes an RTE
1264  * given an already-open relation instead of a RangeVar reference.
1265  */
1266 RangeTblEntry *
1267 addRangeTableEntryForRelation(ParseState *pstate,
1268                                                           Relation rel,
1269                                                           Alias *alias,
1270                                                           bool inh,
1271                                                           bool inFromCl)
1272 {
1273         RangeTblEntry *rte = makeNode(RangeTblEntry);
1274         char       *refname = alias ? alias->aliasname : RelationGetRelationName(rel);
1275
1276         Assert(pstate != NULL);
1277
1278         rte->rtekind = RTE_RELATION;
1279         rte->alias = alias;
1280         rte->relid = RelationGetRelid(rel);
1281         rte->relkind = rel->rd_rel->relkind;
1282
1283         /*
1284          * Build the list of effective column names using user-supplied aliases
1285          * and/or actual column names.
1286          */
1287         rte->eref = makeAlias(refname, NIL);
1288         buildRelationAliases(rel->rd_att, alias, rte->eref);
1289
1290         /*
1291          * Set flags and access permissions.
1292          *
1293          * The initial default on access checks is always check-for-READ-access,
1294          * which is the right thing for all except target tables.
1295          */
1296         rte->lateral = false;
1297         rte->inh = inh;
1298         rte->inFromCl = inFromCl;
1299
1300         rte->requiredPerms = ACL_SELECT;
1301         rte->checkAsUser = InvalidOid;  /* not set-uid by default, either */
1302         rte->selectedCols = NULL;
1303         rte->insertedCols = NULL;
1304         rte->updatedCols = NULL;
1305
1306         /*
1307          * Add completed RTE to pstate's range table list, but not to join list
1308          * nor namespace --- caller must do that if appropriate.
1309          */
1310         pstate->p_rtable = lappend(pstate->p_rtable, rte);
1311
1312         return rte;
1313 }
1314
1315 /*
1316  * Add an entry for a subquery to the pstate's range table (p_rtable).
1317  *
1318  * This is just like addRangeTableEntry() except that it makes a subquery RTE.
1319  * Note that an alias clause *must* be supplied.
1320  */
1321 RangeTblEntry *
1322 addRangeTableEntryForSubquery(ParseState *pstate,
1323                                                           Query *subquery,
1324                                                           Alias *alias,
1325                                                           bool lateral,
1326                                                           bool inFromCl)
1327 {
1328         RangeTblEntry *rte = makeNode(RangeTblEntry);
1329         char       *refname = alias->aliasname;
1330         Alias      *eref;
1331         int                     numaliases;
1332         int                     varattno;
1333         ListCell   *tlistitem;
1334
1335         Assert(pstate != NULL);
1336
1337         rte->rtekind = RTE_SUBQUERY;
1338         rte->relid = InvalidOid;
1339         rte->subquery = subquery;
1340         rte->alias = alias;
1341
1342         eref = copyObject(alias);
1343         numaliases = list_length(eref->colnames);
1344
1345         /* fill in any unspecified alias columns */
1346         varattno = 0;
1347         foreach(tlistitem, subquery->targetList)
1348         {
1349                 TargetEntry *te = (TargetEntry *) lfirst(tlistitem);
1350
1351                 if (te->resjunk)
1352                         continue;
1353                 varattno++;
1354                 Assert(varattno == te->resno);
1355                 if (varattno > numaliases)
1356                 {
1357                         char       *attrname;
1358
1359                         attrname = pstrdup(te->resname);
1360                         eref->colnames = lappend(eref->colnames, makeString(attrname));
1361                 }
1362         }
1363         if (varattno < numaliases)
1364                 ereport(ERROR,
1365                                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1366                                  errmsg("table \"%s\" has %d columns available but %d columns specified",
1367                                                 refname, varattno, numaliases)));
1368
1369         rte->eref = eref;
1370
1371         /*
1372          * Set flags and access permissions.
1373          *
1374          * Subqueries are never checked for access rights.
1375          */
1376         rte->lateral = lateral;
1377         rte->inh = false;                       /* never true for subqueries */
1378         rte->inFromCl = inFromCl;
1379
1380         rte->requiredPerms = 0;
1381         rte->checkAsUser = InvalidOid;
1382         rte->selectedCols = NULL;
1383         rte->insertedCols = NULL;
1384         rte->updatedCols = NULL;
1385
1386         /*
1387          * Add completed RTE to pstate's range table list, but not to join list
1388          * nor namespace --- caller must do that if appropriate.
1389          */
1390         pstate->p_rtable = lappend(pstate->p_rtable, rte);
1391
1392         return rte;
1393 }
1394
1395 /*
1396  * Add an entry for a function (or functions) to the pstate's range table
1397  * (p_rtable).
1398  *
1399  * This is just like addRangeTableEntry() except that it makes a function RTE.
1400  */
1401 RangeTblEntry *
1402 addRangeTableEntryForFunction(ParseState *pstate,
1403                                                           List *funcnames,
1404                                                           List *funcexprs,
1405                                                           List *coldeflists,
1406                                                           RangeFunction *rangefunc,
1407                                                           bool lateral,
1408                                                           bool inFromCl)
1409 {
1410         RangeTblEntry *rte = makeNode(RangeTblEntry);
1411         Alias      *alias = rangefunc->alias;
1412         Alias      *eref;
1413         char       *aliasname;
1414         int                     nfuncs = list_length(funcexprs);
1415         TupleDesc  *functupdescs;
1416         TupleDesc       tupdesc;
1417         ListCell   *lc1,
1418                            *lc2,
1419                            *lc3;
1420         int                     i;
1421         int                     j;
1422         int                     funcno;
1423         int                     natts,
1424                                 totalatts;
1425
1426         Assert(pstate != NULL);
1427
1428         rte->rtekind = RTE_FUNCTION;
1429         rte->relid = InvalidOid;
1430         rte->subquery = NULL;
1431         rte->functions = NIL;           /* we'll fill this list below */
1432         rte->funcordinality = rangefunc->ordinality;
1433         rte->alias = alias;
1434
1435         /*
1436          * Choose the RTE alias name.  We default to using the first function's
1437          * name even when there's more than one; which is maybe arguable but beats
1438          * using something constant like "table".
1439          */
1440         if (alias)
1441                 aliasname = alias->aliasname;
1442         else
1443                 aliasname = linitial(funcnames);
1444
1445         eref = makeAlias(aliasname, NIL);
1446         rte->eref = eref;
1447
1448         /* Process each function ... */
1449         functupdescs = (TupleDesc *) palloc(nfuncs * sizeof(TupleDesc));
1450
1451         totalatts = 0;
1452         funcno = 0;
1453         forthree(lc1, funcexprs, lc2, funcnames, lc3, coldeflists)
1454         {
1455                 Node       *funcexpr = (Node *) lfirst(lc1);
1456                 char       *funcname = (char *) lfirst(lc2);
1457                 List       *coldeflist = (List *) lfirst(lc3);
1458                 RangeTblFunction *rtfunc = makeNode(RangeTblFunction);
1459                 TypeFuncClass functypclass;
1460                 Oid                     funcrettype;
1461
1462                 /* Initialize RangeTblFunction node */
1463                 rtfunc->funcexpr = funcexpr;
1464                 rtfunc->funccolnames = NIL;
1465                 rtfunc->funccoltypes = NIL;
1466                 rtfunc->funccoltypmods = NIL;
1467                 rtfunc->funccolcollations = NIL;
1468                 rtfunc->funcparams = NULL;      /* not set until planning */
1469
1470                 /*
1471                  * Now determine if the function returns a simple or composite type.
1472                  */
1473                 functypclass = get_expr_result_type(funcexpr,
1474                                                                                         &funcrettype,
1475                                                                                         &tupdesc);
1476
1477                 /*
1478                  * A coldeflist is required if the function returns RECORD and hasn't
1479                  * got a predetermined record type, and is prohibited otherwise.
1480                  */
1481                 if (coldeflist != NIL)
1482                 {
1483                         if (functypclass != TYPEFUNC_RECORD)
1484                                 ereport(ERROR,
1485                                                 (errcode(ERRCODE_SYNTAX_ERROR),
1486                                                  errmsg("a column definition list is only allowed for functions returning \"record\""),
1487                                                  parser_errposition(pstate,
1488                                                                                         exprLocation((Node *) coldeflist))));
1489                 }
1490                 else
1491                 {
1492                         if (functypclass == TYPEFUNC_RECORD)
1493                                 ereport(ERROR,
1494                                                 (errcode(ERRCODE_SYNTAX_ERROR),
1495                                                  errmsg("a column definition list is required for functions returning \"record\""),
1496                                                  parser_errposition(pstate, exprLocation(funcexpr))));
1497                 }
1498
1499                 if (functypclass == TYPEFUNC_COMPOSITE ||
1500                         functypclass == TYPEFUNC_COMPOSITE_DOMAIN)
1501                 {
1502                         /* Composite data type, e.g. a table's row type */
1503                         Assert(tupdesc);
1504                 }
1505                 else if (functypclass == TYPEFUNC_SCALAR)
1506                 {
1507                         /* Base data type, i.e. scalar */
1508                         tupdesc = CreateTemplateTupleDesc(1, false);
1509                         TupleDescInitEntry(tupdesc,
1510                                                            (AttrNumber) 1,
1511                                                            chooseScalarFunctionAlias(funcexpr, funcname,
1512                                                                                                                  alias, nfuncs),
1513                                                            funcrettype,
1514                                                            -1,
1515                                                            0);
1516                 }
1517                 else if (functypclass == TYPEFUNC_RECORD)
1518                 {
1519                         ListCell   *col;
1520
1521                         /*
1522                          * Use the column definition list to construct a tupdesc and fill
1523                          * in the RangeTblFunction's lists.
1524                          */
1525                         tupdesc = CreateTemplateTupleDesc(list_length(coldeflist), false);
1526                         i = 1;
1527                         foreach(col, coldeflist)
1528                         {
1529                                 ColumnDef  *n = (ColumnDef *) lfirst(col);
1530                                 char       *attrname;
1531                                 Oid                     attrtype;
1532                                 int32           attrtypmod;
1533                                 Oid                     attrcollation;
1534
1535                                 attrname = n->colname;
1536                                 if (n->typeName->setof)
1537                                         ereport(ERROR,
1538                                                         (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
1539                                                          errmsg("column \"%s\" cannot be declared SETOF",
1540                                                                         attrname),
1541                                                          parser_errposition(pstate, n->location)));
1542                                 typenameTypeIdAndMod(pstate, n->typeName,
1543                                                                          &attrtype, &attrtypmod);
1544                                 attrcollation = GetColumnDefCollation(pstate, n, attrtype);
1545                                 TupleDescInitEntry(tupdesc,
1546                                                                    (AttrNumber) i,
1547                                                                    attrname,
1548                                                                    attrtype,
1549                                                                    attrtypmod,
1550                                                                    0);
1551                                 TupleDescInitEntryCollation(tupdesc,
1552                                                                                         (AttrNumber) i,
1553                                                                                         attrcollation);
1554                                 rtfunc->funccolnames = lappend(rtfunc->funccolnames,
1555                                                                                            makeString(pstrdup(attrname)));
1556                                 rtfunc->funccoltypes = lappend_oid(rtfunc->funccoltypes,
1557                                                                                                    attrtype);
1558                                 rtfunc->funccoltypmods = lappend_int(rtfunc->funccoltypmods,
1559                                                                                                          attrtypmod);
1560                                 rtfunc->funccolcollations = lappend_oid(rtfunc->funccolcollations,
1561                                                                                                                 attrcollation);
1562
1563                                 i++;
1564                         }
1565
1566                         /*
1567                          * Ensure that the coldeflist defines a legal set of names (no
1568                          * duplicates) and datatypes (no pseudo-types, for instance).
1569                          */
1570                         CheckAttributeNamesTypes(tupdesc, RELKIND_COMPOSITE_TYPE, false);
1571                 }
1572                 else
1573                         ereport(ERROR,
1574                                         (errcode(ERRCODE_DATATYPE_MISMATCH),
1575                                          errmsg("function \"%s\" in FROM has unsupported return type %s",
1576                                                         funcname, format_type_be(funcrettype)),
1577                                          parser_errposition(pstate, exprLocation(funcexpr))));
1578
1579                 /* Finish off the RangeTblFunction and add it to the RTE's list */
1580                 rtfunc->funccolcount = tupdesc->natts;
1581                 rte->functions = lappend(rte->functions, rtfunc);
1582
1583                 /* Save the tupdesc for use below */
1584                 functupdescs[funcno] = tupdesc;
1585                 totalatts += tupdesc->natts;
1586                 funcno++;
1587         }
1588
1589         /*
1590          * If there's more than one function, or we want an ordinality column, we
1591          * have to produce a merged tupdesc.
1592          */
1593         if (nfuncs > 1 || rangefunc->ordinality)
1594         {
1595                 if (rangefunc->ordinality)
1596                         totalatts++;
1597
1598                 /* Merge the tuple descs of each function into a composite one */
1599                 tupdesc = CreateTemplateTupleDesc(totalatts, false);
1600                 natts = 0;
1601                 for (i = 0; i < nfuncs; i++)
1602                 {
1603                         for (j = 1; j <= functupdescs[i]->natts; j++)
1604                                 TupleDescCopyEntry(tupdesc, ++natts, functupdescs[i], j);
1605                 }
1606
1607                 /* Add the ordinality column if needed */
1608                 if (rangefunc->ordinality)
1609                         TupleDescInitEntry(tupdesc,
1610                                                            (AttrNumber) ++natts,
1611                                                            "ordinality",
1612                                                            INT8OID,
1613                                                            -1,
1614                                                            0);
1615
1616                 Assert(natts == totalatts);
1617         }
1618         else
1619         {
1620                 /* We can just use the single function's tupdesc as-is */
1621                 tupdesc = functupdescs[0];
1622         }
1623
1624         /* Use the tupdesc while assigning column aliases for the RTE */
1625         buildRelationAliases(tupdesc, alias, eref);
1626
1627         /*
1628          * Set flags and access permissions.
1629          *
1630          * Functions are never checked for access rights (at least, not by the RTE
1631          * permissions mechanism).
1632          */
1633         rte->lateral = lateral;
1634         rte->inh = false;                       /* never true for functions */
1635         rte->inFromCl = inFromCl;
1636
1637         rte->requiredPerms = 0;
1638         rte->checkAsUser = InvalidOid;
1639         rte->selectedCols = NULL;
1640         rte->insertedCols = NULL;
1641         rte->updatedCols = NULL;
1642
1643         /*
1644          * Add completed RTE to pstate's range table list, but not to join list
1645          * nor namespace --- caller must do that if appropriate.
1646          */
1647         pstate->p_rtable = lappend(pstate->p_rtable, rte);
1648
1649         return rte;
1650 }
1651
1652 /*
1653  * Add an entry for a table function to the pstate's range table (p_rtable).
1654  *
1655  * This is much like addRangeTableEntry() except that it makes a tablefunc RTE.
1656  */
1657 RangeTblEntry *
1658 addRangeTableEntryForTableFunc(ParseState *pstate,
1659                                                            TableFunc *tf,
1660                                                            Alias *alias,
1661                                                            bool lateral,
1662                                                            bool inFromCl)
1663 {
1664         RangeTblEntry *rte = makeNode(RangeTblEntry);
1665         char       *refname = alias ? alias->aliasname : pstrdup("xmltable");
1666         Alias      *eref;
1667         int                     numaliases;
1668
1669         Assert(pstate != NULL);
1670
1671         rte->rtekind = RTE_TABLEFUNC;
1672         rte->relid = InvalidOid;
1673         rte->subquery = NULL;
1674         rte->tablefunc = tf;
1675         rte->coltypes = tf->coltypes;
1676         rte->coltypmods = tf->coltypmods;
1677         rte->colcollations = tf->colcollations;
1678         rte->alias = alias;
1679
1680         eref = alias ? copyObject(alias) : makeAlias(refname, NIL);
1681         numaliases = list_length(eref->colnames);
1682
1683         /* fill in any unspecified alias columns */
1684         if (numaliases < list_length(tf->colnames))
1685                 eref->colnames = list_concat(eref->colnames,
1686                                                                          list_copy_tail(tf->colnames, numaliases));
1687
1688         rte->eref = eref;
1689
1690         /*
1691          * Set flags and access permissions.
1692          *
1693          * Tablefuncs are never checked for access rights (at least, not by the
1694          * RTE permissions mechanism).
1695          */
1696         rte->lateral = lateral;
1697         rte->inh = false;                       /* never true for tablefunc RTEs */
1698         rte->inFromCl = inFromCl;
1699
1700         rte->requiredPerms = 0;
1701         rte->checkAsUser = InvalidOid;
1702         rte->selectedCols = NULL;
1703         rte->insertedCols = NULL;
1704         rte->updatedCols = NULL;
1705
1706         /*
1707          * Add completed RTE to pstate's range table list, but not to join list
1708          * nor namespace --- caller must do that if appropriate.
1709          */
1710         pstate->p_rtable = lappend(pstate->p_rtable, rte);
1711
1712         return rte;
1713 }
1714
1715 /*
1716  * Add an entry for a VALUES list to the pstate's range table (p_rtable).
1717  *
1718  * This is much like addRangeTableEntry() except that it makes a values RTE.
1719  */
1720 RangeTblEntry *
1721 addRangeTableEntryForValues(ParseState *pstate,
1722                                                         List *exprs,
1723                                                         List *coltypes,
1724                                                         List *coltypmods,
1725                                                         List *colcollations,
1726                                                         Alias *alias,
1727                                                         bool lateral,
1728                                                         bool inFromCl)
1729 {
1730         RangeTblEntry *rte = makeNode(RangeTblEntry);
1731         char       *refname = alias ? alias->aliasname : pstrdup("*VALUES*");
1732         Alias      *eref;
1733         int                     numaliases;
1734         int                     numcolumns;
1735
1736         Assert(pstate != NULL);
1737
1738         rte->rtekind = RTE_VALUES;
1739         rte->relid = InvalidOid;
1740         rte->subquery = NULL;
1741         rte->values_lists = exprs;
1742         rte->coltypes = coltypes;
1743         rte->coltypmods = coltypmods;
1744         rte->colcollations = colcollations;
1745         rte->alias = alias;
1746
1747         eref = alias ? copyObject(alias) : makeAlias(refname, NIL);
1748
1749         /* fill in any unspecified alias columns */
1750         numcolumns = list_length((List *) linitial(exprs));
1751         numaliases = list_length(eref->colnames);
1752         while (numaliases < numcolumns)
1753         {
1754                 char            attrname[64];
1755
1756                 numaliases++;
1757                 snprintf(attrname, sizeof(attrname), "column%d", numaliases);
1758                 eref->colnames = lappend(eref->colnames,
1759                                                                  makeString(pstrdup(attrname)));
1760         }
1761         if (numcolumns < numaliases)
1762                 ereport(ERROR,
1763                                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1764                                  errmsg("VALUES lists \"%s\" have %d columns available but %d columns specified",
1765                                                 refname, numcolumns, numaliases)));
1766
1767         rte->eref = eref;
1768
1769         /*
1770          * Set flags and access permissions.
1771          *
1772          * Subqueries are never checked for access rights.
1773          */
1774         rte->lateral = lateral;
1775         rte->inh = false;                       /* never true for values RTEs */
1776         rte->inFromCl = inFromCl;
1777
1778         rte->requiredPerms = 0;
1779         rte->checkAsUser = InvalidOid;
1780         rte->selectedCols = NULL;
1781         rte->insertedCols = NULL;
1782         rte->updatedCols = NULL;
1783
1784         /*
1785          * Add completed RTE to pstate's range table list, but not to join list
1786          * nor namespace --- caller must do that if appropriate.
1787          */
1788         pstate->p_rtable = lappend(pstate->p_rtable, rte);
1789
1790         return rte;
1791 }
1792
1793 /*
1794  * Add an entry for a join to the pstate's range table (p_rtable).
1795  *
1796  * This is much like addRangeTableEntry() except that it makes a join RTE.
1797  */
1798 RangeTblEntry *
1799 addRangeTableEntryForJoin(ParseState *pstate,
1800                                                   List *colnames,
1801                                                   JoinType jointype,
1802                                                   List *aliasvars,
1803                                                   Alias *alias,
1804                                                   bool inFromCl)
1805 {
1806         RangeTblEntry *rte = makeNode(RangeTblEntry);
1807         Alias      *eref;
1808         int                     numaliases;
1809
1810         Assert(pstate != NULL);
1811
1812         /*
1813          * Fail if join has too many columns --- we must be able to reference any
1814          * of the columns with an AttrNumber.
1815          */
1816         if (list_length(aliasvars) > MaxAttrNumber)
1817                 ereport(ERROR,
1818                                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1819                                  errmsg("joins can have at most %d columns",
1820                                                 MaxAttrNumber)));
1821
1822         rte->rtekind = RTE_JOIN;
1823         rte->relid = InvalidOid;
1824         rte->subquery = NULL;
1825         rte->jointype = jointype;
1826         rte->joinaliasvars = aliasvars;
1827         rte->alias = alias;
1828
1829         eref = alias ? copyObject(alias) : makeAlias("unnamed_join", NIL);
1830         numaliases = list_length(eref->colnames);
1831
1832         /* fill in any unspecified alias columns */
1833         if (numaliases < list_length(colnames))
1834                 eref->colnames = list_concat(eref->colnames,
1835                                                                          list_copy_tail(colnames, numaliases));
1836
1837         rte->eref = eref;
1838
1839         /*
1840          * Set flags and access permissions.
1841          *
1842          * Joins are never checked for access rights.
1843          */
1844         rte->lateral = false;
1845         rte->inh = false;                       /* never true for joins */
1846         rte->inFromCl = inFromCl;
1847
1848         rte->requiredPerms = 0;
1849         rte->checkAsUser = InvalidOid;
1850         rte->selectedCols = NULL;
1851         rte->insertedCols = NULL;
1852         rte->updatedCols = NULL;
1853
1854         /*
1855          * Add completed RTE to pstate's range table list, but not to join list
1856          * nor namespace --- caller must do that if appropriate.
1857          */
1858         pstate->p_rtable = lappend(pstate->p_rtable, rte);
1859
1860         return rte;
1861 }
1862
1863 /*
1864  * Add an entry for a CTE reference to the pstate's range table (p_rtable).
1865  *
1866  * This is much like addRangeTableEntry() except that it makes a CTE RTE.
1867  */
1868 RangeTblEntry *
1869 addRangeTableEntryForCTE(ParseState *pstate,
1870                                                  CommonTableExpr *cte,
1871                                                  Index levelsup,
1872                                                  RangeVar *rv,
1873                                                  bool inFromCl)
1874 {
1875         RangeTblEntry *rte = makeNode(RangeTblEntry);
1876         Alias      *alias = rv->alias;
1877         char       *refname = alias ? alias->aliasname : cte->ctename;
1878         Alias      *eref;
1879         int                     numaliases;
1880         int                     varattno;
1881         ListCell   *lc;
1882
1883         Assert(pstate != NULL);
1884
1885         rte->rtekind = RTE_CTE;
1886         rte->ctename = cte->ctename;
1887         rte->ctelevelsup = levelsup;
1888
1889         /* Self-reference if and only if CTE's parse analysis isn't completed */
1890         rte->self_reference = !IsA(cte->ctequery, Query);
1891         Assert(cte->cterecursive || !rte->self_reference);
1892         /* Bump the CTE's refcount if this isn't a self-reference */
1893         if (!rte->self_reference)
1894                 cte->cterefcount++;
1895
1896         /*
1897          * We throw error if the CTE is INSERT/UPDATE/DELETE without RETURNING.
1898          * This won't get checked in case of a self-reference, but that's OK
1899          * because data-modifying CTEs aren't allowed to be recursive anyhow.
1900          */
1901         if (IsA(cte->ctequery, Query))
1902         {
1903                 Query      *ctequery = (Query *) cte->ctequery;
1904
1905                 if (ctequery->commandType != CMD_SELECT &&
1906                         ctequery->returningList == NIL)
1907                         ereport(ERROR,
1908                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1909                                          errmsg("WITH query \"%s\" does not have a RETURNING clause",
1910                                                         cte->ctename),
1911                                          parser_errposition(pstate, rv->location)));
1912         }
1913
1914         rte->coltypes = cte->ctecoltypes;
1915         rte->coltypmods = cte->ctecoltypmods;
1916         rte->colcollations = cte->ctecolcollations;
1917
1918         rte->alias = alias;
1919         if (alias)
1920                 eref = copyObject(alias);
1921         else
1922                 eref = makeAlias(refname, NIL);
1923         numaliases = list_length(eref->colnames);
1924
1925         /* fill in any unspecified alias columns */
1926         varattno = 0;
1927         foreach(lc, cte->ctecolnames)
1928         {
1929                 varattno++;
1930                 if (varattno > numaliases)
1931                         eref->colnames = lappend(eref->colnames, lfirst(lc));
1932         }
1933         if (varattno < numaliases)
1934                 ereport(ERROR,
1935                                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1936                                  errmsg("table \"%s\" has %d columns available but %d columns specified",
1937                                                 refname, varattno, numaliases)));
1938
1939         rte->eref = eref;
1940
1941         /*
1942          * Set flags and access permissions.
1943          *
1944          * Subqueries are never checked for access rights.
1945          */
1946         rte->lateral = false;
1947         rte->inh = false;                       /* never true for subqueries */
1948         rte->inFromCl = inFromCl;
1949
1950         rte->requiredPerms = 0;
1951         rte->checkAsUser = InvalidOid;
1952         rte->selectedCols = NULL;
1953         rte->insertedCols = NULL;
1954         rte->updatedCols = NULL;
1955
1956         /*
1957          * Add completed RTE to pstate's range table list, but not to join list
1958          * nor namespace --- caller must do that if appropriate.
1959          */
1960         pstate->p_rtable = lappend(pstate->p_rtable, rte);
1961
1962         return rte;
1963 }
1964
1965 /*
1966  * Add an entry for an ephemeral named relation reference to the pstate's
1967  * range table (p_rtable).
1968  *
1969  * It is expected that the RangeVar, which up until now is only known to be an
1970  * ephemeral named relation, will (in conjunction with the QueryEnvironment in
1971  * the ParseState), create a RangeTblEntry for a specific *kind* of ephemeral
1972  * named relation, based on enrtype.
1973  *
1974  * This is much like addRangeTableEntry() except that it makes an RTE for an
1975  * ephemeral named relation.
1976  */
1977 RangeTblEntry *
1978 addRangeTableEntryForENR(ParseState *pstate,
1979                                                  RangeVar *rv,
1980                                                  bool inFromCl)
1981 {
1982         RangeTblEntry *rte = makeNode(RangeTblEntry);
1983         Alias      *alias = rv->alias;
1984         char       *refname = alias ? alias->aliasname : rv->relname;
1985         EphemeralNamedRelationMetadata enrmd;
1986         TupleDesc       tupdesc;
1987         int                     attno;
1988
1989         Assert(pstate != NULL);
1990         enrmd = get_visible_ENR(pstate, rv->relname);
1991         Assert(enrmd != NULL);
1992
1993         switch (enrmd->enrtype)
1994         {
1995                 case ENR_NAMED_TUPLESTORE:
1996                         rte->rtekind = RTE_NAMEDTUPLESTORE;
1997                         break;
1998
1999                 default:
2000                         elog(ERROR, "unexpected enrtype: %d", enrmd->enrtype);
2001                         return NULL;            /* for fussy compilers */
2002         }
2003
2004         /*
2005          * Record dependency on a relation.  This allows plans to be invalidated
2006          * if they access transition tables linked to a table that is altered.
2007          */
2008         rte->relid = enrmd->reliddesc;
2009
2010         /*
2011          * Build the list of effective column names using user-supplied aliases
2012          * and/or actual column names.
2013          */
2014         tupdesc = ENRMetadataGetTupDesc(enrmd);
2015         rte->eref = makeAlias(refname, NIL);
2016         buildRelationAliases(tupdesc, alias, rte->eref);
2017
2018         /* Record additional data for ENR, including column type info */
2019         rte->enrname = enrmd->name;
2020         rte->enrtuples = enrmd->enrtuples;
2021         rte->coltypes = NIL;
2022         rte->coltypmods = NIL;
2023         rte->colcollations = NIL;
2024         for (attno = 1; attno <= tupdesc->natts; ++attno)
2025         {
2026                 Form_pg_attribute att = TupleDescAttr(tupdesc, attno - 1);
2027
2028                 if (att->attisdropped)
2029                 {
2030                         /* Record zeroes for a dropped column */
2031                         rte->coltypes = lappend_oid(rte->coltypes, InvalidOid);
2032                         rte->coltypmods = lappend_int(rte->coltypmods, 0);
2033                         rte->colcollations = lappend_oid(rte->colcollations, InvalidOid);
2034                 }
2035                 else
2036                 {
2037                         /* Let's just make sure we can tell this isn't dropped */
2038                         if (att->atttypid == InvalidOid)
2039                                 elog(ERROR, "atttypid is invalid for non-dropped column in \"%s\"",
2040                                          rv->relname);
2041                         rte->coltypes = lappend_oid(rte->coltypes, att->atttypid);
2042                         rte->coltypmods = lappend_int(rte->coltypmods, att->atttypmod);
2043                         rte->colcollations = lappend_oid(rte->colcollations,
2044                                                                                          att->attcollation);
2045                 }
2046         }
2047
2048         /*
2049          * Set flags and access permissions.
2050          *
2051          * ENRs are never checked for access rights.
2052          */
2053         rte->lateral = false;
2054         rte->inh = false;                       /* never true for ENRs */
2055         rte->inFromCl = inFromCl;
2056
2057         rte->requiredPerms = 0;
2058         rte->checkAsUser = InvalidOid;
2059         rte->selectedCols = NULL;
2060
2061         /*
2062          * Add completed RTE to pstate's range table list, but not to join list
2063          * nor namespace --- caller must do that if appropriate.
2064          */
2065         pstate->p_rtable = lappend(pstate->p_rtable, rte);
2066
2067         return rte;
2068 }
2069
2070
2071 /*
2072  * Has the specified refname been selected FOR UPDATE/FOR SHARE?
2073  *
2074  * This is used when we have not yet done transformLockingClause, but need
2075  * to know the correct lock to take during initial opening of relations.
2076  *
2077  * Note: we pay no attention to whether it's FOR UPDATE vs FOR SHARE,
2078  * since the table-level lock is the same either way.
2079  */
2080 bool
2081 isLockedRefname(ParseState *pstate, const char *refname)
2082 {
2083         ListCell   *l;
2084
2085         /*
2086          * If we are in a subquery specified as locked FOR UPDATE/SHARE from
2087          * parent level, then act as though there's a generic FOR UPDATE here.
2088          */
2089         if (pstate->p_locked_from_parent)
2090                 return true;
2091
2092         foreach(l, pstate->p_locking_clause)
2093         {
2094                 LockingClause *lc = (LockingClause *) lfirst(l);
2095
2096                 if (lc->lockedRels == NIL)
2097                 {
2098                         /* all tables used in query */
2099                         return true;
2100                 }
2101                 else
2102                 {
2103                         /* just the named tables */
2104                         ListCell   *l2;
2105
2106                         foreach(l2, lc->lockedRels)
2107                         {
2108                                 RangeVar   *thisrel = (RangeVar *) lfirst(l2);
2109
2110                                 if (strcmp(refname, thisrel->relname) == 0)
2111                                         return true;
2112                         }
2113                 }
2114         }
2115         return false;
2116 }
2117
2118 /*
2119  * Add the given RTE as a top-level entry in the pstate's join list
2120  * and/or namespace list.  (We assume caller has checked for any
2121  * namespace conflicts.)  The RTE is always marked as unconditionally
2122  * visible, that is, not LATERAL-only.
2123  *
2124  * Note: some callers know that they can find the new ParseNamespaceItem
2125  * at the end of the pstate->p_namespace list.  This is a bit ugly but not
2126  * worth complicating this function's signature for.
2127  */
2128 void
2129 addRTEtoQuery(ParseState *pstate, RangeTblEntry *rte,
2130                           bool addToJoinList,
2131                           bool addToRelNameSpace, bool addToVarNameSpace)
2132 {
2133         if (addToJoinList)
2134         {
2135                 int                     rtindex = RTERangeTablePosn(pstate, rte, NULL);
2136                 RangeTblRef *rtr = makeNode(RangeTblRef);
2137
2138                 rtr->rtindex = rtindex;
2139                 pstate->p_joinlist = lappend(pstate->p_joinlist, rtr);
2140         }
2141         if (addToRelNameSpace || addToVarNameSpace)
2142         {
2143                 ParseNamespaceItem *nsitem;
2144
2145                 nsitem = (ParseNamespaceItem *) palloc(sizeof(ParseNamespaceItem));
2146                 nsitem->p_rte = rte;
2147                 nsitem->p_rel_visible = addToRelNameSpace;
2148                 nsitem->p_cols_visible = addToVarNameSpace;
2149                 nsitem->p_lateral_only = false;
2150                 nsitem->p_lateral_ok = true;
2151                 pstate->p_namespace = lappend(pstate->p_namespace, nsitem);
2152         }
2153 }
2154
2155 /*
2156  * expandRTE -- expand the columns of a rangetable entry
2157  *
2158  * This creates lists of an RTE's column names (aliases if provided, else
2159  * real names) and Vars for each column.  Only user columns are considered.
2160  * If include_dropped is FALSE then dropped columns are omitted from the
2161  * results.  If include_dropped is TRUE then empty strings and NULL constants
2162  * (not Vars!) are returned for dropped columns.
2163  *
2164  * rtindex, sublevels_up, and location are the varno, varlevelsup, and location
2165  * values to use in the created Vars.  Ordinarily rtindex should match the
2166  * actual position of the RTE in its rangetable.
2167  *
2168  * The output lists go into *colnames and *colvars.
2169  * If only one of the two kinds of output list is needed, pass NULL for the
2170  * output pointer for the unwanted one.
2171  */
2172 void
2173 expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up,
2174                   int location, bool include_dropped,
2175                   List **colnames, List **colvars)
2176 {
2177         int                     varattno;
2178
2179         if (colnames)
2180                 *colnames = NIL;
2181         if (colvars)
2182                 *colvars = NIL;
2183
2184         switch (rte->rtekind)
2185         {
2186                 case RTE_RELATION:
2187                         /* Ordinary relation RTE */
2188                         expandRelation(rte->relid, rte->eref,
2189                                                    rtindex, sublevels_up, location,
2190                                                    include_dropped, colnames, colvars);
2191                         break;
2192                 case RTE_SUBQUERY:
2193                         {
2194                                 /* Subquery RTE */
2195                                 ListCell   *aliasp_item = list_head(rte->eref->colnames);
2196                                 ListCell   *tlistitem;
2197
2198                                 varattno = 0;
2199                                 foreach(tlistitem, rte->subquery->targetList)
2200                                 {
2201                                         TargetEntry *te = (TargetEntry *) lfirst(tlistitem);
2202
2203                                         if (te->resjunk)
2204                                                 continue;
2205                                         varattno++;
2206                                         Assert(varattno == te->resno);
2207
2208                                         if (colnames)
2209                                         {
2210                                                 /* Assume there is one alias per target item */
2211                                                 char       *label = strVal(lfirst(aliasp_item));
2212
2213                                                 *colnames = lappend(*colnames, makeString(pstrdup(label)));
2214                                                 aliasp_item = lnext(aliasp_item);
2215                                         }
2216
2217                                         if (colvars)
2218                                         {
2219                                                 Var                *varnode;
2220
2221                                                 varnode = makeVar(rtindex, varattno,
2222                                                                                   exprType((Node *) te->expr),
2223                                                                                   exprTypmod((Node *) te->expr),
2224                                                                                   exprCollation((Node *) te->expr),
2225                                                                                   sublevels_up);
2226                                                 varnode->location = location;
2227
2228                                                 *colvars = lappend(*colvars, varnode);
2229                                         }
2230                                 }
2231                         }
2232                         break;
2233                 case RTE_FUNCTION:
2234                         {
2235                                 /* Function RTE */
2236                                 int                     atts_done = 0;
2237                                 ListCell   *lc;
2238
2239                                 foreach(lc, rte->functions)
2240                                 {
2241                                         RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
2242                                         TypeFuncClass functypclass;
2243                                         Oid                     funcrettype;
2244                                         TupleDesc       tupdesc;
2245
2246                                         functypclass = get_expr_result_type(rtfunc->funcexpr,
2247                                                                                                                 &funcrettype,
2248                                                                                                                 &tupdesc);
2249                                         if (functypclass == TYPEFUNC_COMPOSITE ||
2250                                                 functypclass == TYPEFUNC_COMPOSITE_DOMAIN)
2251                                         {
2252                                                 /* Composite data type, e.g. a table's row type */
2253                                                 Assert(tupdesc);
2254                                                 expandTupleDesc(tupdesc, rte->eref,
2255                                                                                 rtfunc->funccolcount, atts_done,
2256                                                                                 rtindex, sublevels_up, location,
2257                                                                                 include_dropped, colnames, colvars);
2258                                         }
2259                                         else if (functypclass == TYPEFUNC_SCALAR)
2260                                         {
2261                                                 /* Base data type, i.e. scalar */
2262                                                 if (colnames)
2263                                                         *colnames = lappend(*colnames,
2264                                                                                                 list_nth(rte->eref->colnames,
2265                                                                                                                  atts_done));
2266
2267                                                 if (colvars)
2268                                                 {
2269                                                         Var                *varnode;
2270
2271                                                         varnode = makeVar(rtindex, atts_done + 1,
2272                                                                                           funcrettype, -1,
2273                                                                                           exprCollation(rtfunc->funcexpr),
2274                                                                                           sublevels_up);
2275                                                         varnode->location = location;
2276
2277                                                         *colvars = lappend(*colvars, varnode);
2278                                                 }
2279                                         }
2280                                         else if (functypclass == TYPEFUNC_RECORD)
2281                                         {
2282                                                 if (colnames)
2283                                                 {
2284                                                         List       *namelist;
2285
2286                                                         /* extract appropriate subset of column list */
2287                                                         namelist = list_copy_tail(rte->eref->colnames,
2288                                                                                                           atts_done);
2289                                                         namelist = list_truncate(namelist,
2290                                                                                                          rtfunc->funccolcount);
2291                                                         *colnames = list_concat(*colnames, namelist);
2292                                                 }
2293
2294                                                 if (colvars)
2295                                                 {
2296                                                         ListCell   *l1;
2297                                                         ListCell   *l2;
2298                                                         ListCell   *l3;
2299                                                         int                     attnum = atts_done;
2300
2301                                                         forthree(l1, rtfunc->funccoltypes,
2302                                                                          l2, rtfunc->funccoltypmods,
2303                                                                          l3, rtfunc->funccolcollations)
2304                                                         {
2305                                                                 Oid                     attrtype = lfirst_oid(l1);
2306                                                                 int32           attrtypmod = lfirst_int(l2);
2307                                                                 Oid                     attrcollation = lfirst_oid(l3);
2308                                                                 Var                *varnode;
2309
2310                                                                 attnum++;
2311                                                                 varnode = makeVar(rtindex,
2312                                                                                                   attnum,
2313                                                                                                   attrtype,
2314                                                                                                   attrtypmod,
2315                                                                                                   attrcollation,
2316                                                                                                   sublevels_up);
2317                                                                 varnode->location = location;
2318                                                                 *colvars = lappend(*colvars, varnode);
2319                                                         }
2320                                                 }
2321                                         }
2322                                         else
2323                                         {
2324                                                 /* addRangeTableEntryForFunction should've caught this */
2325                                                 elog(ERROR, "function in FROM has unsupported return type");
2326                                         }
2327                                         atts_done += rtfunc->funccolcount;
2328                                 }
2329
2330                                 /* Append the ordinality column if any */
2331                                 if (rte->funcordinality)
2332                                 {
2333                                         if (colnames)
2334                                                 *colnames = lappend(*colnames,
2335                                                                                         llast(rte->eref->colnames));
2336
2337                                         if (colvars)
2338                                         {
2339                                                 Var                *varnode = makeVar(rtindex,
2340                                                                                                           atts_done + 1,
2341                                                                                                           INT8OID,
2342                                                                                                           -1,
2343                                                                                                           InvalidOid,
2344                                                                                                           sublevels_up);
2345
2346                                                 *colvars = lappend(*colvars, varnode);
2347                                         }
2348                                 }
2349                         }
2350                         break;
2351                 case RTE_JOIN:
2352                         {
2353                                 /* Join RTE */
2354                                 ListCell   *colname;
2355                                 ListCell   *aliasvar;
2356
2357                                 Assert(list_length(rte->eref->colnames) == list_length(rte->joinaliasvars));
2358
2359                                 varattno = 0;
2360                                 forboth(colname, rte->eref->colnames, aliasvar, rte->joinaliasvars)
2361                                 {
2362                                         Node       *avar = (Node *) lfirst(aliasvar);
2363
2364                                         varattno++;
2365
2366                                         /*
2367                                          * During ordinary parsing, there will never be any
2368                                          * deleted columns in the join; but we have to check since
2369                                          * this routine is also used by the rewriter, and joins
2370                                          * found in stored rules might have join columns for
2371                                          * since-deleted columns.  This will be signaled by a null
2372                                          * pointer in the alias-vars list.
2373                                          */
2374                                         if (avar == NULL)
2375                                         {
2376                                                 if (include_dropped)
2377                                                 {
2378                                                         if (colnames)
2379                                                                 *colnames = lappend(*colnames,
2380                                                                                                         makeString(pstrdup("")));
2381                                                         if (colvars)
2382                                                         {
2383                                                                 /*
2384                                                                  * Can't use join's column type here (it might
2385                                                                  * be dropped!); but it doesn't really matter
2386                                                                  * what type the Const claims to be.
2387                                                                  */
2388                                                                 *colvars = lappend(*colvars,
2389                                                                                                    makeNullConst(INT4OID, -1,
2390                                                                                                                                  InvalidOid));
2391                                                         }
2392                                                 }
2393                                                 continue;
2394                                         }
2395
2396                                         if (colnames)
2397                                         {
2398                                                 char       *label = strVal(lfirst(colname));
2399
2400                                                 *colnames = lappend(*colnames,
2401                                                                                         makeString(pstrdup(label)));
2402                                         }
2403
2404                                         if (colvars)
2405                                         {
2406                                                 Var                *varnode;
2407
2408                                                 varnode = makeVar(rtindex, varattno,
2409                                                                                   exprType(avar),
2410                                                                                   exprTypmod(avar),
2411                                                                                   exprCollation(avar),
2412                                                                                   sublevels_up);
2413                                                 varnode->location = location;
2414
2415                                                 *colvars = lappend(*colvars, varnode);
2416                                         }
2417                                 }
2418                         }
2419                         break;
2420                 case RTE_TABLEFUNC:
2421                 case RTE_VALUES:
2422                 case RTE_CTE:
2423                 case RTE_NAMEDTUPLESTORE:
2424                         {
2425                                 /* Tablefunc, Values, CTE, or ENR RTE */
2426                                 ListCell   *aliasp_item = list_head(rte->eref->colnames);
2427                                 ListCell   *lct;
2428                                 ListCell   *lcm;
2429                                 ListCell   *lcc;
2430
2431                                 varattno = 0;
2432                                 forthree(lct, rte->coltypes,
2433                                                  lcm, rte->coltypmods,
2434                                                  lcc, rte->colcollations)
2435                                 {
2436                                         Oid                     coltype = lfirst_oid(lct);
2437                                         int32           coltypmod = lfirst_int(lcm);
2438                                         Oid                     colcoll = lfirst_oid(lcc);
2439
2440                                         varattno++;
2441
2442                                         if (colnames)
2443                                         {
2444                                                 /* Assume there is one alias per output column */
2445                                                 if (OidIsValid(coltype))
2446                                                 {
2447                                                         char       *label = strVal(lfirst(aliasp_item));
2448
2449                                                         *colnames = lappend(*colnames,
2450                                                                                                 makeString(pstrdup(label)));
2451                                                 }
2452                                                 else if (include_dropped)
2453                                                         *colnames = lappend(*colnames,
2454                                                                                                 makeString(pstrdup("")));
2455
2456                                                 aliasp_item = lnext(aliasp_item);
2457                                         }
2458
2459                                         if (colvars)
2460                                         {
2461                                                 if (OidIsValid(coltype))
2462                                                 {
2463                                                         Var                *varnode;
2464
2465                                                         varnode = makeVar(rtindex, varattno,
2466                                                                                           coltype, coltypmod, colcoll,
2467                                                                                           sublevels_up);
2468                                                         varnode->location = location;
2469
2470                                                         *colvars = lappend(*colvars, varnode);
2471                                                 }
2472                                                 else if (include_dropped)
2473                                                 {
2474                                                         /*
2475                                                          * It doesn't really matter what type the Const
2476                                                          * claims to be.
2477                                                          */
2478                                                         *colvars = lappend(*colvars,
2479                                                                                            makeNullConst(INT4OID, -1,
2480                                                                                                                          InvalidOid));
2481                                                 }
2482                                         }
2483                                 }
2484                         }
2485                         break;
2486                 default:
2487                         elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
2488         }
2489 }
2490
2491 /*
2492  * expandRelation -- expandRTE subroutine
2493  */
2494 static void
2495 expandRelation(Oid relid, Alias *eref, int rtindex, int sublevels_up,
2496                            int location, bool include_dropped,
2497                            List **colnames, List **colvars)
2498 {
2499         Relation        rel;
2500
2501         /* Get the tupledesc and turn it over to expandTupleDesc */
2502         rel = relation_open(relid, AccessShareLock);
2503         expandTupleDesc(rel->rd_att, eref, rel->rd_att->natts, 0,
2504                                         rtindex, sublevels_up,
2505                                         location, include_dropped,
2506                                         colnames, colvars);
2507         relation_close(rel, AccessShareLock);
2508 }
2509
2510 /*
2511  * expandTupleDesc -- expandRTE subroutine
2512  *
2513  * Generate names and/or Vars for the first "count" attributes of the tupdesc,
2514  * and append them to colnames/colvars.  "offset" is added to the varattno
2515  * that each Var would otherwise have, and we also skip the first "offset"
2516  * entries in eref->colnames.  (These provisions allow use of this code for
2517  * an individual composite-returning function in an RTE_FUNCTION RTE.)
2518  */
2519 static void
2520 expandTupleDesc(TupleDesc tupdesc, Alias *eref, int count, int offset,
2521                                 int rtindex, int sublevels_up,
2522                                 int location, bool include_dropped,
2523                                 List **colnames, List **colvars)
2524 {
2525         ListCell   *aliascell = list_head(eref->colnames);
2526         int                     varattno;
2527
2528         if (colnames)
2529         {
2530                 int                     i;
2531
2532                 for (i = 0; i < offset; i++)
2533                 {
2534                         if (aliascell)
2535                                 aliascell = lnext(aliascell);
2536                 }
2537         }
2538
2539         Assert(count <= tupdesc->natts);
2540         for (varattno = 0; varattno < count; varattno++)
2541         {
2542                 Form_pg_attribute attr = TupleDescAttr(tupdesc, varattno);
2543
2544                 if (attr->attisdropped)
2545                 {
2546                         if (include_dropped)
2547                         {
2548                                 if (colnames)
2549                                         *colnames = lappend(*colnames, makeString(pstrdup("")));
2550                                 if (colvars)
2551                                 {
2552                                         /*
2553                                          * can't use atttypid here, but it doesn't really matter
2554                                          * what type the Const claims to be.
2555                                          */
2556                                         *colvars = lappend(*colvars,
2557                                                                            makeNullConst(INT4OID, -1, InvalidOid));
2558                                 }
2559                         }
2560                         if (aliascell)
2561                                 aliascell = lnext(aliascell);
2562                         continue;
2563                 }
2564
2565                 if (colnames)
2566                 {
2567                         char       *label;
2568
2569                         if (aliascell)
2570                         {
2571                                 label = strVal(lfirst(aliascell));
2572                                 aliascell = lnext(aliascell);
2573                         }
2574                         else
2575                         {
2576                                 /* If we run out of aliases, use the underlying name */
2577                                 label = NameStr(attr->attname);
2578                         }
2579                         *colnames = lappend(*colnames, makeString(pstrdup(label)));
2580                 }
2581
2582                 if (colvars)
2583                 {
2584                         Var                *varnode;
2585
2586                         varnode = makeVar(rtindex, varattno + offset + 1,
2587                                                           attr->atttypid, attr->atttypmod,
2588                                                           attr->attcollation,
2589                                                           sublevels_up);
2590                         varnode->location = location;
2591
2592                         *colvars = lappend(*colvars, varnode);
2593                 }
2594         }
2595 }
2596
2597 /*
2598  * expandRelAttrs -
2599  *        Workhorse for "*" expansion: produce a list of targetentries
2600  *        for the attributes of the RTE
2601  *
2602  * As with expandRTE, rtindex/sublevels_up determine the varno/varlevelsup
2603  * fields of the Vars produced, and location sets their location.
2604  * pstate->p_next_resno determines the resnos assigned to the TLEs.
2605  * The referenced columns are marked as requiring SELECT access.
2606  */
2607 List *
2608 expandRelAttrs(ParseState *pstate, RangeTblEntry *rte,
2609                            int rtindex, int sublevels_up, int location)
2610 {
2611         List       *names,
2612                            *vars;
2613         ListCell   *name,
2614                            *var;
2615         List       *te_list = NIL;
2616
2617         expandRTE(rte, rtindex, sublevels_up, location, false,
2618                           &names, &vars);
2619
2620         /*
2621          * Require read access to the table.  This is normally redundant with the
2622          * markVarForSelectPriv calls below, but not if the table has zero
2623          * columns.
2624          */
2625         rte->requiredPerms |= ACL_SELECT;
2626
2627         forboth(name, names, var, vars)
2628         {
2629                 char       *label = strVal(lfirst(name));
2630                 Var                *varnode = (Var *) lfirst(var);
2631                 TargetEntry *te;
2632
2633                 te = makeTargetEntry((Expr *) varnode,
2634                                                          (AttrNumber) pstate->p_next_resno++,
2635                                                          label,
2636                                                          false);
2637                 te_list = lappend(te_list, te);
2638
2639                 /* Require read access to each column */
2640                 markVarForSelectPriv(pstate, varnode, rte);
2641         }
2642
2643         Assert(name == NULL && var == NULL);    /* lists not the same length? */
2644
2645         return te_list;
2646 }
2647
2648 /*
2649  * get_rte_attribute_name
2650  *              Get an attribute name from a RangeTblEntry
2651  *
2652  * This is unlike get_attname() because we use aliases if available.
2653  * In particular, it will work on an RTE for a subselect or join, whereas
2654  * get_attname() only works on real relations.
2655  *
2656  * "*" is returned if the given attnum is InvalidAttrNumber --- this case
2657  * occurs when a Var represents a whole tuple of a relation.
2658  */
2659 char *
2660 get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
2661 {
2662         if (attnum == InvalidAttrNumber)
2663                 return "*";
2664
2665         /*
2666          * If there is a user-written column alias, use it.
2667          */
2668         if (rte->alias &&
2669                 attnum > 0 && attnum <= list_length(rte->alias->colnames))
2670                 return strVal(list_nth(rte->alias->colnames, attnum - 1));
2671
2672         /*
2673          * If the RTE is a relation, go to the system catalogs not the
2674          * eref->colnames list.  This is a little slower but it will give the
2675          * right answer if the column has been renamed since the eref list was
2676          * built (which can easily happen for rules).
2677          */
2678         if (rte->rtekind == RTE_RELATION)
2679                 return get_relid_attribute_name(rte->relid, attnum);
2680
2681         /*
2682          * Otherwise use the column name from eref.  There should always be one.
2683          */
2684         if (attnum > 0 && attnum <= list_length(rte->eref->colnames))
2685                 return strVal(list_nth(rte->eref->colnames, attnum - 1));
2686
2687         /* else caller gave us a bogus attnum */
2688         elog(ERROR, "invalid attnum %d for rangetable entry %s",
2689                  attnum, rte->eref->aliasname);
2690         return NULL;                            /* keep compiler quiet */
2691 }
2692
2693 /*
2694  * get_rte_attribute_type
2695  *              Get attribute type/typmod/collation information from a RangeTblEntry
2696  */
2697 void
2698 get_rte_attribute_type(RangeTblEntry *rte, AttrNumber attnum,
2699                                            Oid *vartype, int32 *vartypmod, Oid *varcollid)
2700 {
2701         switch (rte->rtekind)
2702         {
2703                 case RTE_RELATION:
2704                         {
2705                                 /* Plain relation RTE --- get the attribute's type info */
2706                                 HeapTuple       tp;
2707                                 Form_pg_attribute att_tup;
2708
2709                                 tp = SearchSysCache2(ATTNUM,
2710                                                                          ObjectIdGetDatum(rte->relid),
2711                                                                          Int16GetDatum(attnum));
2712                                 if (!HeapTupleIsValid(tp))      /* shouldn't happen */
2713                                         elog(ERROR, "cache lookup failed for attribute %d of relation %u",
2714                                                  attnum, rte->relid);
2715                                 att_tup = (Form_pg_attribute) GETSTRUCT(tp);
2716
2717                                 /*
2718                                  * If dropped column, pretend it ain't there.  See notes in
2719                                  * scanRTEForColumn.
2720                                  */
2721                                 if (att_tup->attisdropped)
2722                                         ereport(ERROR,
2723                                                         (errcode(ERRCODE_UNDEFINED_COLUMN),
2724                                                          errmsg("column \"%s\" of relation \"%s\" does not exist",
2725                                                                         NameStr(att_tup->attname),
2726                                                                         get_rel_name(rte->relid))));
2727                                 *vartype = att_tup->atttypid;
2728                                 *vartypmod = att_tup->atttypmod;
2729                                 *varcollid = att_tup->attcollation;
2730                                 ReleaseSysCache(tp);
2731                         }
2732                         break;
2733                 case RTE_SUBQUERY:
2734                         {
2735                                 /* Subselect RTE --- get type info from subselect's tlist */
2736                                 TargetEntry *te = get_tle_by_resno(rte->subquery->targetList,
2737                                                                                                    attnum);
2738
2739                                 if (te == NULL || te->resjunk)
2740                                         elog(ERROR, "subquery %s does not have attribute %d",
2741                                                  rte->eref->aliasname, attnum);
2742                                 *vartype = exprType((Node *) te->expr);
2743                                 *vartypmod = exprTypmod((Node *) te->expr);
2744                                 *varcollid = exprCollation((Node *) te->expr);
2745                         }
2746                         break;
2747                 case RTE_FUNCTION:
2748                         {
2749                                 /* Function RTE */
2750                                 ListCell   *lc;
2751                                 int                     atts_done = 0;
2752
2753                                 /* Identify which function covers the requested column */
2754                                 foreach(lc, rte->functions)
2755                                 {
2756                                         RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
2757
2758                                         if (attnum > atts_done &&
2759                                                 attnum <= atts_done + rtfunc->funccolcount)
2760                                         {
2761                                                 TypeFuncClass functypclass;
2762                                                 Oid                     funcrettype;
2763                                                 TupleDesc       tupdesc;
2764
2765                                                 attnum -= atts_done;    /* now relative to this func */
2766                                                 functypclass = get_expr_result_type(rtfunc->funcexpr,
2767                                                                                                                         &funcrettype,
2768                                                                                                                         &tupdesc);
2769
2770                                                 if (functypclass == TYPEFUNC_COMPOSITE ||
2771                                                         functypclass == TYPEFUNC_COMPOSITE_DOMAIN)
2772                                                 {
2773                                                         /* Composite data type, e.g. a table's row type */
2774                                                         Form_pg_attribute att_tup;
2775
2776                                                         Assert(tupdesc);
2777                                                         Assert(attnum <= tupdesc->natts);
2778                                                         att_tup = TupleDescAttr(tupdesc, attnum - 1);
2779
2780                                                         /*
2781                                                          * If dropped column, pretend it ain't there.  See
2782                                                          * notes in scanRTEForColumn.
2783                                                          */
2784                                                         if (att_tup->attisdropped)
2785                                                                 ereport(ERROR,
2786                                                                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
2787                                                                                  errmsg("column \"%s\" of relation \"%s\" does not exist",
2788                                                                                                 NameStr(att_tup->attname),
2789                                                                                                 rte->eref->aliasname)));
2790                                                         *vartype = att_tup->atttypid;
2791                                                         *vartypmod = att_tup->atttypmod;
2792                                                         *varcollid = att_tup->attcollation;
2793                                                 }
2794                                                 else if (functypclass == TYPEFUNC_SCALAR)
2795                                                 {
2796                                                         /* Base data type, i.e. scalar */
2797                                                         *vartype = funcrettype;
2798                                                         *vartypmod = -1;
2799                                                         *varcollid = exprCollation(rtfunc->funcexpr);
2800                                                 }
2801                                                 else if (functypclass == TYPEFUNC_RECORD)
2802                                                 {
2803                                                         *vartype = list_nth_oid(rtfunc->funccoltypes,
2804                                                                                                         attnum - 1);
2805                                                         *vartypmod = list_nth_int(rtfunc->funccoltypmods,
2806                                                                                                           attnum - 1);
2807                                                         *varcollid = list_nth_oid(rtfunc->funccolcollations,
2808                                                                                                           attnum - 1);
2809                                                 }
2810                                                 else
2811                                                 {
2812                                                         /*
2813                                                          * addRangeTableEntryForFunction should've caught
2814                                                          * this
2815                                                          */
2816                                                         elog(ERROR, "function in FROM has unsupported return type");
2817                                                 }
2818                                                 return;
2819                                         }
2820                                         atts_done += rtfunc->funccolcount;
2821                                 }
2822
2823                                 /* If we get here, must be looking for the ordinality column */
2824                                 if (rte->funcordinality && attnum == atts_done + 1)
2825                                 {
2826                                         *vartype = INT8OID;
2827                                         *vartypmod = -1;
2828                                         *varcollid = InvalidOid;
2829                                         return;
2830                                 }
2831
2832                                 /* this probably can't happen ... */
2833                                 ereport(ERROR,
2834                                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
2835                                                  errmsg("column %d of relation \"%s\" does not exist",
2836                                                                 attnum,
2837                                                                 rte->eref->aliasname)));
2838                         }
2839                         break;
2840                 case RTE_JOIN:
2841                         {
2842                                 /*
2843                                  * Join RTE --- get type info from join RTE's alias variable
2844                                  */
2845                                 Node       *aliasvar;
2846
2847                                 Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars));
2848                                 aliasvar = (Node *) list_nth(rte->joinaliasvars, attnum - 1);
2849                                 Assert(aliasvar != NULL);
2850                                 *vartype = exprType(aliasvar);
2851                                 *vartypmod = exprTypmod(aliasvar);
2852                                 *varcollid = exprCollation(aliasvar);
2853                         }
2854                         break;
2855                 case RTE_TABLEFUNC:
2856                 case RTE_VALUES:
2857                 case RTE_CTE:
2858                 case RTE_NAMEDTUPLESTORE:
2859                         {
2860                                 /*
2861                                  * tablefunc, VALUES, CTE, or ENR RTE --- get type info from
2862                                  * lists in the RTE
2863                                  */
2864                                 Assert(attnum > 0 && attnum <= list_length(rte->coltypes));
2865                                 *vartype = list_nth_oid(rte->coltypes, attnum - 1);
2866                                 *vartypmod = list_nth_int(rte->coltypmods, attnum - 1);
2867                                 *varcollid = list_nth_oid(rte->colcollations, attnum - 1);
2868
2869                                 /* For ENR, better check for dropped column */
2870                                 if (!OidIsValid(*vartype))
2871                                         ereport(ERROR,
2872                                                         (errcode(ERRCODE_UNDEFINED_COLUMN),
2873                                                          errmsg("column %d of relation \"%s\" does not exist",
2874                                                                         attnum,
2875                                                                         rte->eref->aliasname)));
2876                         }
2877                         break;
2878                 default:
2879                         elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
2880         }
2881 }
2882
2883 /*
2884  * get_rte_attribute_is_dropped
2885  *              Check whether attempted attribute ref is to a dropped column
2886  */
2887 bool
2888 get_rte_attribute_is_dropped(RangeTblEntry *rte, AttrNumber attnum)
2889 {
2890         bool            result;
2891
2892         switch (rte->rtekind)
2893         {
2894                 case RTE_RELATION:
2895                         {
2896                                 /*
2897                                  * Plain relation RTE --- get the attribute's catalog entry
2898                                  */
2899                                 HeapTuple       tp;
2900                                 Form_pg_attribute att_tup;
2901
2902                                 tp = SearchSysCache2(ATTNUM,
2903                                                                          ObjectIdGetDatum(rte->relid),
2904                                                                          Int16GetDatum(attnum));
2905                                 if (!HeapTupleIsValid(tp))      /* shouldn't happen */
2906                                         elog(ERROR, "cache lookup failed for attribute %d of relation %u",
2907                                                  attnum, rte->relid);
2908                                 att_tup = (Form_pg_attribute) GETSTRUCT(tp);
2909                                 result = att_tup->attisdropped;
2910                                 ReleaseSysCache(tp);
2911                         }
2912                         break;
2913                 case RTE_SUBQUERY:
2914                 case RTE_TABLEFUNC:
2915                 case RTE_VALUES:
2916                 case RTE_CTE:
2917
2918                         /*
2919                          * Subselect, Table Functions, Values, CTE RTEs never have dropped
2920                          * columns
2921                          */
2922                         result = false;
2923                         break;
2924                 case RTE_NAMEDTUPLESTORE:
2925                         {
2926                                 /* Check dropped-ness by testing for valid coltype */
2927                                 if (attnum <= 0 ||
2928                                         attnum > list_length(rte->coltypes))
2929                                         elog(ERROR, "invalid varattno %d", attnum);
2930                                 result = !OidIsValid((list_nth_oid(rte->coltypes, attnum - 1)));
2931                         }
2932                         break;
2933                 case RTE_JOIN:
2934                         {
2935                                 /*
2936                                  * A join RTE would not have dropped columns when constructed,
2937                                  * but one in a stored rule might contain columns that were
2938                                  * dropped from the underlying tables, if said columns are
2939                                  * nowhere explicitly referenced in the rule.  This will be
2940                                  * signaled to us by a null pointer in the joinaliasvars list.
2941                                  */
2942                                 Var                *aliasvar;
2943
2944                                 if (attnum <= 0 ||
2945                                         attnum > list_length(rte->joinaliasvars))
2946                                         elog(ERROR, "invalid varattno %d", attnum);
2947                                 aliasvar = (Var *) list_nth(rte->joinaliasvars, attnum - 1);
2948
2949                                 result = (aliasvar == NULL);
2950                         }
2951                         break;
2952                 case RTE_FUNCTION:
2953                         {
2954                                 /* Function RTE */
2955                                 ListCell   *lc;
2956                                 int                     atts_done = 0;
2957
2958                                 /*
2959                                  * Dropped attributes are only possible with functions that
2960                                  * return named composite types.  In such a case we have to
2961                                  * look up the result type to see if it currently has this
2962                                  * column dropped.  So first, loop over the funcs until we
2963                                  * find the one that covers the requested column.
2964                                  */
2965                                 foreach(lc, rte->functions)
2966                                 {
2967                                         RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
2968
2969                                         if (attnum > atts_done &&
2970                                                 attnum <= atts_done + rtfunc->funccolcount)
2971                                         {
2972                                                 TupleDesc       tupdesc;
2973
2974                                                 tupdesc = get_expr_result_tupdesc(rtfunc->funcexpr,
2975                                                                                                                   true);
2976                                                 if (tupdesc)
2977                                                 {
2978                                                         /* Composite data type, e.g. a table's row type */
2979                                                         Form_pg_attribute att_tup;
2980
2981                                                         Assert(tupdesc);
2982                                                         Assert(attnum - atts_done <= tupdesc->natts);
2983                                                         att_tup = TupleDescAttr(tupdesc,
2984                                                                                                         attnum - atts_done - 1);
2985                                                         return att_tup->attisdropped;
2986                                                 }
2987                                                 /* Otherwise, it can't have any dropped columns */
2988                                                 return false;
2989                                         }
2990                                         atts_done += rtfunc->funccolcount;
2991                                 }
2992
2993                                 /* If we get here, must be looking for the ordinality column */
2994                                 if (rte->funcordinality && attnum == atts_done + 1)
2995                                         return false;
2996
2997                                 /* this probably can't happen ... */
2998                                 ereport(ERROR,
2999                                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
3000                                                  errmsg("column %d of relation \"%s\" does not exist",
3001                                                                 attnum,
3002                                                                 rte->eref->aliasname)));
3003                                 result = false; /* keep compiler quiet */
3004                         }
3005                         break;
3006                 default:
3007                         elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind);
3008                         result = false;         /* keep compiler quiet */
3009         }
3010
3011         return result;
3012 }
3013
3014 /*
3015  * Given a targetlist and a resno, return the matching TargetEntry
3016  *
3017  * Returns NULL if resno is not present in list.
3018  *
3019  * Note: we need to search, rather than just indexing with list_nth(),
3020  * because not all tlists are sorted by resno.
3021  */
3022 TargetEntry *
3023 get_tle_by_resno(List *tlist, AttrNumber resno)
3024 {
3025         ListCell   *l;
3026
3027         foreach(l, tlist)
3028         {
3029                 TargetEntry *tle = (TargetEntry *) lfirst(l);
3030
3031                 if (tle->resno == resno)
3032                         return tle;
3033         }
3034         return NULL;
3035 }
3036
3037 /*
3038  * Given a Query and rangetable index, return relation's RowMarkClause if any
3039  *
3040  * Returns NULL if relation is not selected FOR UPDATE/SHARE
3041  */
3042 RowMarkClause *
3043 get_parse_rowmark(Query *qry, Index rtindex)
3044 {
3045         ListCell   *l;
3046
3047         foreach(l, qry->rowMarks)
3048         {
3049                 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
3050
3051                 if (rc->rti == rtindex)
3052                         return rc;
3053         }
3054         return NULL;
3055 }
3056
3057 /*
3058  *      given relation and att name, return attnum of variable
3059  *
3060  *      Returns InvalidAttrNumber if the attr doesn't exist (or is dropped).
3061  *
3062  *      This should only be used if the relation is already
3063  *      heap_open()'ed.  Use the cache version get_attnum()
3064  *      for access to non-opened relations.
3065  */
3066 int
3067 attnameAttNum(Relation rd, const char *attname, bool sysColOK)
3068 {
3069         int                     i;
3070
3071         for (i = 0; i < rd->rd_rel->relnatts; i++)
3072         {
3073                 Form_pg_attribute att = TupleDescAttr(rd->rd_att, i);
3074
3075                 if (namestrcmp(&(att->attname), attname) == 0 && !att->attisdropped)
3076                         return i + 1;
3077         }
3078
3079         if (sysColOK)
3080         {
3081                 if ((i = specialAttNum(attname)) != InvalidAttrNumber)
3082                 {
3083                         if (i != ObjectIdAttributeNumber || rd->rd_rel->relhasoids)
3084                                 return i;
3085                 }
3086         }
3087
3088         /* on failure */
3089         return InvalidAttrNumber;
3090 }
3091
3092 /* specialAttNum()
3093  *
3094  * Check attribute name to see if it is "special", e.g. "oid".
3095  * - thomas 2000-02-07
3096  *
3097  * Note: this only discovers whether the name could be a system attribute.
3098  * Caller needs to verify that it really is an attribute of the rel,
3099  * at least in the case of "oid", which is now optional.
3100  */
3101 static int
3102 specialAttNum(const char *attname)
3103 {
3104         Form_pg_attribute sysatt;
3105
3106         sysatt = SystemAttributeByName(attname,
3107                                                                    true /* "oid" will be accepted */ );
3108         if (sysatt != NULL)
3109                 return sysatt->attnum;
3110         return InvalidAttrNumber;
3111 }
3112
3113
3114 /*
3115  * given attribute id, return name of that attribute
3116  *
3117  *      This should only be used if the relation is already
3118  *      heap_open()'ed.  Use the cache version get_atttype()
3119  *      for access to non-opened relations.
3120  */
3121 Name
3122 attnumAttName(Relation rd, int attid)
3123 {
3124         if (attid <= 0)
3125         {
3126                 Form_pg_attribute sysatt;
3127
3128                 sysatt = SystemAttributeDefinition(attid, rd->rd_rel->relhasoids);
3129                 return &sysatt->attname;
3130         }
3131         if (attid > rd->rd_att->natts)
3132                 elog(ERROR, "invalid attribute number %d", attid);
3133         return &TupleDescAttr(rd->rd_att, attid - 1)->attname;
3134 }
3135
3136 /*
3137  * given attribute id, return type of that attribute
3138  *
3139  *      This should only be used if the relation is already
3140  *      heap_open()'ed.  Use the cache version get_atttype()
3141  *      for access to non-opened relations.
3142  */
3143 Oid
3144 attnumTypeId(Relation rd, int attid)
3145 {
3146         if (attid <= 0)
3147         {
3148                 Form_pg_attribute sysatt;
3149
3150                 sysatt = SystemAttributeDefinition(attid, rd->rd_rel->relhasoids);
3151                 return sysatt->atttypid;
3152         }
3153         if (attid > rd->rd_att->natts)
3154                 elog(ERROR, "invalid attribute number %d", attid);
3155         return TupleDescAttr(rd->rd_att, attid - 1)->atttypid;
3156 }
3157
3158 /*
3159  * given attribute id, return collation of that attribute
3160  *
3161  *      This should only be used if the relation is already heap_open()'ed.
3162  */
3163 Oid
3164 attnumCollationId(Relation rd, int attid)
3165 {
3166         if (attid <= 0)
3167         {
3168                 /* All system attributes are of noncollatable types. */
3169                 return InvalidOid;
3170         }
3171         if (attid > rd->rd_att->natts)
3172                 elog(ERROR, "invalid attribute number %d", attid);
3173         return TupleDescAttr(rd->rd_att, attid - 1)->attcollation;
3174 }
3175
3176 /*
3177  * Generate a suitable error about a missing RTE.
3178  *
3179  * Since this is a very common type of error, we work rather hard to
3180  * produce a helpful message.
3181  */
3182 void
3183 errorMissingRTE(ParseState *pstate, RangeVar *relation)
3184 {
3185         RangeTblEntry *rte;
3186         int                     sublevels_up;
3187         const char *badAlias = NULL;
3188
3189         /*
3190          * Check to see if there are any potential matches in the query's
3191          * rangetable.  (Note: cases involving a bad schema name in the RangeVar
3192          * will throw error immediately here.  That seems OK.)
3193          */
3194         rte = searchRangeTableForRel(pstate, relation);
3195
3196         /*
3197          * If we found a match that has an alias and the alias is visible in the
3198          * namespace, then the problem is probably use of the relation's real name
3199          * instead of its alias, ie "SELECT foo.* FROM foo f". This mistake is
3200          * common enough to justify a specific hint.
3201          *
3202          * If we found a match that doesn't meet those criteria, assume the
3203          * problem is illegal use of a relation outside its scope, as in the
3204          * MySQL-ism "SELECT ... FROM a, b LEFT JOIN c ON (a.x = c.y)".
3205          */
3206         if (rte && rte->alias &&
3207                 strcmp(rte->eref->aliasname, relation->relname) != 0 &&
3208                 refnameRangeTblEntry(pstate, NULL, rte->eref->aliasname,
3209                                                          relation->location,
3210                                                          &sublevels_up) == rte)
3211                 badAlias = rte->eref->aliasname;
3212
3213         if (rte)
3214                 ereport(ERROR,
3215                                 (errcode(ERRCODE_UNDEFINED_TABLE),
3216                                  errmsg("invalid reference to FROM-clause entry for table \"%s\"",
3217                                                 relation->relname),
3218                                  (badAlias ?
3219                                   errhint("Perhaps you meant to reference the table alias \"%s\".",
3220                                                   badAlias) :
3221                                   errhint("There is an entry for table \"%s\", but it cannot be referenced from this part of the query.",
3222                                                   rte->eref->aliasname)),
3223                                  parser_errposition(pstate, relation->location)));
3224         else
3225                 ereport(ERROR,
3226                                 (errcode(ERRCODE_UNDEFINED_TABLE),
3227                                  errmsg("missing FROM-clause entry for table \"%s\"",
3228                                                 relation->relname),
3229                                  parser_errposition(pstate, relation->location)));
3230 }
3231
3232 /*
3233  * Generate a suitable error about a missing column.
3234  *
3235  * Since this is a very common type of error, we work rather hard to
3236  * produce a helpful message.
3237  */
3238 void
3239 errorMissingColumn(ParseState *pstate,
3240                                    char *relname, char *colname, int location)
3241 {
3242         FuzzyAttrMatchState *state;
3243         char       *closestfirst = NULL;
3244
3245         /*
3246          * Search the entire rtable looking for possible matches.  If we find one,
3247          * emit a hint about it.
3248          *
3249          * TODO: improve this code (and also errorMissingRTE) to mention using
3250          * LATERAL if appropriate.
3251          */
3252         state = searchRangeTableForCol(pstate, relname, colname, location);
3253
3254         /*
3255          * Extract closest col string for best match, if any.
3256          *
3257          * Infer an exact match referenced despite not being visible from the fact
3258          * that an attribute number was not present in state passed back -- this
3259          * is what is reported when !closestfirst.  There might also be an exact
3260          * match that was qualified with an incorrect alias, in which case
3261          * closestfirst will be set (so hint is the same as generic fuzzy case).
3262          */
3263         if (state->rfirst && AttributeNumberIsValid(state->first))
3264                 closestfirst = strVal(list_nth(state->rfirst->eref->colnames,
3265                                                                            state->first - 1));
3266
3267         if (!state->rsecond)
3268         {
3269                 /*
3270                  * Handle case where there is zero or one column suggestions to hint,
3271                  * including exact matches referenced but not visible.
3272                  */
3273                 ereport(ERROR,
3274                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
3275                                  relname ?
3276                                  errmsg("column %s.%s does not exist", relname, colname) :
3277                                  errmsg("column \"%s\" does not exist", colname),
3278                                  state->rfirst ? closestfirst ?
3279                                  errhint("Perhaps you meant to reference the column \"%s.%s\".",
3280                                                  state->rfirst->eref->aliasname, closestfirst) :
3281                                  errhint("There is a column named \"%s\" in table \"%s\", but it cannot be referenced from this part of the query.",
3282                                                  colname, state->rfirst->eref->aliasname) : 0,
3283                                  parser_errposition(pstate, location)));
3284         }
3285         else
3286         {
3287                 /* Handle case where there are two equally useful column hints */
3288                 char       *closestsecond;
3289
3290                 closestsecond = strVal(list_nth(state->rsecond->eref->colnames,
3291                                                                                 state->second - 1));
3292
3293                 ereport(ERROR,
3294                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
3295                                  relname ?
3296                                  errmsg("column %s.%s does not exist", relname, colname) :
3297                                  errmsg("column \"%s\" does not exist", colname),
3298                                  errhint("Perhaps you meant to reference the column \"%s.%s\" or the column \"%s.%s\".",
3299                                                  state->rfirst->eref->aliasname, closestfirst,
3300                                                  state->rsecond->eref->aliasname, closestsecond),
3301                                  parser_errposition(pstate, location)));
3302         }
3303 }
3304
3305
3306 /*
3307  * Examine a fully-parsed query, and return TRUE iff any relation underlying
3308  * the query is a temporary relation (table, view, or materialized view).
3309  */
3310 bool
3311 isQueryUsingTempRelation(Query *query)
3312 {
3313         return isQueryUsingTempRelation_walker((Node *) query, NULL);
3314 }
3315
3316 static bool
3317 isQueryUsingTempRelation_walker(Node *node, void *context)
3318 {
3319         if (node == NULL)
3320                 return false;
3321
3322         if (IsA(node, Query))
3323         {
3324                 Query      *query = (Query *) node;
3325                 ListCell   *rtable;
3326
3327                 foreach(rtable, query->rtable)
3328                 {
3329                         RangeTblEntry *rte = lfirst(rtable);
3330
3331                         if (rte->rtekind == RTE_RELATION)
3332                         {
3333                                 Relation        rel = heap_open(rte->relid, AccessShareLock);
3334                                 char            relpersistence = rel->rd_rel->relpersistence;
3335
3336                                 heap_close(rel, AccessShareLock);
3337                                 if (relpersistence == RELPERSISTENCE_TEMP)
3338                                         return true;
3339                         }
3340                 }
3341
3342                 return query_tree_walker(query,
3343                                                                  isQueryUsingTempRelation_walker,
3344                                                                  context,
3345                                                                  QTW_IGNORE_JOINALIASES);
3346         }
3347
3348         return expression_tree_walker(node,
3349                                                                   isQueryUsingTempRelation_walker,
3350                                                                   context);
3351 }