PostgreSQL Source Code  git master
parse_target.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * parse_target.c
4  * handle target lists
5  *
6  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/parser/parse_target.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include "catalog/pg_type.h"
18 #include "commands/dbcommands.h"
19 #include "funcapi.h"
20 #include "miscadmin.h"
21 #include "nodes/makefuncs.h"
22 #include "nodes/nodeFuncs.h"
23 #include "parser/parse_coerce.h"
24 #include "parser/parse_expr.h"
25 #include "parser/parse_func.h"
26 #include "parser/parse_relation.h"
27 #include "parser/parse_target.h"
28 #include "parser/parse_type.h"
29 #include "parser/parsetree.h"
30 #include "utils/builtins.h"
31 #include "utils/lsyscache.h"
32 #include "utils/rel.h"
33 #include "utils/typcache.h"
34 
35 static void markTargetListOrigin(ParseState *pstate, TargetEntry *tle,
36  Var *var, int levelsup);
38  Node *basenode,
39  const char *targetName,
40  Oid targetTypeId,
41  int32 targetTypMod,
42  Oid targetCollation,
43  List *subscripts,
44  bool isSlice,
45  List *indirection,
46  ListCell *next_indirection,
47  Node *rhs,
48  CoercionContext ccontext,
49  int location);
50 static List *ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref,
51  bool make_target_entry);
52 static List *ExpandAllTables(ParseState *pstate, int location);
54  bool make_target_entry, ParseExprKind exprKind);
55 static List *ExpandSingleTable(ParseState *pstate, ParseNamespaceItem *nsitem,
56  int sublevels_up, int location,
57  bool make_target_entry);
58 static List *ExpandRowReference(ParseState *pstate, Node *expr,
59  bool make_target_entry);
60 static int FigureColnameInternal(Node *node, char **name);
61 
62 
63 /*
64  * transformTargetEntry()
65  * Transform any ordinary "expression-type" node into a targetlist entry.
66  * This is exported so that parse_clause.c can generate targetlist entries
67  * for ORDER/GROUP BY items that are not already in the targetlist.
68  *
69  * node the (untransformed) parse tree for the value expression.
70  * expr the transformed expression, or NULL if caller didn't do it yet.
71  * exprKind expression kind (EXPR_KIND_SELECT_TARGET, etc)
72  * colname the column name to be assigned, or NULL if none yet set.
73  * resjunk true if the target should be marked resjunk, ie, it is not
74  * wanted in the final projected tuple.
75  */
78  Node *node,
79  Node *expr,
80  ParseExprKind exprKind,
81  char *colname,
82  bool resjunk)
83 {
84  /* Transform the node if caller didn't do it already */
85  if (expr == NULL)
86  {
87  /*
88  * If it's a SetToDefault node and we should allow that, pass it
89  * through unmodified. (transformExpr will throw the appropriate
90  * error if we're disallowing it.)
91  */
92  if (exprKind == EXPR_KIND_UPDATE_SOURCE && IsA(node, SetToDefault))
93  expr = node;
94  else
95  expr = transformExpr(pstate, node, exprKind);
96  }
97 
98  if (colname == NULL && !resjunk)
99  {
100  /*
101  * Generate a suitable column name for a column without any explicit
102  * 'AS ColumnName' clause.
103  */
104  colname = FigureColname(node);
105  }
106 
107  return makeTargetEntry((Expr *) expr,
108  (AttrNumber) pstate->p_next_resno++,
109  colname,
110  resjunk);
111 }
112 
113 
114 /*
115  * transformTargetList()
116  * Turns a list of ResTarget's into a list of TargetEntry's.
117  *
118  * This code acts mostly the same for SELECT, UPDATE, or RETURNING lists;
119  * the main thing is to transform the given expressions (the "val" fields).
120  * The exprKind parameter distinguishes these cases when necessary.
121  */
122 List *
123 transformTargetList(ParseState *pstate, List *targetlist,
124  ParseExprKind exprKind)
125 {
126  List *p_target = NIL;
127  bool expand_star;
128  ListCell *o_target;
129 
130  /* Shouldn't have any leftover multiassign items at start */
131  Assert(pstate->p_multiassign_exprs == NIL);
132 
133  /* Expand "something.*" in SELECT and RETURNING, but not UPDATE */
134  expand_star = (exprKind != EXPR_KIND_UPDATE_SOURCE);
135 
136  foreach(o_target, targetlist)
137  {
138  ResTarget *res = (ResTarget *) lfirst(o_target);
139 
140  /*
141  * Check for "something.*". Depending on the complexity of the
142  * "something", the star could appear as the last field in ColumnRef,
143  * or as the last indirection item in A_Indirection.
144  */
145  if (expand_star)
146  {
147  if (IsA(res->val, ColumnRef))
148  {
149  ColumnRef *cref = (ColumnRef *) res->val;
150 
151  if (IsA(llast(cref->fields), A_Star))
152  {
153  /* It is something.*, expand into multiple items */
154  p_target = list_concat(p_target,
155  ExpandColumnRefStar(pstate,
156  cref,
157  true));
158  continue;
159  }
160  }
161  else if (IsA(res->val, A_Indirection))
162  {
163  A_Indirection *ind = (A_Indirection *) res->val;
164 
165  if (IsA(llast(ind->indirection), A_Star))
166  {
167  /* It is something.*, expand into multiple items */
168  p_target = list_concat(p_target,
169  ExpandIndirectionStar(pstate,
170  ind,
171  true,
172  exprKind));
173  continue;
174  }
175  }
176  }
177 
178  /*
179  * Not "something.*", or we want to treat that as a plain whole-row
180  * variable, so transform as a single expression
181  */
182  p_target = lappend(p_target,
183  transformTargetEntry(pstate,
184  res->val,
185  NULL,
186  exprKind,
187  res->name,
188  false));
189  }
190 
191  /*
192  * If any multiassign resjunk items were created, attach them to the end
193  * of the targetlist. This should only happen in an UPDATE tlist. We
194  * don't need to worry about numbering of these items; transformUpdateStmt
195  * will set their resnos.
196  */
197  if (pstate->p_multiassign_exprs)
198  {
199  Assert(exprKind == EXPR_KIND_UPDATE_SOURCE);
200  p_target = list_concat(p_target, pstate->p_multiassign_exprs);
201  pstate->p_multiassign_exprs = NIL;
202  }
203 
204  return p_target;
205 }
206 
207 
208 /*
209  * transformExpressionList()
210  *
211  * This is the identical transformation to transformTargetList, except that
212  * the input list elements are bare expressions without ResTarget decoration,
213  * and the output elements are likewise just expressions without TargetEntry
214  * decoration. Also, we don't expect any multiassign constructs within the
215  * list, so there's nothing to do for that. We use this for ROW() and
216  * VALUES() constructs.
217  *
218  * exprKind is not enough to tell us whether to allow SetToDefault, so
219  * an additional flag is needed for that.
220  */
221 List *
223  ParseExprKind exprKind, bool allowDefault)
224 {
225  List *result = NIL;
226  ListCell *lc;
227 
228  foreach(lc, exprlist)
229  {
230  Node *e = (Node *) lfirst(lc);
231 
232  /*
233  * Check for "something.*". Depending on the complexity of the
234  * "something", the star could appear as the last field in ColumnRef,
235  * or as the last indirection item in A_Indirection.
236  */
237  if (IsA(e, ColumnRef))
238  {
239  ColumnRef *cref = (ColumnRef *) e;
240 
241  if (IsA(llast(cref->fields), A_Star))
242  {
243  /* It is something.*, expand into multiple items */
244  result = list_concat(result,
245  ExpandColumnRefStar(pstate, cref,
246  false));
247  continue;
248  }
249  }
250  else if (IsA(e, A_Indirection))
251  {
253 
254  if (IsA(llast(ind->indirection), A_Star))
255  {
256  /* It is something.*, expand into multiple items */
257  result = list_concat(result,
258  ExpandIndirectionStar(pstate, ind,
259  false, exprKind));
260  continue;
261  }
262  }
263 
264  /*
265  * Not "something.*", so transform as a single expression. If it's a
266  * SetToDefault node and we should allow that, pass it through
267  * unmodified. (transformExpr will throw the appropriate error if
268  * we're disallowing it.)
269  */
270  if (allowDefault && IsA(e, SetToDefault))
271  /* do nothing */ ;
272  else
273  e = transformExpr(pstate, e, exprKind);
274 
275  result = lappend(result, e);
276  }
277 
278  return result;
279 }
280 
281 
282 /*
283  * resolveTargetListUnknowns()
284  * Convert any unknown-type targetlist entries to type TEXT.
285  *
286  * We do this after we've exhausted all other ways of identifying the output
287  * column types of a query.
288  */
289 void
291 {
292  ListCell *l;
293 
294  foreach(l, targetlist)
295  {
296  TargetEntry *tle = (TargetEntry *) lfirst(l);
297  Oid restype = exprType((Node *) tle->expr);
298 
299  if (restype == UNKNOWNOID)
300  {
301  tle->expr = (Expr *) coerce_type(pstate, (Node *) tle->expr,
302  restype, TEXTOID, -1,
305  -1);
306  }
307  }
308 }
309 
310 
311 /*
312  * markTargetListOrigins()
313  * Mark targetlist columns that are simple Vars with the source
314  * table's OID and column number.
315  *
316  * Currently, this is done only for SELECT targetlists and RETURNING lists,
317  * since we only need the info if we are going to send it to the frontend.
318  */
319 void
320 markTargetListOrigins(ParseState *pstate, List *targetlist)
321 {
322  ListCell *l;
323 
324  foreach(l, targetlist)
325  {
326  TargetEntry *tle = (TargetEntry *) lfirst(l);
327 
328  markTargetListOrigin(pstate, tle, (Var *) tle->expr, 0);
329  }
330 }
331 
332 /*
333  * markTargetListOrigin()
334  * If 'var' is a Var of a plain relation, mark 'tle' with its origin
335  *
336  * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
337  *
338  * Note that we do not drill down into views, but report the view as the
339  * column owner. There's also no need to drill down into joins: if we see
340  * a join alias Var, it must be a merged JOIN USING column (or possibly a
341  * whole-row Var); that is not a direct reference to any plain table column,
342  * so we don't report it.
343  */
344 static void
346  Var *var, int levelsup)
347 {
348  int netlevelsup;
349  RangeTblEntry *rte;
351 
352  if (var == NULL || !IsA(var, Var))
353  return;
354  netlevelsup = var->varlevelsup + levelsup;
355  rte = GetRTEByRangeTablePosn(pstate, var->varno, netlevelsup);
356  attnum = var->varattno;
357 
358  switch (rte->rtekind)
359  {
360  case RTE_RELATION:
361  /* It's a table or view, report it */
362  tle->resorigtbl = rte->relid;
363  tle->resorigcol = attnum;
364  break;
365  case RTE_SUBQUERY:
366  /* Subselect-in-FROM: copy up from the subselect */
367  if (attnum != InvalidAttrNumber)
368  {
370  attnum);
371 
372  if (ste == NULL || ste->resjunk)
373  elog(ERROR, "subquery %s does not have attribute %d",
374  rte->eref->aliasname, attnum);
375  tle->resorigtbl = ste->resorigtbl;
376  tle->resorigcol = ste->resorigcol;
377  }
378  break;
379  case RTE_JOIN:
380  case RTE_FUNCTION:
381  case RTE_VALUES:
382  case RTE_TABLEFUNC:
383  case RTE_NAMEDTUPLESTORE:
384  case RTE_RESULT:
385  /* not a simple relation, leave it unmarked */
386  break;
387  case RTE_CTE:
388 
389  /*
390  * CTE reference: copy up from the subquery, if possible. If the
391  * RTE is a recursive self-reference then we can't do anything
392  * because we haven't finished analyzing it yet. However, it's no
393  * big loss because we must be down inside the recursive term of a
394  * recursive CTE, and so any markings on the current targetlist
395  * are not going to affect the results anyway.
396  */
397  if (attnum != InvalidAttrNumber && !rte->self_reference)
398  {
399  CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup);
400  TargetEntry *ste;
401  List *tl = GetCTETargetList(cte);
402  int extra_cols = 0;
403 
404  /*
405  * RTE for CTE will already have the search and cycle columns
406  * added, but the subquery won't, so skip looking those up.
407  */
408  if (cte->search_clause)
409  extra_cols += 1;
410  if (cte->cycle_clause)
411  extra_cols += 2;
412  if (extra_cols &&
413  attnum > list_length(tl) &&
414  attnum <= list_length(tl) + extra_cols)
415  break;
416 
417  ste = get_tle_by_resno(tl, attnum);
418  if (ste == NULL || ste->resjunk)
419  elog(ERROR, "CTE %s does not have attribute %d",
420  rte->eref->aliasname, attnum);
421  tle->resorigtbl = ste->resorigtbl;
422  tle->resorigcol = ste->resorigcol;
423  }
424  break;
425  }
426 }
427 
428 
429 /*
430  * transformAssignedExpr()
431  * This is used in INSERT and UPDATE statements only. It prepares an
432  * expression for assignment to a column of the target table.
433  * This includes coercing the given value to the target column's type
434  * (if necessary), and dealing with any subfield names or subscripts
435  * attached to the target column itself. The input expression has
436  * already been through transformExpr().
437  *
438  * pstate parse state
439  * expr expression to be modified
440  * exprKind indicates which type of statement we're dealing with
441  * colname target column name (ie, name of attribute to be assigned to)
442  * attrno target attribute number
443  * indirection subscripts/field names for target column, if any
444  * location error cursor position for the target column, or -1
445  *
446  * Returns the modified expression.
447  *
448  * Note: location points at the target column name (SET target or INSERT
449  * column name list entry), and must therefore be -1 in an INSERT that
450  * omits the column name list. So we should usually prefer to use
451  * exprLocation(expr) for errors that can happen in a default INSERT.
452  */
453 Expr *
455  Expr *expr,
456  ParseExprKind exprKind,
457  const char *colname,
458  int attrno,
459  List *indirection,
460  int location)
461 {
462  Relation rd = pstate->p_target_relation;
463  Oid type_id; /* type of value provided */
464  Oid attrtype; /* type of target column */
465  int32 attrtypmod;
466  Oid attrcollation; /* collation of target column */
467  ParseExprKind sv_expr_kind;
468 
469  /*
470  * Save and restore identity of expression type we're parsing. We must
471  * set p_expr_kind here because we can parse subscripts without going
472  * through transformExpr().
473  */
474  Assert(exprKind != EXPR_KIND_NONE);
475  sv_expr_kind = pstate->p_expr_kind;
476  pstate->p_expr_kind = exprKind;
477 
478  Assert(rd != NULL);
479  if (attrno <= 0)
480  ereport(ERROR,
481  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
482  errmsg("cannot assign to system column \"%s\"",
483  colname),
484  parser_errposition(pstate, location)));
485  attrtype = attnumTypeId(rd, attrno);
486  attrtypmod = TupleDescAttr(rd->rd_att, attrno - 1)->atttypmod;
487  attrcollation = TupleDescAttr(rd->rd_att, attrno - 1)->attcollation;
488 
489  /*
490  * If the expression is a DEFAULT placeholder, insert the attribute's
491  * type/typmod/collation into it so that exprType etc will report the
492  * right things. (We expect that the eventually substituted default
493  * expression will in fact have this type and typmod. The collation
494  * likely doesn't matter, but let's set it correctly anyway.) Also,
495  * reject trying to update a subfield or array element with DEFAULT, since
496  * there can't be any default for portions of a column.
497  */
498  if (expr && IsA(expr, SetToDefault))
499  {
500  SetToDefault *def = (SetToDefault *) expr;
501 
502  def->typeId = attrtype;
503  def->typeMod = attrtypmod;
504  def->collation = attrcollation;
505  if (indirection)
506  {
507  if (IsA(linitial(indirection), A_Indices))
508  ereport(ERROR,
509  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
510  errmsg("cannot set an array element to DEFAULT"),
511  parser_errposition(pstate, location)));
512  else
513  ereport(ERROR,
514  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
515  errmsg("cannot set a subfield to DEFAULT"),
516  parser_errposition(pstate, location)));
517  }
518  }
519 
520  /* Now we can use exprType() safely. */
521  type_id = exprType((Node *) expr);
522 
523  /*
524  * If there is indirection on the target column, prepare an array or
525  * subfield assignment expression. This will generate a new column value
526  * that the source value has been inserted into, which can then be placed
527  * in the new tuple constructed by INSERT or UPDATE.
528  */
529  if (indirection)
530  {
531  Node *colVar;
532 
533  if (pstate->p_is_insert)
534  {
535  /*
536  * The command is INSERT INTO table (col.something) ... so there
537  * is not really a source value to work with. Insert a NULL
538  * constant as the source value.
539  */
540  colVar = (Node *) makeNullConst(attrtype, attrtypmod,
541  attrcollation);
542  }
543  else
544  {
545  /*
546  * Build a Var for the column to be updated.
547  */
548  Var *var;
549 
550  var = makeVar(pstate->p_target_nsitem->p_rtindex, attrno,
551  attrtype, attrtypmod, attrcollation, 0);
552  var->location = location;
553 
554  colVar = (Node *) var;
555  }
556 
557  expr = (Expr *)
559  colVar,
560  colname,
561  false,
562  attrtype,
563  attrtypmod,
564  attrcollation,
565  indirection,
566  list_head(indirection),
567  (Node *) expr,
569  location);
570  }
571  else
572  {
573  /*
574  * For normal non-qualified target column, do type checking and
575  * coercion.
576  */
577  Node *orig_expr = (Node *) expr;
578 
579  expr = (Expr *)
580  coerce_to_target_type(pstate,
581  orig_expr, type_id,
582  attrtype, attrtypmod,
585  -1);
586  if (expr == NULL)
587  ereport(ERROR,
588  (errcode(ERRCODE_DATATYPE_MISMATCH),
589  errmsg("column \"%s\" is of type %s"
590  " but expression is of type %s",
591  colname,
592  format_type_be(attrtype),
593  format_type_be(type_id)),
594  errhint("You will need to rewrite or cast the expression."),
595  parser_errposition(pstate, exprLocation(orig_expr))));
596  }
597 
598  pstate->p_expr_kind = sv_expr_kind;
599 
600  return expr;
601 }
602 
603 
604 /*
605  * updateTargetListEntry()
606  * This is used in UPDATE statements (and ON CONFLICT DO UPDATE)
607  * only. It prepares an UPDATE TargetEntry for assignment to a
608  * column of the target table. This includes coercing the given
609  * value to the target column's type (if necessary), and dealing with
610  * any subfield names or subscripts attached to the target column
611  * itself.
612  *
613  * pstate parse state
614  * tle target list entry to be modified
615  * colname target column name (ie, name of attribute to be assigned to)
616  * attrno target attribute number
617  * indirection subscripts/field names for target column, if any
618  * location error cursor position (should point at column name), or -1
619  */
620 void
622  TargetEntry *tle,
623  char *colname,
624  int attrno,
625  List *indirection,
626  int location)
627 {
628  /* Fix up expression as needed */
629  tle->expr = transformAssignedExpr(pstate,
630  tle->expr,
632  colname,
633  attrno,
634  indirection,
635  location);
636 
637  /*
638  * Set the resno to identify the target column --- the rewriter and
639  * planner depend on this. We also set the resname to identify the target
640  * column, but this is only for debugging purposes; it should not be
641  * relied on. (In particular, it might be out of date in a stored rule.)
642  */
643  tle->resno = (AttrNumber) attrno;
644  tle->resname = colname;
645 }
646 
647 
648 /*
649  * Process indirection (field selection or subscripting) of the target
650  * column in INSERT/UPDATE/assignment. This routine recurses for multiple
651  * levels of indirection --- but note that several adjacent A_Indices nodes
652  * in the indirection list are treated as a single multidimensional subscript
653  * operation.
654  *
655  * In the initial call, basenode is a Var for the target column in UPDATE,
656  * or a null Const of the target's type in INSERT, or a Param for the target
657  * variable in PL/pgSQL assignment. In recursive calls, basenode is NULL,
658  * indicating that a substitute node should be consed up if needed.
659  *
660  * targetName is the name of the field or subfield we're assigning to, and
661  * targetIsSubscripting is true if we're subscripting it. These are just for
662  * error reporting.
663  *
664  * targetTypeId, targetTypMod, targetCollation indicate the datatype and
665  * collation of the object to be assigned to (initially the target column,
666  * later some subobject).
667  *
668  * indirection is the list of indirection nodes, and indirection_cell is the
669  * start of the sublist remaining to process. When it's NULL, we're done
670  * recursing and can just coerce and return the RHS.
671  *
672  * rhs is the already-transformed value to be assigned; note it has not been
673  * coerced to any particular type.
674  *
675  * ccontext is the coercion level to use while coercing the rhs. For
676  * normal statements it'll be COERCION_ASSIGNMENT, but PL/pgSQL uses
677  * a special value.
678  *
679  * location is the cursor error position for any errors. (Note: this points
680  * to the head of the target clause, eg "foo" in "foo.bar[baz]". Later we
681  * might want to decorate indirection cells with their own location info,
682  * in which case the location argument could probably be dropped.)
683  */
684 Node *
686  Node *basenode,
687  const char *targetName,
688  bool targetIsSubscripting,
689  Oid targetTypeId,
690  int32 targetTypMod,
691  Oid targetCollation,
692  List *indirection,
693  ListCell *indirection_cell,
694  Node *rhs,
695  CoercionContext ccontext,
696  int location)
697 {
698  Node *result;
699  List *subscripts = NIL;
700  bool isSlice = false;
701  ListCell *i;
702 
703  if (indirection_cell && !basenode)
704  {
705  /*
706  * Set up a substitution. We abuse CaseTestExpr for this. It's safe
707  * to do so because the only nodes that will be above the CaseTestExpr
708  * in the finished expression will be FieldStore and SubscriptingRef
709  * nodes. (There could be other stuff in the tree, but it will be
710  * within other child fields of those node types.)
711  */
713 
714  ctest->typeId = targetTypeId;
715  ctest->typeMod = targetTypMod;
716  ctest->collation = targetCollation;
717  basenode = (Node *) ctest;
718  }
719 
720  /*
721  * We have to split any field-selection operations apart from
722  * subscripting. Adjacent A_Indices nodes have to be treated as a single
723  * multidimensional subscript operation.
724  */
725  for_each_cell(i, indirection, indirection_cell)
726  {
727  Node *n = lfirst(i);
728 
729  if (IsA(n, A_Indices))
730  {
731  subscripts = lappend(subscripts, n);
732  if (((A_Indices *) n)->is_slice)
733  isSlice = true;
734  }
735  else if (IsA(n, A_Star))
736  {
737  ereport(ERROR,
738  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
739  errmsg("row expansion via \"*\" is not supported here"),
740  parser_errposition(pstate, location)));
741  }
742  else
743  {
744  FieldStore *fstore;
745  Oid baseTypeId;
746  int32 baseTypeMod;
747  Oid typrelid;
749  Oid fieldTypeId;
750  int32 fieldTypMod;
751  Oid fieldCollation;
752 
753  Assert(IsA(n, String));
754 
755  /* process subscripts before this field selection */
756  if (subscripts)
757  {
758  /* recurse, and then return because we're done */
759  return transformAssignmentSubscripts(pstate,
760  basenode,
761  targetName,
762  targetTypeId,
763  targetTypMod,
764  targetCollation,
765  subscripts,
766  isSlice,
767  indirection,
768  i,
769  rhs,
770  ccontext,
771  location);
772  }
773 
774  /* No subscripts, so can process field selection here */
775 
776  /*
777  * Look up the composite type, accounting for possibility that
778  * what we are given is a domain over composite.
779  */
780  baseTypeMod = targetTypMod;
781  baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod);
782 
783  typrelid = typeidTypeRelid(baseTypeId);
784  if (!typrelid)
785  ereport(ERROR,
786  (errcode(ERRCODE_DATATYPE_MISMATCH),
787  errmsg("cannot assign to field \"%s\" of column \"%s\" because its type %s is not a composite type",
788  strVal(n), targetName,
789  format_type_be(targetTypeId)),
790  parser_errposition(pstate, location)));
791 
792  attnum = get_attnum(typrelid, strVal(n));
793  if (attnum == InvalidAttrNumber)
794  ereport(ERROR,
795  (errcode(ERRCODE_UNDEFINED_COLUMN),
796  errmsg("cannot assign to field \"%s\" of column \"%s\" because there is no such column in data type %s",
797  strVal(n), targetName,
798  format_type_be(targetTypeId)),
799  parser_errposition(pstate, location)));
800  if (attnum < 0)
801  ereport(ERROR,
802  (errcode(ERRCODE_UNDEFINED_COLUMN),
803  errmsg("cannot assign to system column \"%s\"",
804  strVal(n)),
805  parser_errposition(pstate, location)));
806 
807  get_atttypetypmodcoll(typrelid, attnum,
808  &fieldTypeId, &fieldTypMod, &fieldCollation);
809 
810  /* recurse to create appropriate RHS for field assign */
811  rhs = transformAssignmentIndirection(pstate,
812  NULL,
813  strVal(n),
814  false,
815  fieldTypeId,
816  fieldTypMod,
817  fieldCollation,
818  indirection,
819  lnext(indirection, i),
820  rhs,
821  ccontext,
822  location);
823 
824  /* and build a FieldStore node */
825  fstore = makeNode(FieldStore);
826  fstore->arg = (Expr *) basenode;
827  fstore->newvals = list_make1(rhs);
828  fstore->fieldnums = list_make1_int(attnum);
829  fstore->resulttype = baseTypeId;
830 
831  /* If target is a domain, apply constraints */
832  if (baseTypeId != targetTypeId)
833  return coerce_to_domain((Node *) fstore,
834  baseTypeId, baseTypeMod,
835  targetTypeId,
838  location,
839  false);
840 
841  return (Node *) fstore;
842  }
843  }
844 
845  /* process trailing subscripts, if any */
846  if (subscripts)
847  {
848  /* recurse, and then return because we're done */
849  return transformAssignmentSubscripts(pstate,
850  basenode,
851  targetName,
852  targetTypeId,
853  targetTypMod,
854  targetCollation,
855  subscripts,
856  isSlice,
857  indirection,
858  NULL,
859  rhs,
860  ccontext,
861  location);
862  }
863 
864  /* base case: just coerce RHS to match target type ID */
865 
866  result = coerce_to_target_type(pstate,
867  rhs, exprType(rhs),
868  targetTypeId, targetTypMod,
869  ccontext,
871  -1);
872  if (result == NULL)
873  {
874  if (targetIsSubscripting)
875  ereport(ERROR,
876  (errcode(ERRCODE_DATATYPE_MISMATCH),
877  errmsg("subscripted assignment to \"%s\" requires type %s"
878  " but expression is of type %s",
879  targetName,
880  format_type_be(targetTypeId),
881  format_type_be(exprType(rhs))),
882  errhint("You will need to rewrite or cast the expression."),
883  parser_errposition(pstate, location)));
884  else
885  ereport(ERROR,
886  (errcode(ERRCODE_DATATYPE_MISMATCH),
887  errmsg("subfield \"%s\" is of type %s"
888  " but expression is of type %s",
889  targetName,
890  format_type_be(targetTypeId),
891  format_type_be(exprType(rhs))),
892  errhint("You will need to rewrite or cast the expression."),
893  parser_errposition(pstate, location)));
894  }
895 
896  return result;
897 }
898 
899 /*
900  * helper for transformAssignmentIndirection: process container assignment
901  */
902 static Node *
904  Node *basenode,
905  const char *targetName,
906  Oid targetTypeId,
907  int32 targetTypMod,
908  Oid targetCollation,
909  List *subscripts,
910  bool isSlice,
911  List *indirection,
912  ListCell *next_indirection,
913  Node *rhs,
914  CoercionContext ccontext,
915  int location)
916 {
917  Node *result;
918  SubscriptingRef *sbsref;
919  Oid containerType;
920  int32 containerTypMod;
921  Oid typeNeeded;
922  int32 typmodNeeded;
923  Oid collationNeeded;
924 
925  Assert(subscripts != NIL);
926 
927  /* Identify the actual container type involved */
928  containerType = targetTypeId;
929  containerTypMod = targetTypMod;
930  transformContainerType(&containerType, &containerTypMod);
931 
932  /* Process subscripts and identify required type for RHS */
933  sbsref = transformContainerSubscripts(pstate,
934  basenode,
935  containerType,
936  containerTypMod,
937  subscripts,
938  true);
939 
940  typeNeeded = sbsref->refrestype;
941  typmodNeeded = sbsref->reftypmod;
942 
943  /*
944  * Container normally has same collation as its elements, but there's an
945  * exception: we might be subscripting a domain over a container type. In
946  * that case use collation of the base type. (This is shaky for arbitrary
947  * subscripting semantics, but it doesn't matter all that much since we
948  * only use this to label the collation of a possible CaseTestExpr.)
949  */
950  if (containerType == targetTypeId)
951  collationNeeded = targetCollation;
952  else
953  collationNeeded = get_typcollation(containerType);
954 
955  /* recurse to create appropriate RHS for container assign */
956  rhs = transformAssignmentIndirection(pstate,
957  NULL,
958  targetName,
959  true,
960  typeNeeded,
961  typmodNeeded,
962  collationNeeded,
963  indirection,
964  next_indirection,
965  rhs,
966  ccontext,
967  location);
968 
969  /*
970  * Insert the already-properly-coerced RHS into the SubscriptingRef. Then
971  * set refrestype and reftypmod back to the container type's values.
972  */
973  sbsref->refassgnexpr = (Expr *) rhs;
974  sbsref->refrestype = containerType;
975  sbsref->reftypmod = containerTypMod;
976 
977  result = (Node *) sbsref;
978 
979  /* If target was a domain over container, need to coerce up to the domain */
980  if (containerType != targetTypeId)
981  {
982  Oid resulttype = exprType(result);
983 
984  result = coerce_to_target_type(pstate,
985  result, resulttype,
986  targetTypeId, targetTypMod,
987  ccontext,
989  -1);
990  /* can fail if we had int2vector/oidvector, but not for true domains */
991  if (result == NULL)
992  ereport(ERROR,
993  (errcode(ERRCODE_CANNOT_COERCE),
994  errmsg("cannot cast type %s to %s",
995  format_type_be(resulttype),
996  format_type_be(targetTypeId)),
997  parser_errposition(pstate, location)));
998  }
999 
1000  return result;
1001 }
1002 
1003 
1004 /*
1005  * checkInsertTargets -
1006  * generate a list of INSERT column targets if not supplied, or
1007  * test supplied column names to make sure they are in target table.
1008  * Also return an integer list of the columns' attribute numbers.
1009  */
1010 List *
1011 checkInsertTargets(ParseState *pstate, List *cols, List **attrnos)
1012 {
1013  *attrnos = NIL;
1014 
1015  if (cols == NIL)
1016  {
1017  /*
1018  * Generate default column list for INSERT.
1019  */
1020  int numcol = RelationGetNumberOfAttributes(pstate->p_target_relation);
1021 
1022  int i;
1023 
1024  for (i = 0; i < numcol; i++)
1025  {
1026  ResTarget *col;
1027  Form_pg_attribute attr;
1028 
1029  attr = TupleDescAttr(pstate->p_target_relation->rd_att, i);
1030 
1031  if (attr->attisdropped)
1032  continue;
1033 
1034  col = makeNode(ResTarget);
1035  col->name = pstrdup(NameStr(attr->attname));
1036  col->indirection = NIL;
1037  col->val = NULL;
1038  col->location = -1;
1039  cols = lappend(cols, col);
1040  *attrnos = lappend_int(*attrnos, i + 1);
1041  }
1042  }
1043  else
1044  {
1045  /*
1046  * Do initial validation of user-supplied INSERT column list.
1047  */
1048  Bitmapset *wholecols = NULL;
1049  Bitmapset *partialcols = NULL;
1050  ListCell *tl;
1051 
1052  foreach(tl, cols)
1053  {
1054  ResTarget *col = (ResTarget *) lfirst(tl);
1055  char *name = col->name;
1056  int attrno;
1057 
1058  /* Lookup column name, ereport on failure */
1059  attrno = attnameAttNum(pstate->p_target_relation, name, false);
1060  if (attrno == InvalidAttrNumber)
1061  ereport(ERROR,
1062  (errcode(ERRCODE_UNDEFINED_COLUMN),
1063  errmsg("column \"%s\" of relation \"%s\" does not exist",
1064  name,
1066  parser_errposition(pstate, col->location)));
1067 
1068  /*
1069  * Check for duplicates, but only of whole columns --- we allow
1070  * INSERT INTO foo (col.subcol1, col.subcol2)
1071  */
1072  if (col->indirection == NIL)
1073  {
1074  /* whole column; must not have any other assignment */
1075  if (bms_is_member(attrno, wholecols) ||
1076  bms_is_member(attrno, partialcols))
1077  ereport(ERROR,
1078  (errcode(ERRCODE_DUPLICATE_COLUMN),
1079  errmsg("column \"%s\" specified more than once",
1080  name),
1081  parser_errposition(pstate, col->location)));
1082  wholecols = bms_add_member(wholecols, attrno);
1083  }
1084  else
1085  {
1086  /* partial column; must not have any whole assignment */
1087  if (bms_is_member(attrno, wholecols))
1088  ereport(ERROR,
1089  (errcode(ERRCODE_DUPLICATE_COLUMN),
1090  errmsg("column \"%s\" specified more than once",
1091  name),
1092  parser_errposition(pstate, col->location)));
1093  partialcols = bms_add_member(partialcols, attrno);
1094  }
1095 
1096  *attrnos = lappend_int(*attrnos, attrno);
1097  }
1098  }
1099 
1100  return cols;
1101 }
1102 
1103 /*
1104  * ExpandColumnRefStar()
1105  * Transforms foo.* into a list of expressions or targetlist entries.
1106  *
1107  * This handles the case where '*' appears as the last or only item in a
1108  * ColumnRef. The code is shared between the case of foo.* at the top level
1109  * in a SELECT target list (where we want TargetEntry nodes in the result)
1110  * and foo.* in a ROW() or VALUES() construct (where we want just bare
1111  * expressions).
1112  *
1113  * The referenced columns are marked as requiring SELECT access.
1114  */
1115 static List *
1117  bool make_target_entry)
1118 {
1119  List *fields = cref->fields;
1120  int numnames = list_length(fields);
1121 
1122  if (numnames == 1)
1123  {
1124  /*
1125  * Target item is a bare '*', expand all tables
1126  *
1127  * (e.g., SELECT * FROM emp, dept)
1128  *
1129  * Since the grammar only accepts bare '*' at top level of SELECT, we
1130  * need not handle the make_target_entry==false case here.
1131  */
1132  Assert(make_target_entry);
1133  return ExpandAllTables(pstate, cref->location);
1134  }
1135  else
1136  {
1137  /*
1138  * Target item is relation.*, expand that table
1139  *
1140  * (e.g., SELECT emp.*, dname FROM emp, dept)
1141  *
1142  * Note: this code is a lot like transformColumnRef; it's tempting to
1143  * call that instead and then replace the resulting whole-row Var with
1144  * a list of Vars. However, that would leave us with the RTE's
1145  * selectedCols bitmap showing the whole row as needing select
1146  * permission, as well as the individual columns. That would be
1147  * incorrect (since columns added later shouldn't need select
1148  * permissions). We could try to remove the whole-row permission bit
1149  * after the fact, but duplicating code is less messy.
1150  */
1151  char *nspname = NULL;
1152  char *relname = NULL;
1153  ParseNamespaceItem *nsitem = NULL;
1154  int levels_up;
1155  enum
1156  {
1157  CRSERR_NO_RTE,
1158  CRSERR_WRONG_DB,
1159  CRSERR_TOO_MANY
1160  } crserr = CRSERR_NO_RTE;
1161 
1162  /*
1163  * Give the PreParseColumnRefHook, if any, first shot. If it returns
1164  * non-null then we should use that expression.
1165  */
1166  if (pstate->p_pre_columnref_hook != NULL)
1167  {
1168  Node *node;
1169 
1170  node = pstate->p_pre_columnref_hook(pstate, cref);
1171  if (node != NULL)
1172  return ExpandRowReference(pstate, node, make_target_entry);
1173  }
1174 
1175  switch (numnames)
1176  {
1177  case 2:
1178  relname = strVal(linitial(fields));
1179  nsitem = refnameNamespaceItem(pstate, nspname, relname,
1180  cref->location,
1181  &levels_up);
1182  break;
1183  case 3:
1184  nspname = strVal(linitial(fields));
1185  relname = strVal(lsecond(fields));
1186  nsitem = refnameNamespaceItem(pstate, nspname, relname,
1187  cref->location,
1188  &levels_up);
1189  break;
1190  case 4:
1191  {
1192  char *catname = strVal(linitial(fields));
1193 
1194  /*
1195  * We check the catalog name and then ignore it.
1196  */
1197  if (strcmp(catname, get_database_name(MyDatabaseId)) != 0)
1198  {
1199  crserr = CRSERR_WRONG_DB;
1200  break;
1201  }
1202  nspname = strVal(lsecond(fields));
1203  relname = strVal(lthird(fields));
1204  nsitem = refnameNamespaceItem(pstate, nspname, relname,
1205  cref->location,
1206  &levels_up);
1207  break;
1208  }
1209  default:
1210  crserr = CRSERR_TOO_MANY;
1211  break;
1212  }
1213 
1214  /*
1215  * Now give the PostParseColumnRefHook, if any, a chance. We cheat a
1216  * bit by passing the RangeTblEntry, not a Var, as the planned
1217  * translation. (A single Var wouldn't be strictly correct anyway.
1218  * This convention allows hooks that really care to know what is
1219  * happening. It might be better to pass the nsitem, but we'd have to
1220  * promote that struct to a full-fledged Node type so that callees
1221  * could identify its type.)
1222  */
1223  if (pstate->p_post_columnref_hook != NULL)
1224  {
1225  Node *node;
1226 
1227  node = pstate->p_post_columnref_hook(pstate, cref,
1228  (Node *) (nsitem ? nsitem->p_rte : NULL));
1229  if (node != NULL)
1230  {
1231  if (nsitem != NULL)
1232  ereport(ERROR,
1233  (errcode(ERRCODE_AMBIGUOUS_COLUMN),
1234  errmsg("column reference \"%s\" is ambiguous",
1235  NameListToString(cref->fields)),
1236  parser_errposition(pstate, cref->location)));
1237  return ExpandRowReference(pstate, node, make_target_entry);
1238  }
1239  }
1240 
1241  /*
1242  * Throw error if no translation found.
1243  */
1244  if (nsitem == NULL)
1245  {
1246  switch (crserr)
1247  {
1248  case CRSERR_NO_RTE:
1249  errorMissingRTE(pstate, makeRangeVar(nspname, relname,
1250  cref->location));
1251  break;
1252  case CRSERR_WRONG_DB:
1253  ereport(ERROR,
1254  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1255  errmsg("cross-database references are not implemented: %s",
1256  NameListToString(cref->fields)),
1257  parser_errposition(pstate, cref->location)));
1258  break;
1259  case CRSERR_TOO_MANY:
1260  ereport(ERROR,
1261  (errcode(ERRCODE_SYNTAX_ERROR),
1262  errmsg("improper qualified name (too many dotted names): %s",
1263  NameListToString(cref->fields)),
1264  parser_errposition(pstate, cref->location)));
1265  break;
1266  }
1267  }
1268 
1269  /*
1270  * OK, expand the nsitem into fields.
1271  */
1272  return ExpandSingleTable(pstate, nsitem, levels_up, cref->location,
1273  make_target_entry);
1274  }
1275 }
1276 
1277 /*
1278  * ExpandAllTables()
1279  * Transforms '*' (in the target list) into a list of targetlist entries.
1280  *
1281  * tlist entries are generated for each relation visible for unqualified
1282  * column name access. We do not consider qualified-name-only entries because
1283  * that would include input tables of aliasless JOINs, NEW/OLD pseudo-entries,
1284  * etc.
1285  *
1286  * The referenced relations/columns are marked as requiring SELECT access.
1287  */
1288 static List *
1289 ExpandAllTables(ParseState *pstate, int location)
1290 {
1291  List *target = NIL;
1292  bool found_table = false;
1293  ListCell *l;
1294 
1295  foreach(l, pstate->p_namespace)
1296  {
1297  ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
1298 
1299  /* Ignore table-only items */
1300  if (!nsitem->p_cols_visible)
1301  continue;
1302  /* Should not have any lateral-only items when parsing targetlist */
1303  Assert(!nsitem->p_lateral_only);
1304  /* Remember we found a p_cols_visible item */
1305  found_table = true;
1306 
1307  target = list_concat(target,
1308  expandNSItemAttrs(pstate,
1309  nsitem,
1310  0,
1311  location));
1312  }
1313 
1314  /*
1315  * Check for "SELECT *;". We do it this way, rather than checking for
1316  * target == NIL, because we want to allow SELECT * FROM a zero_column
1317  * table.
1318  */
1319  if (!found_table)
1320  ereport(ERROR,
1321  (errcode(ERRCODE_SYNTAX_ERROR),
1322  errmsg("SELECT * with no tables specified is not valid"),
1323  parser_errposition(pstate, location)));
1324 
1325  return target;
1326 }
1327 
1328 /*
1329  * ExpandIndirectionStar()
1330  * Transforms foo.* into a list of expressions or targetlist entries.
1331  *
1332  * This handles the case where '*' appears as the last item in A_Indirection.
1333  * The code is shared between the case of foo.* at the top level in a SELECT
1334  * target list (where we want TargetEntry nodes in the result) and foo.* in
1335  * a ROW() or VALUES() construct (where we want just bare expressions).
1336  * For robustness, we use a separate "make_target_entry" flag to control
1337  * this rather than relying on exprKind.
1338  */
1339 static List *
1341  bool make_target_entry, ParseExprKind exprKind)
1342 {
1343  Node *expr;
1344 
1345  /* Strip off the '*' to create a reference to the rowtype object */
1346  ind = copyObject(ind);
1347  ind->indirection = list_truncate(ind->indirection,
1348  list_length(ind->indirection) - 1);
1349 
1350  /* And transform that */
1351  expr = transformExpr(pstate, (Node *) ind, exprKind);
1352 
1353  /* Expand the rowtype expression into individual fields */
1354  return ExpandRowReference(pstate, expr, make_target_entry);
1355 }
1356 
1357 /*
1358  * ExpandSingleTable()
1359  * Transforms foo.* into a list of expressions or targetlist entries.
1360  *
1361  * This handles the case where foo has been determined to be a simple
1362  * reference to an RTE, so we can just generate Vars for the expressions.
1363  *
1364  * The referenced columns are marked as requiring SELECT access.
1365  */
1366 static List *
1368  int sublevels_up, int location, bool make_target_entry)
1369 {
1370  if (make_target_entry)
1371  {
1372  /* expandNSItemAttrs handles permissions marking */
1373  return expandNSItemAttrs(pstate, nsitem, sublevels_up, location);
1374  }
1375  else
1376  {
1377  RangeTblEntry *rte = nsitem->p_rte;
1378  List *vars;
1379  ListCell *l;
1380 
1381  vars = expandNSItemVars(nsitem, sublevels_up, location, NULL);
1382 
1383  /*
1384  * Require read access to the table. This is normally redundant with
1385  * the markVarForSelectPriv calls below, but not if the table has zero
1386  * columns. We need not do anything if the nsitem is for a join: its
1387  * component tables will have been marked ACL_SELECT when they were
1388  * added to the rangetable. (This step changes things only for the
1389  * target relation of UPDATE/DELETE, which cannot be under a join.)
1390  */
1391  if (rte->rtekind == RTE_RELATION)
1392  rte->requiredPerms |= ACL_SELECT;
1393 
1394  /* Require read access to each column */
1395  foreach(l, vars)
1396  {
1397  Var *var = (Var *) lfirst(l);
1398 
1399  markVarForSelectPriv(pstate, var);
1400  }
1401 
1402  return vars;
1403  }
1404 }
1405 
1406 /*
1407  * ExpandRowReference()
1408  * Transforms foo.* into a list of expressions or targetlist entries.
1409  *
1410  * This handles the case where foo is an arbitrary expression of composite
1411  * type.
1412  */
1413 static List *
1415  bool make_target_entry)
1416 {
1417  List *result = NIL;
1418  TupleDesc tupleDesc;
1419  int numAttrs;
1420  int i;
1421 
1422  /*
1423  * If the rowtype expression is a whole-row Var, we can expand the fields
1424  * as simple Vars. Note: if the RTE is a relation, this case leaves us
1425  * with the RTE's selectedCols bitmap showing the whole row as needing
1426  * select permission, as well as the individual columns. However, we can
1427  * only get here for weird notations like (table.*).*, so it's not worth
1428  * trying to clean up --- arguably, the permissions marking is correct
1429  * anyway for such cases.
1430  */
1431  if (IsA(expr, Var) &&
1432  ((Var *) expr)->varattno == InvalidAttrNumber)
1433  {
1434  Var *var = (Var *) expr;
1435  ParseNamespaceItem *nsitem;
1436 
1437  nsitem = GetNSItemByRangeTablePosn(pstate, var->varno, var->varlevelsup);
1438  return ExpandSingleTable(pstate, nsitem, var->varlevelsup, var->location, make_target_entry);
1439  }
1440 
1441  /*
1442  * Otherwise we have to do it the hard way. Our current implementation is
1443  * to generate multiple copies of the expression and do FieldSelects.
1444  * (This can be pretty inefficient if the expression involves nontrivial
1445  * computation :-(.)
1446  *
1447  * Verify it's a composite type, and get the tupdesc.
1448  * get_expr_result_tupdesc() handles this conveniently.
1449  *
1450  * If it's a Var of type RECORD, we have to work even harder: we have to
1451  * find what the Var refers to, and pass that to get_expr_result_tupdesc.
1452  * That task is handled by expandRecordVariable().
1453  */
1454  if (IsA(expr, Var) &&
1455  ((Var *) expr)->vartype == RECORDOID)
1456  tupleDesc = expandRecordVariable(pstate, (Var *) expr, 0);
1457  else
1458  tupleDesc = get_expr_result_tupdesc(expr, false);
1459  Assert(tupleDesc);
1460 
1461  /* Generate a list of references to the individual fields */
1462  numAttrs = tupleDesc->natts;
1463  for (i = 0; i < numAttrs; i++)
1464  {
1465  Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
1466  FieldSelect *fselect;
1467 
1468  if (att->attisdropped)
1469  continue;
1470 
1471  fselect = makeNode(FieldSelect);
1472  fselect->arg = (Expr *) copyObject(expr);
1473  fselect->fieldnum = i + 1;
1474  fselect->resulttype = att->atttypid;
1475  fselect->resulttypmod = att->atttypmod;
1476  /* save attribute's collation for parse_collate.c */
1477  fselect->resultcollid = att->attcollation;
1478 
1479  if (make_target_entry)
1480  {
1481  /* add TargetEntry decoration */
1482  TargetEntry *te;
1483 
1484  te = makeTargetEntry((Expr *) fselect,
1485  (AttrNumber) pstate->p_next_resno++,
1486  pstrdup(NameStr(att->attname)),
1487  false);
1488  result = lappend(result, te);
1489  }
1490  else
1491  result = lappend(result, fselect);
1492  }
1493 
1494  return result;
1495 }
1496 
1497 /*
1498  * expandRecordVariable
1499  * Get the tuple descriptor for a Var of type RECORD, if possible.
1500  *
1501  * Since no actual table or view column is allowed to have type RECORD, such
1502  * a Var must refer to a JOIN or FUNCTION RTE or to a subquery output. We
1503  * drill down to find the ultimate defining expression and attempt to infer
1504  * the tupdesc from it. We ereport if we can't determine the tupdesc.
1505  *
1506  * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
1507  */
1508 TupleDesc
1509 expandRecordVariable(ParseState *pstate, Var *var, int levelsup)
1510 {
1511  TupleDesc tupleDesc;
1512  int netlevelsup;
1513  RangeTblEntry *rte;
1515  Node *expr;
1516 
1517  /* Check my caller didn't mess up */
1518  Assert(IsA(var, Var));
1519  Assert(var->vartype == RECORDOID);
1520 
1521  /*
1522  * Note: it's tempting to use GetNSItemByRangeTablePosn here so that we
1523  * can use expandNSItemVars instead of expandRTE; but that does not work
1524  * for some of the recursion cases below, where we have consed up a
1525  * ParseState that lacks p_namespace data.
1526  */
1527  netlevelsup = var->varlevelsup + levelsup;
1528  rte = GetRTEByRangeTablePosn(pstate, var->varno, netlevelsup);
1529  attnum = var->varattno;
1530 
1531  if (attnum == InvalidAttrNumber)
1532  {
1533  /* Whole-row reference to an RTE, so expand the known fields */
1534  List *names,
1535  *vars;
1536  ListCell *lname,
1537  *lvar;
1538  int i;
1539 
1540  expandRTE(rte, var->varno, 0, var->location, false,
1541  &names, &vars);
1542 
1544  i = 1;
1545  forboth(lname, names, lvar, vars)
1546  {
1547  char *label = strVal(lfirst(lname));
1548  Node *varnode = (Node *) lfirst(lvar);
1549 
1550  TupleDescInitEntry(tupleDesc, i,
1551  label,
1552  exprType(varnode),
1553  exprTypmod(varnode),
1554  0);
1555  TupleDescInitEntryCollation(tupleDesc, i,
1556  exprCollation(varnode));
1557  i++;
1558  }
1559  Assert(lname == NULL && lvar == NULL); /* lists same length? */
1560 
1561  return tupleDesc;
1562  }
1563 
1564  expr = (Node *) var; /* default if we can't drill down */
1565 
1566  switch (rte->rtekind)
1567  {
1568  case RTE_RELATION:
1569  case RTE_VALUES:
1570  case RTE_NAMEDTUPLESTORE:
1571  case RTE_RESULT:
1572 
1573  /*
1574  * This case should not occur: a column of a table, values list,
1575  * or ENR shouldn't have type RECORD. Fall through and fail (most
1576  * likely) at the bottom.
1577  */
1578  break;
1579  case RTE_SUBQUERY:
1580  {
1581  /* Subselect-in-FROM: examine sub-select's output expr */
1583  attnum);
1584 
1585  if (ste == NULL || ste->resjunk)
1586  elog(ERROR, "subquery %s does not have attribute %d",
1587  rte->eref->aliasname, attnum);
1588  expr = (Node *) ste->expr;
1589  if (IsA(expr, Var))
1590  {
1591  /*
1592  * Recurse into the sub-select to see what its Var refers
1593  * to. We have to build an additional level of ParseState
1594  * to keep in step with varlevelsup in the subselect.
1595  */
1596  ParseState mypstate;
1597 
1598  MemSet(&mypstate, 0, sizeof(mypstate));
1599  mypstate.parentParseState = pstate;
1600  mypstate.p_rtable = rte->subquery->rtable;
1601  /* don't bother filling the rest of the fake pstate */
1602 
1603  return expandRecordVariable(&mypstate, (Var *) expr, 0);
1604  }
1605  /* else fall through to inspect the expression */
1606  }
1607  break;
1608  case RTE_JOIN:
1609  /* Join RTE --- recursively inspect the alias variable */
1610  Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars));
1611  expr = (Node *) list_nth(rte->joinaliasvars, attnum - 1);
1612  Assert(expr != NULL);
1613  /* We intentionally don't strip implicit coercions here */
1614  if (IsA(expr, Var))
1615  return expandRecordVariable(pstate, (Var *) expr, netlevelsup);
1616  /* else fall through to inspect the expression */
1617  break;
1618  case RTE_FUNCTION:
1619 
1620  /*
1621  * We couldn't get here unless a function is declared with one of
1622  * its result columns as RECORD, which is not allowed.
1623  */
1624  break;
1625  case RTE_TABLEFUNC:
1626 
1627  /*
1628  * Table function cannot have columns with RECORD type.
1629  */
1630  break;
1631  case RTE_CTE:
1632  /* CTE reference: examine subquery's output expr */
1633  if (!rte->self_reference)
1634  {
1635  CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup);
1636  TargetEntry *ste;
1637 
1639  if (ste == NULL || ste->resjunk)
1640  elog(ERROR, "CTE %s does not have attribute %d",
1641  rte->eref->aliasname, attnum);
1642  expr = (Node *) ste->expr;
1643  if (IsA(expr, Var))
1644  {
1645  /*
1646  * Recurse into the CTE to see what its Var refers to. We
1647  * have to build an additional level of ParseState to keep
1648  * in step with varlevelsup in the CTE; furthermore it
1649  * could be an outer CTE.
1650  */
1651  ParseState mypstate;
1652  Index levelsup;
1653 
1654  MemSet(&mypstate, 0, sizeof(mypstate));
1655  /* this loop must work, since GetCTEForRTE did */
1656  for (levelsup = 0;
1657  levelsup < rte->ctelevelsup + netlevelsup;
1658  levelsup++)
1659  pstate = pstate->parentParseState;
1660  mypstate.parentParseState = pstate;
1661  mypstate.p_rtable = ((Query *) cte->ctequery)->rtable;
1662  /* don't bother filling the rest of the fake pstate */
1663 
1664  return expandRecordVariable(&mypstate, (Var *) expr, 0);
1665  }
1666  /* else fall through to inspect the expression */
1667  }
1668  break;
1669  }
1670 
1671  /*
1672  * We now have an expression we can't expand any more, so see if
1673  * get_expr_result_tupdesc() can do anything with it.
1674  */
1675  return get_expr_result_tupdesc(expr, false);
1676 }
1677 
1678 
1679 /*
1680  * FigureColname -
1681  * if the name of the resulting column is not specified in the target
1682  * list, we have to guess a suitable name. The SQL spec provides some
1683  * guidance, but not much...
1684  *
1685  * Note that the argument is the *untransformed* parse tree for the target
1686  * item. This is a shade easier to work with than the transformed tree.
1687  */
1688 char *
1690 {
1691  char *name = NULL;
1692 
1693  (void) FigureColnameInternal(node, &name);
1694  if (name != NULL)
1695  return name;
1696  /* default result if we can't guess anything */
1697  return "?column?";
1698 }
1699 
1700 /*
1701  * FigureIndexColname -
1702  * choose the name for an expression column in an index
1703  *
1704  * This is actually just like FigureColname, except we return NULL if
1705  * we can't pick a good name.
1706  */
1707 char *
1709 {
1710  char *name = NULL;
1711 
1712  (void) FigureColnameInternal(node, &name);
1713  return name;
1714 }
1715 
1716 /*
1717  * FigureColnameInternal -
1718  * internal workhorse for FigureColname
1719  *
1720  * Return value indicates strength of confidence in result:
1721  * 0 - no information
1722  * 1 - second-best name choice
1723  * 2 - good name choice
1724  * The return value is actually only used internally.
1725  * If the result isn't zero, *name is set to the chosen name.
1726  */
1727 static int
1729 {
1730  int strength = 0;
1731 
1732  if (node == NULL)
1733  return strength;
1734 
1735  switch (nodeTag(node))
1736  {
1737  case T_ColumnRef:
1738  {
1739  char *fname = NULL;
1740  ListCell *l;
1741 
1742  /* find last field name, if any, ignoring "*" */
1743  foreach(l, ((ColumnRef *) node)->fields)
1744  {
1745  Node *i = lfirst(l);
1746 
1747  if (IsA(i, String))
1748  fname = strVal(i);
1749  }
1750  if (fname)
1751  {
1752  *name = fname;
1753  return 2;
1754  }
1755  }
1756  break;
1757  case T_A_Indirection:
1758  {
1759  A_Indirection *ind = (A_Indirection *) node;
1760  char *fname = NULL;
1761  ListCell *l;
1762 
1763  /* find last field name, if any, ignoring "*" and subscripts */
1764  foreach(l, ind->indirection)
1765  {
1766  Node *i = lfirst(l);
1767 
1768  if (IsA(i, String))
1769  fname = strVal(i);
1770  }
1771  if (fname)
1772  {
1773  *name = fname;
1774  return 2;
1775  }
1776  return FigureColnameInternal(ind->arg, name);
1777  }
1778  break;
1779  case T_FuncCall:
1780  *name = strVal(llast(((FuncCall *) node)->funcname));
1781  return 2;
1782  case T_A_Expr:
1783  if (((A_Expr *) node)->kind == AEXPR_NULLIF)
1784  {
1785  /* make nullif() act like a regular function */
1786  *name = "nullif";
1787  return 2;
1788  }
1789  break;
1790  case T_TypeCast:
1791  strength = FigureColnameInternal(((TypeCast *) node)->arg,
1792  name);
1793  if (strength <= 1)
1794  {
1795  if (((TypeCast *) node)->typeName != NULL)
1796  {
1797  *name = strVal(llast(((TypeCast *) node)->typeName->names));
1798  return 1;
1799  }
1800  }
1801  break;
1802  case T_CollateClause:
1803  return FigureColnameInternal(((CollateClause *) node)->arg, name);
1804  case T_GroupingFunc:
1805  /* make GROUPING() act like a regular function */
1806  *name = "grouping";
1807  return 2;
1808  case T_SubLink:
1809  switch (((SubLink *) node)->subLinkType)
1810  {
1811  case EXISTS_SUBLINK:
1812  *name = "exists";
1813  return 2;
1814  case ARRAY_SUBLINK:
1815  *name = "array";
1816  return 2;
1817  case EXPR_SUBLINK:
1818  {
1819  /* Get column name of the subquery's single target */
1820  SubLink *sublink = (SubLink *) node;
1821  Query *query = (Query *) sublink->subselect;
1822 
1823  /*
1824  * The subquery has probably already been transformed,
1825  * but let's be careful and check that. (The reason
1826  * we can see a transformed subquery here is that
1827  * transformSubLink is lazy and modifies the SubLink
1828  * node in-place.)
1829  */
1830  if (IsA(query, Query))
1831  {
1832  TargetEntry *te = (TargetEntry *) linitial(query->targetList);
1833 
1834  if (te->resname)
1835  {
1836  *name = te->resname;
1837  return 2;
1838  }
1839  }
1840  }
1841  break;
1842  /* As with other operator-like nodes, these have no names */
1843  case MULTIEXPR_SUBLINK:
1844  case ALL_SUBLINK:
1845  case ANY_SUBLINK:
1846  case ROWCOMPARE_SUBLINK:
1847  case CTE_SUBLINK:
1848  break;
1849  }
1850  break;
1851  case T_CaseExpr:
1852  strength = FigureColnameInternal((Node *) ((CaseExpr *) node)->defresult,
1853  name);
1854  if (strength <= 1)
1855  {
1856  *name = "case";
1857  return 1;
1858  }
1859  break;
1860  case T_A_ArrayExpr:
1861  /* make ARRAY[] act like a function */
1862  *name = "array";
1863  return 2;
1864  case T_RowExpr:
1865  /* make ROW() act like a function */
1866  *name = "row";
1867  return 2;
1868  case T_CoalesceExpr:
1869  /* make coalesce() act like a regular function */
1870  *name = "coalesce";
1871  return 2;
1872  case T_MinMaxExpr:
1873  /* make greatest/least act like a regular function */
1874  switch (((MinMaxExpr *) node)->op)
1875  {
1876  case IS_GREATEST:
1877  *name = "greatest";
1878  return 2;
1879  case IS_LEAST:
1880  *name = "least";
1881  return 2;
1882  }
1883  break;
1884  case T_SQLValueFunction:
1885  /* make these act like a function or variable */
1886  switch (((SQLValueFunction *) node)->op)
1887  {
1888  case SVFOP_CURRENT_DATE:
1889  *name = "current_date";
1890  return 2;
1891  case SVFOP_CURRENT_TIME:
1892  case SVFOP_CURRENT_TIME_N:
1893  *name = "current_time";
1894  return 2;
1897  *name = "current_timestamp";
1898  return 2;
1899  case SVFOP_LOCALTIME:
1900  case SVFOP_LOCALTIME_N:
1901  *name = "localtime";
1902  return 2;
1903  case SVFOP_LOCALTIMESTAMP:
1905  *name = "localtimestamp";
1906  return 2;
1907  case SVFOP_CURRENT_ROLE:
1908  *name = "current_role";
1909  return 2;
1910  case SVFOP_CURRENT_USER:
1911  *name = "current_user";
1912  return 2;
1913  case SVFOP_USER:
1914  *name = "user";
1915  return 2;
1916  case SVFOP_SESSION_USER:
1917  *name = "session_user";
1918  return 2;
1919  case SVFOP_CURRENT_CATALOG:
1920  *name = "current_catalog";
1921  return 2;
1922  case SVFOP_CURRENT_SCHEMA:
1923  *name = "current_schema";
1924  return 2;
1925  }
1926  break;
1927  case T_XmlExpr:
1928  /* make SQL/XML functions act like a regular function */
1929  switch (((XmlExpr *) node)->op)
1930  {
1931  case IS_XMLCONCAT:
1932  *name = "xmlconcat";
1933  return 2;
1934  case IS_XMLELEMENT:
1935  *name = "xmlelement";
1936  return 2;
1937  case IS_XMLFOREST:
1938  *name = "xmlforest";
1939  return 2;
1940  case IS_XMLPARSE:
1941  *name = "xmlparse";
1942  return 2;
1943  case IS_XMLPI:
1944  *name = "xmlpi";
1945  return 2;
1946  case IS_XMLROOT:
1947  *name = "xmlroot";
1948  return 2;
1949  case IS_XMLSERIALIZE:
1950  *name = "xmlserialize";
1951  return 2;
1952  case IS_DOCUMENT:
1953  /* nothing */
1954  break;
1955  }
1956  break;
1957  case T_XmlSerialize:
1958  *name = "xmlserialize";
1959  return 2;
1960  default:
1961  break;
1962  }
1963 
1964  return strength;
1965 }
int16 AttrNumber
Definition: attnum.h:21
#define InvalidAttrNumber
Definition: attnum.h:23
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:427
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:738
#define NameStr(name)
Definition: c.h:681
signed int int32
Definition: c.h:429
unsigned int Index
Definition: c.h:549
#define MemSet(start, val, len)
Definition: c.h:1008
char * get_database_name(Oid dbid)
Definition: dbcommands.c:2162
int errhint(const char *fmt,...)
Definition: elog.c:1151
int errcode(int sqlerrcode)
Definition: elog.c:693
int errmsg(const char *fmt,...)
Definition: elog.c:904
#define ERROR
Definition: elog.h:33
#define elog(elevel,...)
Definition: elog.h:218
#define ereport(elevel,...)
Definition: elog.h:143
const char * name
Definition: encode.c:561
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
TupleDesc get_expr_result_tupdesc(Node *expr, bool noError)
Definition: funcapi.c:440
Oid MyDatabaseId
Definition: globals.c:88
int i
Definition: isn.c:73
Assert(fmt[strlen(fmt) - 1] !='\n')
List * list_truncate(List *list, int new_size)
Definition: list.c:610
List * lappend(List *list, void *datum)
Definition: list.c:336
List * lappend_int(List *list, int datum)
Definition: list.c:354
List * list_concat(List *list1, const List *list2)
Definition: list.c:540
AttrNumber get_attnum(Oid relid, const char *attname)
Definition: lsyscache.c:856
Oid get_typcollation(Oid typid)
Definition: lsyscache.c:3003
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Definition: lsyscache.c:2485
void get_atttypetypmodcoll(Oid relid, AttrNumber attnum, Oid *typid, int32 *typmod, Oid *collid)
Definition: lsyscache.c:968
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:238
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition: makefuncs.c:337
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
Definition: makefuncs.c:422
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition: makefuncs.c:66
char * pstrdup(const char *in)
Definition: mcxt.c:1299
char * NameListToString(List *names)
Definition: namespace.c:3147
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:267
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:759
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1250
#define IsA(nodeptr, _type_)
Definition: nodes.h:589
#define copyObject(obj)
Definition: nodes.h:654
#define nodeTag(nodeptr)
Definition: nodes.h:543
@ T_CoalesceExpr
Definition: nodes.h:186
@ T_XmlSerialize
Definition: nodes.h:476
@ T_SubLink
Definition: nodes.h:170
@ T_CaseExpr
Definition: nodes.h:180
@ T_XmlExpr
Definition: nodes.h:189
@ T_A_ArrayExpr
Definition: nodes.h:444
@ T_RowExpr
Definition: nodes.h:184
@ T_FuncCall
Definition: nodes.h:440
@ T_MinMaxExpr
Definition: nodes.h:187
@ T_A_Expr
Definition: nodes.h:436
@ T_A_Indirection
Definition: nodes.h:443
@ T_SQLValueFunction
Definition: nodes.h:188
@ T_GroupingFunc
Definition: nodes.h:160
@ T_CollateClause
Definition: nodes.h:448
@ T_ColumnRef
Definition: nodes.h:437
@ T_TypeCast
Definition: nodes.h:447
#define makeNode(_type_)
Definition: nodes.h:586
Node * coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition: parse_coerce.c:157
Node * coerce_to_domain(Node *arg, Oid baseTypeId, int32 baseTypeMod, Oid typeId, CoercionContext ccontext, CoercionForm cformat, int location, bool hideInputCoercion)
Definition: parse_coerce.c:676
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition: parse_coerce.c:78
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:94
SubscriptingRef * transformContainerSubscripts(ParseState *pstate, Node *containerBase, Oid containerType, int32 containerTypMod, List *indirection, bool isAssignment)
Definition: parse_node.c:248
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
void transformContainerType(Oid *containerType, int32 *containerTypmod)
Definition: parse_node.c:194
ParseExprKind
Definition: parse_node.h:39
@ EXPR_KIND_UPDATE_TARGET
Definition: parse_node.h:57
@ EXPR_KIND_NONE
Definition: parse_node.h:40
@ EXPR_KIND_UPDATE_SOURCE
Definition: parse_node.h:56
RangeTblEntry * GetRTEByRangeTablePosn(ParseState *pstate, int varno, int sublevels_up)
void markVarForSelectPriv(ParseState *pstate, Var *var)
void errorMissingRTE(ParseState *pstate, RangeVar *relation)
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
ParseNamespaceItem * GetNSItemByRangeTablePosn(ParseState *pstate, int varno, int sublevels_up)
ParseNamespaceItem * refnameNamespaceItem(ParseState *pstate, const char *schemaname, const char *refname, int location, int *sublevels_up)
Oid attnumTypeId(Relation rd, int attid)
List * expandNSItemVars(ParseNamespaceItem *nsitem, int sublevels_up, int location, List **colnames)
List * expandNSItemAttrs(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, int location)
void expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up, int location, bool include_dropped, List **colnames, List **colvars)
CommonTableExpr * GetCTEForRTE(ParseState *pstate, RangeTblEntry *rte, int rtelevelsup)
int attnameAttNum(Relation rd, const char *attname, bool sysColOK)
static List * ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref, bool make_target_entry)
List * transformTargetList(ParseState *pstate, List *targetlist, ParseExprKind exprKind)
Definition: parse_target.c:123
static int FigureColnameInternal(Node *node, char **name)
Expr * transformAssignedExpr(ParseState *pstate, Expr *expr, ParseExprKind exprKind, const char *colname, int attrno, List *indirection, int location)
Definition: parse_target.c:454
static void markTargetListOrigin(ParseState *pstate, TargetEntry *tle, Var *var, int levelsup)
Definition: parse_target.c:345
static List * ExpandSingleTable(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, int location, bool make_target_entry)
char * FigureIndexColname(Node *node)
static List * ExpandRowReference(ParseState *pstate, Node *expr, bool make_target_entry)
void updateTargetListEntry(ParseState *pstate, TargetEntry *tle, char *colname, int attrno, List *indirection, int location)
Definition: parse_target.c:621
void resolveTargetListUnknowns(ParseState *pstate, List *targetlist)
Definition: parse_target.c:290
TargetEntry * transformTargetEntry(ParseState *pstate, Node *node, Node *expr, ParseExprKind exprKind, char *colname, bool resjunk)
Definition: parse_target.c:77
void markTargetListOrigins(ParseState *pstate, List *targetlist)
Definition: parse_target.c:320
List * checkInsertTargets(ParseState *pstate, List *cols, List **attrnos)
static List * ExpandIndirectionStar(ParseState *pstate, A_Indirection *ind, bool make_target_entry, ParseExprKind exprKind)
static Node * transformAssignmentSubscripts(ParseState *pstate, Node *basenode, const char *targetName, Oid targetTypeId, int32 targetTypMod, Oid targetCollation, List *subscripts, bool isSlice, List *indirection, ListCell *next_indirection, Node *rhs, CoercionContext ccontext, int location)
Definition: parse_target.c:903
Node * transformAssignmentIndirection(ParseState *pstate, Node *basenode, const char *targetName, bool targetIsSubscripting, Oid targetTypeId, int32 targetTypMod, Oid targetCollation, List *indirection, ListCell *indirection_cell, Node *rhs, CoercionContext ccontext, int location)
Definition: parse_target.c:685
static List * ExpandAllTables(ParseState *pstate, int location)
List * transformExpressionList(ParseState *pstate, List *exprlist, ParseExprKind exprKind, bool allowDefault)
Definition: parse_target.c:222
char * FigureColname(Node *node)
TupleDesc expandRecordVariable(ParseState *pstate, Var *var, int levelsup)
Oid typeidTypeRelid(Oid type_id)
Definition: parse_type.c:670
#define GetCTETargetList(cte)
Definition: parsenodes.h:1531
@ AEXPR_NULLIF
Definition: parsenodes.h:270
@ RTE_JOIN
Definition: parsenodes.h:992
@ RTE_CTE
Definition: parsenodes.h:996
@ RTE_NAMEDTUPLESTORE
Definition: parsenodes.h:997
@ RTE_VALUES
Definition: parsenodes.h:995
@ RTE_SUBQUERY
Definition: parsenodes.h:991
@ RTE_RESULT
Definition: parsenodes.h:998
@ RTE_FUNCTION
Definition: parsenodes.h:993
@ RTE_TABLEFUNC
Definition: parsenodes.h:994
@ RTE_RELATION
Definition: parsenodes.h:990
struct A_Star A_Star
#define ACL_SELECT
Definition: parsenodes.h:83
int16 attnum
Definition: pg_attribute.h:83
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:207
void * arg
static char * label
NameData relname
Definition: pg_class.h:38
#define lfirst(lc)
Definition: pg_list.h:169
#define llast(l)
Definition: pg_list.h:194
static int list_length(const List *l)
Definition: pg_list.h:149
#define NIL
Definition: pg_list.h:65
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:446
#define lthird(l)
Definition: pg_list.h:184
#define list_make1(x1)
Definition: pg_list.h:206
#define for_each_cell(cell, lst, initcell)
Definition: pg_list.h:417
static ListCell * list_head(const List *l)
Definition: pg_list.h:125
#define linitial(l)
Definition: pg_list.h:174
#define lsecond(l)
Definition: pg_list.h:179
static void * list_nth(const List *list, int n)
Definition: pg_list.h:278
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:322
#define list_make1_int(x1)
Definition: pg_list.h:221
unsigned int Oid
Definition: postgres_ext.h:31
e
Definition: preproc-init.c:82
@ ARRAY_SUBLINK
Definition: primnodes.h:689
@ ANY_SUBLINK
Definition: primnodes.h:685
@ MULTIEXPR_SUBLINK
Definition: primnodes.h:688
@ CTE_SUBLINK
Definition: primnodes.h:690
@ EXPR_SUBLINK
Definition: primnodes.h:687
@ ROWCOMPARE_SUBLINK
Definition: primnodes.h:686
@ ALL_SUBLINK
Definition: primnodes.h:684
@ EXISTS_SUBLINK
Definition: primnodes.h:683
@ IS_LEAST
Definition: primnodes.h:1142
@ IS_GREATEST
Definition: primnodes.h:1141
@ SVFOP_CURRENT_CATALOG
Definition: primnodes.h:1182
@ SVFOP_LOCALTIME_N
Definition: primnodes.h:1175
@ SVFOP_CURRENT_TIMESTAMP
Definition: primnodes.h:1172
@ SVFOP_LOCALTIME
Definition: primnodes.h:1174
@ SVFOP_CURRENT_TIMESTAMP_N
Definition: primnodes.h:1173
@ SVFOP_CURRENT_ROLE
Definition: primnodes.h:1178
@ SVFOP_USER
Definition: primnodes.h:1180
@ SVFOP_CURRENT_SCHEMA
Definition: primnodes.h:1183
@ SVFOP_LOCALTIMESTAMP_N
Definition: primnodes.h:1177
@ SVFOP_CURRENT_DATE
Definition: primnodes.h:1169
@ SVFOP_CURRENT_TIME_N
Definition: primnodes.h:1171
@ SVFOP_CURRENT_TIME
Definition: primnodes.h:1170
@ SVFOP_LOCALTIMESTAMP
Definition: primnodes.h:1176
@ SVFOP_CURRENT_USER
Definition: primnodes.h:1179
@ SVFOP_SESSION_USER
Definition: primnodes.h:1181
@ IS_DOCUMENT
Definition: primnodes.h:1215
@ IS_XMLFOREST
Definition: primnodes.h:1210
@ IS_XMLCONCAT
Definition: primnodes.h:1208
@ IS_XMLPI
Definition: primnodes.h:1212
@ IS_XMLPARSE
Definition: primnodes.h:1211
@ IS_XMLSERIALIZE
Definition: primnodes.h:1214
@ IS_XMLROOT
Definition: primnodes.h:1213
@ IS_XMLELEMENT
Definition: primnodes.h:1209
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:485
CoercionContext
Definition: primnodes.h:462
@ COERCION_ASSIGNMENT
Definition: primnodes.h:464
@ COERCION_IMPLICIT
Definition: primnodes.h:463
#define RelationGetNumberOfAttributes(relation)
Definition: rel.h:484
#define RelationGetRelationName(relation)
Definition: rel.h:512
char * aliasname
Definition: primnodes.h:42
int32 typeMod
Definition: primnodes.h:1019
int location
Definition: parsenodes.h:247
List * fields
Definition: parsenodes.h:246
CTECycleClause * cycle_clause
Definition: parsenodes.h:1518
CTESearchClause * search_clause
Definition: parsenodes.h:1517
AttrNumber fieldnum
Definition: primnodes.h:809
Oid resulttype
Definition: primnodes.h:810
Oid resultcollid
Definition: primnodes.h:813
Expr * arg
Definition: primnodes.h:808
int32 resulttypmod
Definition: primnodes.h:812
List * newvals
Definition: primnodes.h:838
Expr * arg
Definition: primnodes.h:837
Oid resulttype
Definition: primnodes.h:840
List * fieldnums
Definition: primnodes.h:839
Definition: pg_list.h:51
Definition: nodes.h:539
RangeTblEntry * p_rte
Definition: parse_node.h:268
ParseState * parentParseState
Definition: parse_node.h:180
ParseNamespaceItem * p_target_nsitem
Definition: parse_node.h:193
ParseExprKind p_expr_kind
Definition: parse_node.h:196
List * p_multiassign_exprs
Definition: parse_node.h:198
PreParseColumnRefHook p_pre_columnref_hook
Definition: parse_node.h:220
List * p_namespace
Definition: parse_node.h:186
bool p_is_insert
Definition: parse_node.h:194
int p_next_resno
Definition: parse_node.h:197
Relation p_target_relation
Definition: parse_node.h:192
PostParseColumnRefHook p_post_columnref_hook
Definition: parse_node.h:221
List * p_rtable
Definition: parse_node.h:182
List * rtable
Definition: parsenodes.h:146
List * targetList
Definition: parsenodes.h:149
bool self_reference
Definition: parsenodes.h:1119
AclMode requiredPerms
Definition: parsenodes.h:1157
Index ctelevelsup
Definition: parsenodes.h:1118
Query * subquery
Definition: parsenodes.h:1042
Alias * eref
Definition: parsenodes.h:1153
List * joinaliasvars
Definition: parsenodes.h:1082
RTEKind rtekind
Definition: parsenodes.h:1007
TupleDesc rd_att
Definition: rel.h:110
int location
Definition: parsenodes.h:467
Node * val
Definition: parsenodes.h:466
List * indirection
Definition: parsenodes.h:465
char * name
Definition: parsenodes.h:464
int32 typeMod
Definition: primnodes.h:1342
Definition: value.h:58
Expr * refassgnexpr
Definition: primnodes.h:451
Expr * expr
Definition: primnodes.h:1455
char * resname
Definition: primnodes.h:1457
Oid resorigtbl
Definition: primnodes.h:1460
AttrNumber resno
Definition: primnodes.h:1456
bool resjunk
Definition: primnodes.h:1462
AttrNumber resorigcol
Definition: primnodes.h:1461
Definition: primnodes.h:187
Oid vartype
Definition: primnodes.h:193
AttrNumber varattno
Definition: primnodes.h:191
int varno
Definition: primnodes.h:189
Index varlevelsup
Definition: primnodes.h:196
int location
Definition: primnodes.h:201
Definition: regcomp.c:238
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:45
void TupleDescInitEntryCollation(TupleDesc desc, AttrNumber attributeNumber, Oid collationid)
Definition: tupdesc.c:754
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:583
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define strVal(v)
Definition: value.h:72