PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
parse_expr.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * parse_expr.c
4  * handle expressions in parser
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_expr.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 
16 #include "postgres.h"
17 
18 #include "catalog/pg_type.h"
19 #include "commands/dbcommands.h"
20 #include "miscadmin.h"
21 #include "nodes/makefuncs.h"
22 #include "nodes/nodeFuncs.h"
23 #include "optimizer/tlist.h"
24 #include "optimizer/var.h"
25 #include "parser/analyze.h"
26 #include "parser/parse_clause.h"
27 #include "parser/parse_coerce.h"
28 #include "parser/parse_collate.h"
29 #include "parser/parse_expr.h"
30 #include "parser/parse_func.h"
31 #include "parser/parse_oper.h"
32 #include "parser/parse_relation.h"
33 #include "parser/parse_target.h"
34 #include "parser/parse_type.h"
35 #include "parser/parse_agg.h"
36 #include "utils/builtins.h"
37 #include "utils/date.h"
38 #include "utils/lsyscache.h"
39 #include "utils/timestamp.h"
40 #include "utils/xml.h"
41 
42 
43 /* GUC parameters */
45 bool Transform_null_equals = false;
46 
47 /*
48  * Node-type groups for operator precedence warnings
49  * We use zero for everything not otherwise classified
50  */
51 #define PREC_GROUP_POSTFIX_IS 1 /* postfix IS tests (NullTest, etc) */
52 #define PREC_GROUP_INFIX_IS 2 /* infix IS (IS DISTINCT FROM, etc) */
53 #define PREC_GROUP_LESS 3 /* < > */
54 #define PREC_GROUP_EQUAL 4 /* = */
55 #define PREC_GROUP_LESS_EQUAL 5 /* <= >= <> */
56 #define PREC_GROUP_LIKE 6 /* LIKE ILIKE SIMILAR */
57 #define PREC_GROUP_BETWEEN 7 /* BETWEEN */
58 #define PREC_GROUP_IN 8 /* IN */
59 #define PREC_GROUP_NOT_LIKE 9 /* NOT LIKE/ILIKE/SIMILAR */
60 #define PREC_GROUP_NOT_BETWEEN 10 /* NOT BETWEEN */
61 #define PREC_GROUP_NOT_IN 11 /* NOT IN */
62 #define PREC_GROUP_POSTFIX_OP 12 /* generic postfix operators */
63 #define PREC_GROUP_INFIX_OP 13 /* generic infix operators */
64 #define PREC_GROUP_PREFIX_OP 14 /* generic prefix operators */
65 
66 /*
67  * Map precedence groupings to old precedence ordering
68  *
69  * Old precedence order:
70  * 1. NOT
71  * 2. =
72  * 3. < >
73  * 4. LIKE ILIKE SIMILAR
74  * 5. BETWEEN
75  * 6. IN
76  * 7. generic postfix Op
77  * 8. generic Op, including <= => <>
78  * 9. generic prefix Op
79  * 10. IS tests (NullTest, BooleanTest, etc)
80  *
81  * NOT BETWEEN etc map to BETWEEN etc when considered as being on the left,
82  * but to NOT when considered as being on the right, because of the buggy
83  * precedence handling of those productions in the old grammar.
84  */
85 static const int oldprecedence_l[] = {
86  0, 10, 10, 3, 2, 8, 4, 5, 6, 4, 5, 6, 7, 8, 9
87 };
88 static const int oldprecedence_r[] = {
89  0, 10, 10, 3, 2, 8, 4, 5, 6, 1, 1, 1, 7, 8, 9
90 };
91 
92 static Node *transformExprRecurse(ParseState *pstate, Node *expr);
93 static Node *transformParamRef(ParseState *pstate, ParamRef *pref);
94 static Node *transformAExprOp(ParseState *pstate, A_Expr *a);
95 static Node *transformAExprOpAny(ParseState *pstate, A_Expr *a);
96 static Node *transformAExprOpAll(ParseState *pstate, A_Expr *a);
97 static Node *transformAExprDistinct(ParseState *pstate, A_Expr *a);
98 static Node *transformAExprNullIf(ParseState *pstate, A_Expr *a);
99 static Node *transformAExprOf(ParseState *pstate, A_Expr *a);
100 static Node *transformAExprIn(ParseState *pstate, A_Expr *a);
101 static Node *transformAExprBetween(ParseState *pstate, A_Expr *a);
102 static Node *transformBoolExpr(ParseState *pstate, BoolExpr *a);
103 static Node *transformFuncCall(ParseState *pstate, FuncCall *fn);
104 static Node *transformMultiAssignRef(ParseState *pstate, MultiAssignRef *maref);
105 static Node *transformCaseExpr(ParseState *pstate, CaseExpr *c);
106 static Node *transformSubLink(ParseState *pstate, SubLink *sublink);
107 static Node *transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
108  Oid array_type, Oid element_type, int32 typmod);
109 static Node *transformRowExpr(ParseState *pstate, RowExpr *r, bool allowDefault);
111 static Node *transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m);
113  SQLValueFunction *svf);
114 static Node *transformXmlExpr(ParseState *pstate, XmlExpr *x);
115 static Node *transformXmlSerialize(ParseState *pstate, XmlSerialize *xs);
116 static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
117 static Node *transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr);
118 static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
119 static Node *transformWholeRowRef(ParseState *pstate, RangeTblEntry *rte,
120  int location);
122 static Node *transformTypeCast(ParseState *pstate, TypeCast *tc);
124 static Node *make_row_comparison_op(ParseState *pstate, List *opname,
125  List *largs, List *rargs, int location);
126 static Node *make_row_distinct_op(ParseState *pstate, List *opname,
127  RowExpr *lrow, RowExpr *rrow, int location);
128 static Expr *make_distinct_op(ParseState *pstate, List *opname,
129  Node *ltree, Node *rtree, int location);
131  A_Expr *distincta, Node *arg);
132 static int operator_precedence_group(Node *node, const char **nodename);
133 static void emit_precedence_warnings(ParseState *pstate,
134  int opgroup, const char *opname,
135  Node *lchild, Node *rchild,
136  int location);
137 
138 
139 /*
140  * transformExpr -
141  * Analyze and transform expressions. Type checking and type casting is
142  * done here. This processing converts the raw grammar output into
143  * expression trees with fully determined semantics.
144  */
145 Node *
146 transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
147 {
148  Node *result;
149  ParseExprKind sv_expr_kind;
150 
151  /* Save and restore identity of expression type we're parsing */
152  Assert(exprKind != EXPR_KIND_NONE);
153  sv_expr_kind = pstate->p_expr_kind;
154  pstate->p_expr_kind = exprKind;
155 
156  result = transformExprRecurse(pstate, expr);
157 
158  pstate->p_expr_kind = sv_expr_kind;
159 
160  return result;
161 }
162 
163 static Node *
165 {
166  Node *result;
167 
168  if (expr == NULL)
169  return NULL;
170 
171  /* Guard against stack overflow due to overly complex expressions */
173 
174  switch (nodeTag(expr))
175  {
176  case T_ColumnRef:
177  result = transformColumnRef(pstate, (ColumnRef *) expr);
178  break;
179 
180  case T_ParamRef:
181  result = transformParamRef(pstate, (ParamRef *) expr);
182  break;
183 
184  case T_A_Const:
185  {
186  A_Const *con = (A_Const *) expr;
187  Value *val = &con->val;
188 
189  result = (Node *) make_const(pstate, val, con->location);
190  break;
191  }
192 
193  case T_A_Indirection:
194  result = transformIndirection(pstate, (A_Indirection *) expr);
195  break;
196 
197  case T_A_ArrayExpr:
198  result = transformArrayExpr(pstate, (A_ArrayExpr *) expr,
199  InvalidOid, InvalidOid, -1);
200  break;
201 
202  case T_TypeCast:
203  result = transformTypeCast(pstate, (TypeCast *) expr);
204  break;
205 
206  case T_CollateClause:
207  result = transformCollateClause(pstate, (CollateClause *) expr);
208  break;
209 
210  case T_A_Expr:
211  {
212  A_Expr *a = (A_Expr *) expr;
213 
214  switch (a->kind)
215  {
216  case AEXPR_OP:
217  result = transformAExprOp(pstate, a);
218  break;
219  case AEXPR_OP_ANY:
220  result = transformAExprOpAny(pstate, a);
221  break;
222  case AEXPR_OP_ALL:
223  result = transformAExprOpAll(pstate, a);
224  break;
225  case AEXPR_DISTINCT:
226  case AEXPR_NOT_DISTINCT:
227  result = transformAExprDistinct(pstate, a);
228  break;
229  case AEXPR_NULLIF:
230  result = transformAExprNullIf(pstate, a);
231  break;
232  case AEXPR_OF:
233  result = transformAExprOf(pstate, a);
234  break;
235  case AEXPR_IN:
236  result = transformAExprIn(pstate, a);
237  break;
238  case AEXPR_LIKE:
239  case AEXPR_ILIKE:
240  case AEXPR_SIMILAR:
241  /* we can transform these just like AEXPR_OP */
242  result = transformAExprOp(pstate, a);
243  break;
244  case AEXPR_BETWEEN:
245  case AEXPR_NOT_BETWEEN:
246  case AEXPR_BETWEEN_SYM:
248  result = transformAExprBetween(pstate, a);
249  break;
250  case AEXPR_PAREN:
251  result = transformExprRecurse(pstate, a->lexpr);
252  break;
253  default:
254  elog(ERROR, "unrecognized A_Expr kind: %d", a->kind);
255  result = NULL; /* keep compiler quiet */
256  break;
257  }
258  break;
259  }
260 
261  case T_BoolExpr:
262  result = transformBoolExpr(pstate, (BoolExpr *) expr);
263  break;
264 
265  case T_FuncCall:
266  result = transformFuncCall(pstate, (FuncCall *) expr);
267  break;
268 
269  case T_MultiAssignRef:
270  result = transformMultiAssignRef(pstate, (MultiAssignRef *) expr);
271  break;
272 
273  case T_GroupingFunc:
274  result = transformGroupingFunc(pstate, (GroupingFunc *) expr);
275  break;
276 
277  case T_NamedArgExpr:
278  {
279  NamedArgExpr *na = (NamedArgExpr *) expr;
280 
281  na->arg = (Expr *) transformExprRecurse(pstate, (Node *) na->arg);
282  result = expr;
283  break;
284  }
285 
286  case T_SubLink:
287  result = transformSubLink(pstate, (SubLink *) expr);
288  break;
289 
290  case T_CaseExpr:
291  result = transformCaseExpr(pstate, (CaseExpr *) expr);
292  break;
293 
294  case T_RowExpr:
295  result = transformRowExpr(pstate, (RowExpr *) expr, false);
296  break;
297 
298  case T_CoalesceExpr:
299  result = transformCoalesceExpr(pstate, (CoalesceExpr *) expr);
300  break;
301 
302  case T_MinMaxExpr:
303  result = transformMinMaxExpr(pstate, (MinMaxExpr *) expr);
304  break;
305 
306  case T_SQLValueFunction:
307  result = transformSQLValueFunction(pstate,
308  (SQLValueFunction *) expr);
309  break;
310 
311  case T_XmlExpr:
312  result = transformXmlExpr(pstate, (XmlExpr *) expr);
313  break;
314 
315  case T_XmlSerialize:
316  result = transformXmlSerialize(pstate, (XmlSerialize *) expr);
317  break;
318 
319  case T_NullTest:
320  {
321  NullTest *n = (NullTest *) expr;
322 
325  (Node *) n->arg, NULL,
326  n->location);
327 
328  n->arg = (Expr *) transformExprRecurse(pstate, (Node *) n->arg);
329  /* the argument can be any type, so don't coerce it */
330  n->argisrow = type_is_rowtype(exprType((Node *) n->arg));
331  result = expr;
332  break;
333  }
334 
335  case T_BooleanTest:
336  result = transformBooleanTest(pstate, (BooleanTest *) expr);
337  break;
338 
339  case T_CurrentOfExpr:
340  result = transformCurrentOfExpr(pstate, (CurrentOfExpr *) expr);
341  break;
342 
343  /*
344  * In all places where DEFAULT is legal, the caller should have
345  * processed it rather than passing it to transformExpr().
346  */
347  case T_SetToDefault:
348  ereport(ERROR,
349  (errcode(ERRCODE_SYNTAX_ERROR),
350  errmsg("DEFAULT is not allowed in this context"),
351  parser_errposition(pstate,
352  ((SetToDefault *) expr)->location)));
353  break;
354 
355  /*
356  * CaseTestExpr doesn't require any processing; it is only
357  * injected into parse trees in a fully-formed state.
358  *
359  * Ordinarily we should not see a Var here, but it is convenient
360  * for transformJoinUsingClause() to create untransformed operator
361  * trees containing already-transformed Vars. The best
362  * alternative would be to deconstruct and reconstruct column
363  * references, which seems expensively pointless. So allow it.
364  */
365  case T_CaseTestExpr:
366  case T_Var:
367  {
368  result = (Node *) expr;
369  break;
370  }
371 
372  default:
373  /* should not reach here */
374  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
375  result = NULL; /* keep compiler quiet */
376  break;
377  }
378 
379  return result;
380 }
381 
382 /*
383  * helper routine for delivering "column does not exist" error message
384  *
385  * (Usually we don't have to work this hard, but the general case of field
386  * selection from an arbitrary node needs it.)
387  */
388 static void
389 unknown_attribute(ParseState *pstate, Node *relref, char *attname,
390  int location)
391 {
392  RangeTblEntry *rte;
393 
394  if (IsA(relref, Var) &&
395  ((Var *) relref)->varattno == InvalidAttrNumber)
396  {
397  /* Reference the RTE by alias not by actual table name */
398  rte = GetRTEByRangeTablePosn(pstate,
399  ((Var *) relref)->varno,
400  ((Var *) relref)->varlevelsup);
401  ereport(ERROR,
402  (errcode(ERRCODE_UNDEFINED_COLUMN),
403  errmsg("column %s.%s does not exist",
404  rte->eref->aliasname, attname),
405  parser_errposition(pstate, location)));
406  }
407  else
408  {
409  /* Have to do it by reference to the type of the expression */
410  Oid relTypeId = exprType(relref);
411 
412  if (ISCOMPLEX(relTypeId))
413  ereport(ERROR,
414  (errcode(ERRCODE_UNDEFINED_COLUMN),
415  errmsg("column \"%s\" not found in data type %s",
416  attname, format_type_be(relTypeId)),
417  parser_errposition(pstate, location)));
418  else if (relTypeId == RECORDOID)
419  ereport(ERROR,
420  (errcode(ERRCODE_UNDEFINED_COLUMN),
421  errmsg("could not identify column \"%s\" in record data type",
422  attname),
423  parser_errposition(pstate, location)));
424  else
425  ereport(ERROR,
426  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
427  errmsg("column notation .%s applied to type %s, "
428  "which is not a composite type",
429  attname, format_type_be(relTypeId)),
430  parser_errposition(pstate, location)));
431  }
432 }
433 
434 static Node *
436 {
437  Node *last_srf = pstate->p_last_srf;
438  Node *result = transformExprRecurse(pstate, ind->arg);
439  List *subscripts = NIL;
440  int location = exprLocation(result);
441  ListCell *i;
442 
443  /*
444  * We have to split any field-selection operations apart from
445  * subscripting. Adjacent A_Indices nodes have to be treated as a single
446  * multidimensional subscript operation.
447  */
448  foreach(i, ind->indirection)
449  {
450  Node *n = lfirst(i);
451 
452  if (IsA(n, A_Indices))
453  subscripts = lappend(subscripts, n);
454  else if (IsA(n, A_Star))
455  {
456  ereport(ERROR,
457  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
458  errmsg("row expansion via \"*\" is not supported here"),
459  parser_errposition(pstate, location)));
460  }
461  else
462  {
463  Node *newresult;
464 
465  Assert(IsA(n, String));
466 
467  /* process subscripts before this field selection */
468  if (subscripts)
469  result = (Node *) transformArraySubscripts(pstate,
470  result,
471  exprType(result),
472  InvalidOid,
473  exprTypmod(result),
474  subscripts,
475  NULL);
476  subscripts = NIL;
477 
478  newresult = ParseFuncOrColumn(pstate,
479  list_make1(n),
480  list_make1(result),
481  last_srf,
482  NULL,
483  location);
484  if (newresult == NULL)
485  unknown_attribute(pstate, result, strVal(n), location);
486  result = newresult;
487  }
488  }
489  /* process trailing subscripts, if any */
490  if (subscripts)
491  result = (Node *) transformArraySubscripts(pstate,
492  result,
493  exprType(result),
494  InvalidOid,
495  exprTypmod(result),
496  subscripts,
497  NULL);
498 
499  return result;
500 }
501 
502 /*
503  * Transform a ColumnRef.
504  *
505  * If you find yourself changing this code, see also ExpandColumnRefStar.
506  */
507 static Node *
509 {
510  Node *node = NULL;
511  char *nspname = NULL;
512  char *relname = NULL;
513  char *colname = NULL;
514  RangeTblEntry *rte;
515  int levels_up;
516  enum
517  {
518  CRERR_NO_COLUMN,
519  CRERR_NO_RTE,
520  CRERR_WRONG_DB,
521  CRERR_TOO_MANY
522  } crerr = CRERR_NO_COLUMN;
523 
524  /*
525  * Give the PreParseColumnRefHook, if any, first shot. If it returns
526  * non-null then that's all, folks.
527  */
528  if (pstate->p_pre_columnref_hook != NULL)
529  {
530  node = (*pstate->p_pre_columnref_hook) (pstate, cref);
531  if (node != NULL)
532  return node;
533  }
534 
535  /*----------
536  * The allowed syntaxes are:
537  *
538  * A First try to resolve as unqualified column name;
539  * if no luck, try to resolve as unqualified table name (A.*).
540  * A.B A is an unqualified table name; B is either a
541  * column or function name (trying column name first).
542  * A.B.C schema A, table B, col or func name C.
543  * A.B.C.D catalog A, schema B, table C, col or func D.
544  * A.* A is an unqualified table name; means whole-row value.
545  * A.B.* whole-row value of table B in schema A.
546  * A.B.C.* whole-row value of table C in schema B in catalog A.
547  *
548  * We do not need to cope with bare "*"; that will only be accepted by
549  * the grammar at the top level of a SELECT list, and transformTargetList
550  * will take care of it before it ever gets here. Also, "A.*" etc will
551  * be expanded by transformTargetList if they appear at SELECT top level,
552  * so here we are only going to see them as function or operator inputs.
553  *
554  * Currently, if a catalog name is given then it must equal the current
555  * database name; we check it here and then discard it.
556  *----------
557  */
558  switch (list_length(cref->fields))
559  {
560  case 1:
561  {
562  Node *field1 = (Node *) linitial(cref->fields);
563 
564  Assert(IsA(field1, String));
565  colname = strVal(field1);
566 
567  /* Try to identify as an unqualified column */
568  node = colNameToVar(pstate, colname, false, cref->location);
569 
570  if (node == NULL)
571  {
572  /*
573  * Not known as a column of any range-table entry.
574  *
575  * Try to find the name as a relation. Note that only
576  * relations already entered into the rangetable will be
577  * recognized.
578  *
579  * This is a hack for backwards compatibility with
580  * PostQUEL-inspired syntax. The preferred form now is
581  * "rel.*".
582  */
583  rte = refnameRangeTblEntry(pstate, NULL, colname,
584  cref->location,
585  &levels_up);
586  if (rte)
587  node = transformWholeRowRef(pstate, rte,
588  cref->location);
589  }
590  break;
591  }
592  case 2:
593  {
594  Node *field1 = (Node *) linitial(cref->fields);
595  Node *field2 = (Node *) lsecond(cref->fields);
596 
597  Assert(IsA(field1, String));
598  relname = strVal(field1);
599 
600  /* Locate the referenced RTE */
601  rte = refnameRangeTblEntry(pstate, nspname, relname,
602  cref->location,
603  &levels_up);
604  if (rte == NULL)
605  {
606  crerr = CRERR_NO_RTE;
607  break;
608  }
609 
610  /* Whole-row reference? */
611  if (IsA(field2, A_Star))
612  {
613  node = transformWholeRowRef(pstate, rte, cref->location);
614  break;
615  }
616 
617  Assert(IsA(field2, String));
618  colname = strVal(field2);
619 
620  /* Try to identify as a column of the RTE */
621  node = scanRTEForColumn(pstate, rte, colname, cref->location,
622  0, NULL);
623  if (node == NULL)
624  {
625  /* Try it as a function call on the whole row */
626  node = transformWholeRowRef(pstate, rte, cref->location);
627  node = ParseFuncOrColumn(pstate,
628  list_make1(makeString(colname)),
629  list_make1(node),
630  pstate->p_last_srf,
631  NULL,
632  cref->location);
633  }
634  break;
635  }
636  case 3:
637  {
638  Node *field1 = (Node *) linitial(cref->fields);
639  Node *field2 = (Node *) lsecond(cref->fields);
640  Node *field3 = (Node *) lthird(cref->fields);
641 
642  Assert(IsA(field1, String));
643  nspname = strVal(field1);
644  Assert(IsA(field2, String));
645  relname = strVal(field2);
646 
647  /* Locate the referenced RTE */
648  rte = refnameRangeTblEntry(pstate, nspname, relname,
649  cref->location,
650  &levels_up);
651  if (rte == NULL)
652  {
653  crerr = CRERR_NO_RTE;
654  break;
655  }
656 
657  /* Whole-row reference? */
658  if (IsA(field3, A_Star))
659  {
660  node = transformWholeRowRef(pstate, rte, cref->location);
661  break;
662  }
663 
664  Assert(IsA(field3, String));
665  colname = strVal(field3);
666 
667  /* Try to identify as a column of the RTE */
668  node = scanRTEForColumn(pstate, rte, colname, cref->location,
669  0, NULL);
670  if (node == NULL)
671  {
672  /* Try it as a function call on the whole row */
673  node = transformWholeRowRef(pstate, rte, cref->location);
674  node = ParseFuncOrColumn(pstate,
675  list_make1(makeString(colname)),
676  list_make1(node),
677  pstate->p_last_srf,
678  NULL,
679  cref->location);
680  }
681  break;
682  }
683  case 4:
684  {
685  Node *field1 = (Node *) linitial(cref->fields);
686  Node *field2 = (Node *) lsecond(cref->fields);
687  Node *field3 = (Node *) lthird(cref->fields);
688  Node *field4 = (Node *) lfourth(cref->fields);
689  char *catname;
690 
691  Assert(IsA(field1, String));
692  catname = strVal(field1);
693  Assert(IsA(field2, String));
694  nspname = strVal(field2);
695  Assert(IsA(field3, String));
696  relname = strVal(field3);
697 
698  /*
699  * We check the catalog name and then ignore it.
700  */
701  if (strcmp(catname, get_database_name(MyDatabaseId)) != 0)
702  {
703  crerr = CRERR_WRONG_DB;
704  break;
705  }
706 
707  /* Locate the referenced RTE */
708  rte = refnameRangeTblEntry(pstate, nspname, relname,
709  cref->location,
710  &levels_up);
711  if (rte == NULL)
712  {
713  crerr = CRERR_NO_RTE;
714  break;
715  }
716 
717  /* Whole-row reference? */
718  if (IsA(field4, A_Star))
719  {
720  node = transformWholeRowRef(pstate, rte, cref->location);
721  break;
722  }
723 
724  Assert(IsA(field4, String));
725  colname = strVal(field4);
726 
727  /* Try to identify as a column of the RTE */
728  node = scanRTEForColumn(pstate, rte, colname, cref->location,
729  0, NULL);
730  if (node == NULL)
731  {
732  /* Try it as a function call on the whole row */
733  node = transformWholeRowRef(pstate, rte, cref->location);
734  node = ParseFuncOrColumn(pstate,
735  list_make1(makeString(colname)),
736  list_make1(node),
737  pstate->p_last_srf,
738  NULL,
739  cref->location);
740  }
741  break;
742  }
743  default:
744  crerr = CRERR_TOO_MANY; /* too many dotted names */
745  break;
746  }
747 
748  /*
749  * Now give the PostParseColumnRefHook, if any, a chance. We pass the
750  * translation-so-far so that it can throw an error if it wishes in the
751  * case that it has a conflicting interpretation of the ColumnRef. (If it
752  * just translates anyway, we'll throw an error, because we can't undo
753  * whatever effects the preceding steps may have had on the pstate.) If it
754  * returns NULL, use the standard translation, or throw a suitable error
755  * if there is none.
756  */
757  if (pstate->p_post_columnref_hook != NULL)
758  {
759  Node *hookresult;
760 
761  hookresult = (*pstate->p_post_columnref_hook) (pstate, cref, node);
762  if (node == NULL)
763  node = hookresult;
764  else if (hookresult != NULL)
765  ereport(ERROR,
766  (errcode(ERRCODE_AMBIGUOUS_COLUMN),
767  errmsg("column reference \"%s\" is ambiguous",
768  NameListToString(cref->fields)),
769  parser_errposition(pstate, cref->location)));
770  }
771 
772  /*
773  * Throw error if no translation found.
774  */
775  if (node == NULL)
776  {
777  switch (crerr)
778  {
779  case CRERR_NO_COLUMN:
780  errorMissingColumn(pstate, relname, colname, cref->location);
781  break;
782  case CRERR_NO_RTE:
783  errorMissingRTE(pstate, makeRangeVar(nspname, relname,
784  cref->location));
785  break;
786  case CRERR_WRONG_DB:
787  ereport(ERROR,
788  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
789  errmsg("cross-database references are not implemented: %s",
790  NameListToString(cref->fields)),
791  parser_errposition(pstate, cref->location)));
792  break;
793  case CRERR_TOO_MANY:
794  ereport(ERROR,
795  (errcode(ERRCODE_SYNTAX_ERROR),
796  errmsg("improper qualified name (too many dotted names): %s",
797  NameListToString(cref->fields)),
798  parser_errposition(pstate, cref->location)));
799  break;
800  }
801  }
802 
803  return node;
804 }
805 
806 static Node *
808 {
809  Node *result;
810 
811  /*
812  * The core parser knows nothing about Params. If a hook is supplied,
813  * call it. If not, or if the hook returns NULL, throw a generic error.
814  */
815  if (pstate->p_paramref_hook != NULL)
816  result = (*pstate->p_paramref_hook) (pstate, pref);
817  else
818  result = NULL;
819 
820  if (result == NULL)
821  ereport(ERROR,
822  (errcode(ERRCODE_UNDEFINED_PARAMETER),
823  errmsg("there is no parameter $%d", pref->number),
824  parser_errposition(pstate, pref->location)));
825 
826  return result;
827 }
828 
829 /* Test whether an a_expr is a plain NULL constant or not */
830 static bool
832 {
833  if (arg && IsA(arg, A_Const))
834  {
835  A_Const *con = (A_Const *) arg;
836 
837  if (con->val.type == T_Null)
838  return true;
839  }
840  return false;
841 }
842 
843 static Node *
845 {
846  Node *lexpr = a->lexpr;
847  Node *rexpr = a->rexpr;
848  Node *result;
849 
851  {
852  int opgroup;
853  const char *opname;
854 
855  opgroup = operator_precedence_group((Node *) a, &opname);
856  if (opgroup > 0)
857  emit_precedence_warnings(pstate, opgroup, opname,
858  lexpr, rexpr,
859  a->location);
860 
861  /* Look through AEXPR_PAREN nodes so they don't affect tests below */
862  while (lexpr && IsA(lexpr, A_Expr) &&
863  ((A_Expr *) lexpr)->kind == AEXPR_PAREN)
864  lexpr = ((A_Expr *) lexpr)->lexpr;
865  while (rexpr && IsA(rexpr, A_Expr) &&
866  ((A_Expr *) rexpr)->kind == AEXPR_PAREN)
867  rexpr = ((A_Expr *) rexpr)->lexpr;
868  }
869 
870  /*
871  * Special-case "foo = NULL" and "NULL = foo" for compatibility with
872  * standards-broken products (like Microsoft's). Turn these into IS NULL
873  * exprs. (If either side is a CaseTestExpr, then the expression was
874  * generated internally from a CASE-WHEN expression, and
875  * transform_null_equals does not apply.)
876  */
877  if (Transform_null_equals &&
878  list_length(a->name) == 1 &&
879  strcmp(strVal(linitial(a->name)), "=") == 0 &&
880  (exprIsNullConstant(lexpr) || exprIsNullConstant(rexpr)) &&
881  (!IsA(lexpr, CaseTestExpr) &&!IsA(rexpr, CaseTestExpr)))
882  {
883  NullTest *n = makeNode(NullTest);
884 
885  n->nulltesttype = IS_NULL;
886  n->location = a->location;
887 
888  if (exprIsNullConstant(lexpr))
889  n->arg = (Expr *) rexpr;
890  else
891  n->arg = (Expr *) lexpr;
892 
893  result = transformExprRecurse(pstate, (Node *) n);
894  }
895  else if (lexpr && IsA(lexpr, RowExpr) &&
896  rexpr && IsA(rexpr, SubLink) &&
897  ((SubLink *) rexpr)->subLinkType == EXPR_SUBLINK)
898  {
899  /*
900  * Convert "row op subselect" into a ROWCOMPARE sublink. Formerly the
901  * grammar did this, but now that a row construct is allowed anywhere
902  * in expressions, it's easier to do it here.
903  */
904  SubLink *s = (SubLink *) rexpr;
905 
907  s->testexpr = lexpr;
908  s->operName = a->name;
909  s->location = a->location;
910  result = transformExprRecurse(pstate, (Node *) s);
911  }
912  else if (lexpr && IsA(lexpr, RowExpr) &&
913  rexpr && IsA(rexpr, RowExpr))
914  {
915  /* ROW() op ROW() is handled specially */
916  lexpr = transformExprRecurse(pstate, lexpr);
917  rexpr = transformExprRecurse(pstate, rexpr);
918 
919  result = make_row_comparison_op(pstate,
920  a->name,
921  castNode(RowExpr, lexpr)->args,
922  castNode(RowExpr, rexpr)->args,
923  a->location);
924  }
925  else
926  {
927  /* Ordinary scalar operator */
928  Node *last_srf = pstate->p_last_srf;
929 
930  lexpr = transformExprRecurse(pstate, lexpr);
931  rexpr = transformExprRecurse(pstate, rexpr);
932 
933  result = (Node *) make_op(pstate,
934  a->name,
935  lexpr,
936  rexpr,
937  last_srf,
938  a->location);
939  }
940 
941  return result;
942 }
943 
944 static Node *
946 {
947  Node *lexpr = a->lexpr;
948  Node *rexpr = a->rexpr;
949 
952  strVal(llast(a->name)),
953  lexpr, NULL,
954  a->location);
955 
956  lexpr = transformExprRecurse(pstate, lexpr);
957  rexpr = transformExprRecurse(pstate, rexpr);
958 
959  return (Node *) make_scalar_array_op(pstate,
960  a->name,
961  true,
962  lexpr,
963  rexpr,
964  a->location);
965 }
966 
967 static Node *
969 {
970  Node *lexpr = a->lexpr;
971  Node *rexpr = a->rexpr;
972 
975  strVal(llast(a->name)),
976  lexpr, NULL,
977  a->location);
978 
979  lexpr = transformExprRecurse(pstate, lexpr);
980  rexpr = transformExprRecurse(pstate, rexpr);
981 
982  return (Node *) make_scalar_array_op(pstate,
983  a->name,
984  false,
985  lexpr,
986  rexpr,
987  a->location);
988 }
989 
990 static Node *
992 {
993  Node *lexpr = a->lexpr;
994  Node *rexpr = a->rexpr;
995  Node *result;
996 
999  lexpr, rexpr,
1000  a->location);
1001 
1002  /*
1003  * If either input is an undecorated NULL literal, transform to a NullTest
1004  * on the other input. That's simpler to process than a full DistinctExpr,
1005  * and it avoids needing to require that the datatype have an = operator.
1006  */
1007  if (exprIsNullConstant(rexpr))
1008  return make_nulltest_from_distinct(pstate, a, lexpr);
1009  if (exprIsNullConstant(lexpr))
1010  return make_nulltest_from_distinct(pstate, a, rexpr);
1011 
1012  lexpr = transformExprRecurse(pstate, lexpr);
1013  rexpr = transformExprRecurse(pstate, rexpr);
1014 
1015  if (lexpr && IsA(lexpr, RowExpr) &&
1016  rexpr && IsA(rexpr, RowExpr))
1017  {
1018  /* ROW() op ROW() is handled specially */
1019  result = make_row_distinct_op(pstate, a->name,
1020  (RowExpr *) lexpr,
1021  (RowExpr *) rexpr,
1022  a->location);
1023  }
1024  else
1025  {
1026  /* Ordinary scalar operator */
1027  result = (Node *) make_distinct_op(pstate,
1028  a->name,
1029  lexpr,
1030  rexpr,
1031  a->location);
1032  }
1033 
1034  /*
1035  * If it's NOT DISTINCT, we first build a DistinctExpr and then stick a
1036  * NOT on top.
1037  */
1038  if (a->kind == AEXPR_NOT_DISTINCT)
1039  result = (Node *) makeBoolExpr(NOT_EXPR,
1040  list_make1(result),
1041  a->location);
1042 
1043  return result;
1044 }
1045 
1046 static Node *
1048 {
1049  Node *lexpr = transformExprRecurse(pstate, a->lexpr);
1050  Node *rexpr = transformExprRecurse(pstate, a->rexpr);
1051  OpExpr *result;
1052 
1053  result = (OpExpr *) make_op(pstate,
1054  a->name,
1055  lexpr,
1056  rexpr,
1057  pstate->p_last_srf,
1058  a->location);
1059 
1060  /*
1061  * The comparison operator itself should yield boolean ...
1062  */
1063  if (result->opresulttype != BOOLOID)
1064  ereport(ERROR,
1065  (errcode(ERRCODE_DATATYPE_MISMATCH),
1066  errmsg("NULLIF requires = operator to yield boolean"),
1067  parser_errposition(pstate, a->location)));
1068  if (result->opretset)
1069  ereport(ERROR,
1070  (errcode(ERRCODE_DATATYPE_MISMATCH),
1071  /* translator: %s is name of a SQL construct, eg NULLIF */
1072  errmsg("%s must not return a set", "NULLIF"),
1073  parser_errposition(pstate, a->location)));
1074 
1075  /*
1076  * ... but the NullIfExpr will yield the first operand's type.
1077  */
1078  result->opresulttype = exprType((Node *) linitial(result->args));
1079 
1080  /*
1081  * We rely on NullIfExpr and OpExpr being the same struct
1082  */
1083  NodeSetTag(result, T_NullIfExpr);
1084 
1085  return (Node *) result;
1086 }
1087 
1088 /*
1089  * Checking an expression for match to a list of type names. Will result
1090  * in a boolean constant node.
1091  */
1092 static Node *
1094 {
1095  Node *lexpr = a->lexpr;
1096  Const *result;
1097  ListCell *telem;
1098  Oid ltype,
1099  rtype;
1100  bool matched = false;
1101 
1104  lexpr, NULL,
1105  a->location);
1106 
1107  lexpr = transformExprRecurse(pstate, lexpr);
1108 
1109  ltype = exprType(lexpr);
1110  foreach(telem, (List *) a->rexpr)
1111  {
1112  rtype = typenameTypeId(pstate, lfirst(telem));
1113  matched = (rtype == ltype);
1114  if (matched)
1115  break;
1116  }
1117 
1118  /*
1119  * We have two forms: equals or not equals. Flip the sense of the result
1120  * for not equals.
1121  */
1122  if (strcmp(strVal(linitial(a->name)), "<>") == 0)
1123  matched = (!matched);
1124 
1125  result = (Const *) makeBoolConst(matched, false);
1126 
1127  /* Make the result have the original input's parse location */
1128  result->location = exprLocation((Node *) a);
1129 
1130  return (Node *) result;
1131 }
1132 
1133 static Node *
1135 {
1136  Node *result = NULL;
1137  Node *lexpr;
1138  List *rexprs;
1139  List *rvars;
1140  List *rnonvars;
1141  bool useOr;
1142  ListCell *l;
1143 
1144  /*
1145  * If the operator is <>, combine with AND not OR.
1146  */
1147  if (strcmp(strVal(linitial(a->name)), "<>") == 0)
1148  useOr = false;
1149  else
1150  useOr = true;
1151 
1153  emit_precedence_warnings(pstate,
1154  useOr ? PREC_GROUP_IN : PREC_GROUP_NOT_IN,
1155  "IN",
1156  a->lexpr, NULL,
1157  a->location);
1158 
1159  /*
1160  * We try to generate a ScalarArrayOpExpr from IN/NOT IN, but this is only
1161  * possible if there is a suitable array type available. If not, we fall
1162  * back to a boolean condition tree with multiple copies of the lefthand
1163  * expression. Also, any IN-list items that contain Vars are handled as
1164  * separate boolean conditions, because that gives the planner more scope
1165  * for optimization on such clauses.
1166  *
1167  * First step: transform all the inputs, and detect whether any contain
1168  * Vars.
1169  */
1170  lexpr = transformExprRecurse(pstate, a->lexpr);
1171  rexprs = rvars = rnonvars = NIL;
1172  foreach(l, (List *) a->rexpr)
1173  {
1174  Node *rexpr = transformExprRecurse(pstate, lfirst(l));
1175 
1176  rexprs = lappend(rexprs, rexpr);
1177  if (contain_vars_of_level(rexpr, 0))
1178  rvars = lappend(rvars, rexpr);
1179  else
1180  rnonvars = lappend(rnonvars, rexpr);
1181  }
1182 
1183  /*
1184  * ScalarArrayOpExpr is only going to be useful if there's more than one
1185  * non-Var righthand item.
1186  */
1187  if (list_length(rnonvars) > 1)
1188  {
1189  List *allexprs;
1190  Oid scalar_type;
1191  Oid array_type;
1192 
1193  /*
1194  * Try to select a common type for the array elements. Note that
1195  * since the LHS' type is first in the list, it will be preferred when
1196  * there is doubt (eg, when all the RHS items are unknown literals).
1197  *
1198  * Note: use list_concat here not lcons, to avoid damaging rnonvars.
1199  */
1200  allexprs = list_concat(list_make1(lexpr), rnonvars);
1201  scalar_type = select_common_type(pstate, allexprs, NULL, NULL);
1202 
1203  /*
1204  * Do we have an array type to use? Aside from the case where there
1205  * isn't one, we don't risk using ScalarArrayOpExpr when the common
1206  * type is RECORD, because the RowExpr comparison logic below can cope
1207  * with some cases of non-identical row types.
1208  */
1209  if (OidIsValid(scalar_type) && scalar_type != RECORDOID)
1210  array_type = get_array_type(scalar_type);
1211  else
1212  array_type = InvalidOid;
1213  if (array_type != InvalidOid)
1214  {
1215  /*
1216  * OK: coerce all the right-hand non-Var inputs to the common type
1217  * and build an ArrayExpr for them.
1218  */
1219  List *aexprs;
1220  ArrayExpr *newa;
1221 
1222  aexprs = NIL;
1223  foreach(l, rnonvars)
1224  {
1225  Node *rexpr = (Node *) lfirst(l);
1226 
1227  rexpr = coerce_to_common_type(pstate, rexpr,
1228  scalar_type,
1229  "IN");
1230  aexprs = lappend(aexprs, rexpr);
1231  }
1232  newa = makeNode(ArrayExpr);
1233  newa->array_typeid = array_type;
1234  /* array_collid will be set by parse_collate.c */
1235  newa->element_typeid = scalar_type;
1236  newa->elements = aexprs;
1237  newa->multidims = false;
1238  newa->location = -1;
1239 
1240  result = (Node *) make_scalar_array_op(pstate,
1241  a->name,
1242  useOr,
1243  lexpr,
1244  (Node *) newa,
1245  a->location);
1246 
1247  /* Consider only the Vars (if any) in the loop below */
1248  rexprs = rvars;
1249  }
1250  }
1251 
1252  /*
1253  * Must do it the hard way, ie, with a boolean expression tree.
1254  */
1255  foreach(l, rexprs)
1256  {
1257  Node *rexpr = (Node *) lfirst(l);
1258  Node *cmp;
1259 
1260  if (IsA(lexpr, RowExpr) &&
1261  IsA(rexpr, RowExpr))
1262  {
1263  /* ROW() op ROW() is handled specially */
1264  cmp = make_row_comparison_op(pstate,
1265  a->name,
1266  copyObject(((RowExpr *) lexpr)->args),
1267  ((RowExpr *) rexpr)->args,
1268  a->location);
1269  }
1270  else
1271  {
1272  /* Ordinary scalar operator */
1273  cmp = (Node *) make_op(pstate,
1274  a->name,
1275  copyObject(lexpr),
1276  rexpr,
1277  pstate->p_last_srf,
1278  a->location);
1279  }
1280 
1281  cmp = coerce_to_boolean(pstate, cmp, "IN");
1282  if (result == NULL)
1283  result = cmp;
1284  else
1285  result = (Node *) makeBoolExpr(useOr ? OR_EXPR : AND_EXPR,
1286  list_make2(result, cmp),
1287  a->location);
1288  }
1289 
1290  return result;
1291 }
1292 
1293 static Node *
1295 {
1296  Node *aexpr;
1297  Node *bexpr;
1298  Node *cexpr;
1299  Node *result;
1300  Node *sub1;
1301  Node *sub2;
1302  List *args;
1303 
1304  /* Deconstruct A_Expr into three subexprs */
1305  aexpr = a->lexpr;
1306  args = castNode(List, a->rexpr);
1307  Assert(list_length(args) == 2);
1308  bexpr = (Node *) linitial(args);
1309  cexpr = (Node *) lsecond(args);
1310 
1312  {
1313  int opgroup;
1314  const char *opname;
1315 
1316  opgroup = operator_precedence_group((Node *) a, &opname);
1317  emit_precedence_warnings(pstate, opgroup, opname,
1318  aexpr, cexpr,
1319  a->location);
1320  /* We can ignore bexpr thanks to syntactic restrictions */
1321  /* Wrap subexpressions to prevent extra warnings */
1322  aexpr = (Node *) makeA_Expr(AEXPR_PAREN, NIL, aexpr, NULL, -1);
1323  bexpr = (Node *) makeA_Expr(AEXPR_PAREN, NIL, bexpr, NULL, -1);
1324  cexpr = (Node *) makeA_Expr(AEXPR_PAREN, NIL, cexpr, NULL, -1);
1325  }
1326 
1327  /*
1328  * Build the equivalent comparison expression. Make copies of
1329  * multiply-referenced subexpressions for safety. (XXX this is really
1330  * wrong since it results in multiple runtime evaluations of what may be
1331  * volatile expressions ...)
1332  *
1333  * Ideally we would not use hard-wired operators here but instead use
1334  * opclasses. However, mixed data types and other issues make this
1335  * difficult:
1336  * http://archives.postgresql.org/pgsql-hackers/2008-08/msg01142.php
1337  */
1338  switch (a->kind)
1339  {
1340  case AEXPR_BETWEEN:
1341  args = list_make2(makeSimpleA_Expr(AEXPR_OP, ">=",
1342  aexpr, bexpr,
1343  a->location),
1344  makeSimpleA_Expr(AEXPR_OP, "<=",
1345  copyObject(aexpr), cexpr,
1346  a->location));
1347  result = (Node *) makeBoolExpr(AND_EXPR, args, a->location);
1348  break;
1349  case AEXPR_NOT_BETWEEN:
1350  args = list_make2(makeSimpleA_Expr(AEXPR_OP, "<",
1351  aexpr, bexpr,
1352  a->location),
1354  copyObject(aexpr), cexpr,
1355  a->location));
1356  result = (Node *) makeBoolExpr(OR_EXPR, args, a->location);
1357  break;
1358  case AEXPR_BETWEEN_SYM:
1359  args = list_make2(makeSimpleA_Expr(AEXPR_OP, ">=",
1360  aexpr, bexpr,
1361  a->location),
1362  makeSimpleA_Expr(AEXPR_OP, "<=",
1363  copyObject(aexpr), cexpr,
1364  a->location));
1365  sub1 = (Node *) makeBoolExpr(AND_EXPR, args, a->location);
1366  args = list_make2(makeSimpleA_Expr(AEXPR_OP, ">=",
1367  copyObject(aexpr), copyObject(cexpr),
1368  a->location),
1369  makeSimpleA_Expr(AEXPR_OP, "<=",
1370  copyObject(aexpr), copyObject(bexpr),
1371  a->location));
1372  sub2 = (Node *) makeBoolExpr(AND_EXPR, args, a->location);
1373  args = list_make2(sub1, sub2);
1374  result = (Node *) makeBoolExpr(OR_EXPR, args, a->location);
1375  break;
1376  case AEXPR_NOT_BETWEEN_SYM:
1377  args = list_make2(makeSimpleA_Expr(AEXPR_OP, "<",
1378  aexpr, bexpr,
1379  a->location),
1381  copyObject(aexpr), cexpr,
1382  a->location));
1383  sub1 = (Node *) makeBoolExpr(OR_EXPR, args, a->location);
1384  args = list_make2(makeSimpleA_Expr(AEXPR_OP, "<",
1385  copyObject(aexpr), copyObject(cexpr),
1386  a->location),
1388  copyObject(aexpr), copyObject(bexpr),
1389  a->location));
1390  sub2 = (Node *) makeBoolExpr(OR_EXPR, args, a->location);
1391  args = list_make2(sub1, sub2);
1392  result = (Node *) makeBoolExpr(AND_EXPR, args, a->location);
1393  break;
1394  default:
1395  elog(ERROR, "unrecognized A_Expr kind: %d", a->kind);
1396  result = NULL; /* keep compiler quiet */
1397  break;
1398  }
1399 
1400  return transformExprRecurse(pstate, result);
1401 }
1402 
1403 static Node *
1405 {
1406  List *args = NIL;
1407  const char *opname;
1408  ListCell *lc;
1409 
1410  switch (a->boolop)
1411  {
1412  case AND_EXPR:
1413  opname = "AND";
1414  break;
1415  case OR_EXPR:
1416  opname = "OR";
1417  break;
1418  case NOT_EXPR:
1419  opname = "NOT";
1420  break;
1421  default:
1422  elog(ERROR, "unrecognized boolop: %d", (int) a->boolop);
1423  opname = NULL; /* keep compiler quiet */
1424  break;
1425  }
1426 
1427  foreach(lc, a->args)
1428  {
1429  Node *arg = (Node *) lfirst(lc);
1430 
1431  arg = transformExprRecurse(pstate, arg);
1432  arg = coerce_to_boolean(pstate, arg, opname);
1433  args = lappend(args, arg);
1434  }
1435 
1436  return (Node *) makeBoolExpr(a->boolop, args, a->location);
1437 }
1438 
1439 static Node *
1441 {
1442  Node *last_srf = pstate->p_last_srf;
1443  List *targs;
1444  ListCell *args;
1445 
1446  /* Transform the list of arguments ... */
1447  targs = NIL;
1448  foreach(args, fn->args)
1449  {
1450  targs = lappend(targs, transformExprRecurse(pstate,
1451  (Node *) lfirst(args)));
1452  }
1453 
1454  /*
1455  * When WITHIN GROUP is used, we treat its ORDER BY expressions as
1456  * additional arguments to the function, for purposes of function lookup
1457  * and argument type coercion. So, transform each such expression and add
1458  * them to the targs list. We don't explicitly mark where each argument
1459  * came from, but ParseFuncOrColumn can tell what's what by reference to
1460  * list_length(fn->agg_order).
1461  */
1462  if (fn->agg_within_group)
1463  {
1464  Assert(fn->agg_order != NIL);
1465  foreach(args, fn->agg_order)
1466  {
1467  SortBy *arg = (SortBy *) lfirst(args);
1468 
1469  targs = lappend(targs, transformExpr(pstate, arg->node,
1471  }
1472  }
1473 
1474  /* ... and hand off to ParseFuncOrColumn */
1475  return ParseFuncOrColumn(pstate,
1476  fn->funcname,
1477  targs,
1478  last_srf,
1479  fn,
1480  fn->location);
1481 }
1482 
1483 static Node *
1485 {
1486  SubLink *sublink;
1487  RowExpr *rexpr;
1488  Query *qtree;
1489  TargetEntry *tle;
1490 
1491  /* We should only see this in first-stage processing of UPDATE tlists */
1493 
1494  /* We only need to transform the source if this is the first column */
1495  if (maref->colno == 1)
1496  {
1497  /*
1498  * For now, we only allow EXPR SubLinks and RowExprs as the source of
1499  * an UPDATE multiassignment. This is sufficient to cover interesting
1500  * cases; at worst, someone would have to write (SELECT * FROM expr)
1501  * to expand a composite-returning expression of another form.
1502  */
1503  if (IsA(maref->source, SubLink) &&
1504  ((SubLink *) maref->source)->subLinkType == EXPR_SUBLINK)
1505  {
1506  /* Relabel it as a MULTIEXPR_SUBLINK */
1507  sublink = (SubLink *) maref->source;
1508  sublink->subLinkType = MULTIEXPR_SUBLINK;
1509  /* And transform it */
1510  sublink = (SubLink *) transformExprRecurse(pstate,
1511  (Node *) sublink);
1512 
1513  qtree = castNode(Query, sublink->subselect);
1514 
1515  /* Check subquery returns required number of columns */
1516  if (count_nonjunk_tlist_entries(qtree->targetList) != maref->ncolumns)
1517  ereport(ERROR,
1518  (errcode(ERRCODE_SYNTAX_ERROR),
1519  errmsg("number of columns does not match number of values"),
1520  parser_errposition(pstate, sublink->location)));
1521 
1522  /*
1523  * Build a resjunk tlist item containing the MULTIEXPR SubLink,
1524  * and add it to pstate->p_multiassign_exprs, whence it will later
1525  * get appended to the completed targetlist. We needn't worry
1526  * about selecting a resno for it; transformUpdateStmt will do
1527  * that.
1528  */
1529  tle = makeTargetEntry((Expr *) sublink, 0, NULL, true);
1531  tle);
1532 
1533  /*
1534  * Assign a unique-within-this-targetlist ID to the MULTIEXPR
1535  * SubLink. We can just use its position in the
1536  * p_multiassign_exprs list.
1537  */
1538  sublink->subLinkId = list_length(pstate->p_multiassign_exprs);
1539  }
1540  else if (IsA(maref->source, RowExpr))
1541  {
1542  /* Transform the RowExpr, allowing SetToDefault items */
1543  rexpr = (RowExpr *) transformRowExpr(pstate,
1544  (RowExpr *) maref->source,
1545  true);
1546 
1547  /* Check it returns required number of columns */
1548  if (list_length(rexpr->args) != maref->ncolumns)
1549  ereport(ERROR,
1550  (errcode(ERRCODE_SYNTAX_ERROR),
1551  errmsg("number of columns does not match number of values"),
1552  parser_errposition(pstate, rexpr->location)));
1553 
1554  /*
1555  * Temporarily append it to p_multiassign_exprs, so we can get it
1556  * back when we come back here for additional columns.
1557  */
1558  tle = makeTargetEntry((Expr *) rexpr, 0, NULL, true);
1560  tle);
1561  }
1562  else
1563  ereport(ERROR,
1564  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1565  errmsg("source for a multiple-column UPDATE item must be a sub-SELECT or ROW() expression"),
1566  parser_errposition(pstate, exprLocation(maref->source))));
1567  }
1568  else
1569  {
1570  /*
1571  * Second or later column in a multiassignment. Re-fetch the
1572  * transformed SubLink or RowExpr, which we assume is still the last
1573  * entry in p_multiassign_exprs.
1574  */
1575  Assert(pstate->p_multiassign_exprs != NIL);
1576  tle = (TargetEntry *) llast(pstate->p_multiassign_exprs);
1577  }
1578 
1579  /*
1580  * Emit the appropriate output expression for the current column
1581  */
1582  if (IsA(tle->expr, SubLink))
1583  {
1584  Param *param;
1585 
1586  sublink = (SubLink *) tle->expr;
1587  Assert(sublink->subLinkType == MULTIEXPR_SUBLINK);
1588  qtree = castNode(Query, sublink->subselect);
1589 
1590  /* Build a Param representing the current subquery output column */
1591  tle = (TargetEntry *) list_nth(qtree->targetList, maref->colno - 1);
1592  Assert(!tle->resjunk);
1593 
1594  param = makeNode(Param);
1595  param->paramkind = PARAM_MULTIEXPR;
1596  param->paramid = (sublink->subLinkId << 16) | maref->colno;
1597  param->paramtype = exprType((Node *) tle->expr);
1598  param->paramtypmod = exprTypmod((Node *) tle->expr);
1599  param->paramcollid = exprCollation((Node *) tle->expr);
1600  param->location = exprLocation((Node *) tle->expr);
1601 
1602  return (Node *) param;
1603  }
1604 
1605  if (IsA(tle->expr, RowExpr))
1606  {
1607  Node *result;
1608 
1609  rexpr = (RowExpr *) tle->expr;
1610 
1611  /* Just extract and return the next element of the RowExpr */
1612  result = (Node *) list_nth(rexpr->args, maref->colno - 1);
1613 
1614  /*
1615  * If we're at the last column, delete the RowExpr from
1616  * p_multiassign_exprs; we don't need it anymore, and don't want it in
1617  * the finished UPDATE tlist.
1618  */
1619  if (maref->colno == maref->ncolumns)
1620  pstate->p_multiassign_exprs =
1621  list_delete_ptr(pstate->p_multiassign_exprs, tle);
1622 
1623  return result;
1624  }
1625 
1626  elog(ERROR, "unexpected expr type in multiassign list");
1627  return NULL; /* keep compiler quiet */
1628 }
1629 
1630 static Node *
1632 {
1633  CaseExpr *newc = makeNode(CaseExpr);
1634  Node *last_srf = pstate->p_last_srf;
1635  Node *arg;
1636  CaseTestExpr *placeholder;
1637  List *newargs;
1638  List *resultexprs;
1639  ListCell *l;
1640  Node *defresult;
1641  Oid ptype;
1642 
1643  /* transform the test expression, if any */
1644  arg = transformExprRecurse(pstate, (Node *) c->arg);
1645 
1646  /* generate placeholder for test expression */
1647  if (arg)
1648  {
1649  /*
1650  * If test expression is an untyped literal, force it to text. We have
1651  * to do something now because we won't be able to do this coercion on
1652  * the placeholder. This is not as flexible as what was done in 7.4
1653  * and before, but it's good enough to handle the sort of silly coding
1654  * commonly seen.
1655  */
1656  if (exprType(arg) == UNKNOWNOID)
1657  arg = coerce_to_common_type(pstate, arg, TEXTOID, "CASE");
1658 
1659  /*
1660  * Run collation assignment on the test expression so that we know
1661  * what collation to mark the placeholder with. In principle we could
1662  * leave it to parse_collate.c to do that later, but propagating the
1663  * result to the CaseTestExpr would be unnecessarily complicated.
1664  */
1665  assign_expr_collations(pstate, arg);
1666 
1667  placeholder = makeNode(CaseTestExpr);
1668  placeholder->typeId = exprType(arg);
1669  placeholder->typeMod = exprTypmod(arg);
1670  placeholder->collation = exprCollation(arg);
1671  }
1672  else
1673  placeholder = NULL;
1674 
1675  newc->arg = (Expr *) arg;
1676 
1677  /* transform the list of arguments */
1678  newargs = NIL;
1679  resultexprs = NIL;
1680  foreach(l, c->args)
1681  {
1682  CaseWhen *w = lfirst_node(CaseWhen, l);
1683  CaseWhen *neww = makeNode(CaseWhen);
1684  Node *warg;
1685 
1686  warg = (Node *) w->expr;
1687  if (placeholder)
1688  {
1689  /* shorthand form was specified, so expand... */
1690  warg = (Node *) makeSimpleA_Expr(AEXPR_OP, "=",
1691  (Node *) placeholder,
1692  warg,
1693  w->location);
1694  }
1695  neww->expr = (Expr *) transformExprRecurse(pstate, warg);
1696 
1697  neww->expr = (Expr *) coerce_to_boolean(pstate,
1698  (Node *) neww->expr,
1699  "CASE/WHEN");
1700 
1701  warg = (Node *) w->result;
1702  neww->result = (Expr *) transformExprRecurse(pstate, warg);
1703  neww->location = w->location;
1704 
1705  newargs = lappend(newargs, neww);
1706  resultexprs = lappend(resultexprs, neww->result);
1707  }
1708 
1709  newc->args = newargs;
1710 
1711  /* transform the default clause */
1712  defresult = (Node *) c->defresult;
1713  if (defresult == NULL)
1714  {
1715  A_Const *n = makeNode(A_Const);
1716 
1717  n->val.type = T_Null;
1718  n->location = -1;
1719  defresult = (Node *) n;
1720  }
1721  newc->defresult = (Expr *) transformExprRecurse(pstate, defresult);
1722 
1723  /*
1724  * Note: default result is considered the most significant type in
1725  * determining preferred type. This is how the code worked before, but it
1726  * seems a little bogus to me --- tgl
1727  */
1728  resultexprs = lcons(newc->defresult, resultexprs);
1729 
1730  ptype = select_common_type(pstate, resultexprs, "CASE", NULL);
1731  Assert(OidIsValid(ptype));
1732  newc->casetype = ptype;
1733  /* casecollid will be set by parse_collate.c */
1734 
1735  /* Convert default result clause, if necessary */
1736  newc->defresult = (Expr *)
1737  coerce_to_common_type(pstate,
1738  (Node *) newc->defresult,
1739  ptype,
1740  "CASE/ELSE");
1741 
1742  /* Convert when-clause results, if necessary */
1743  foreach(l, newc->args)
1744  {
1745  CaseWhen *w = (CaseWhen *) lfirst(l);
1746 
1747  w->result = (Expr *)
1748  coerce_to_common_type(pstate,
1749  (Node *) w->result,
1750  ptype,
1751  "CASE/WHEN");
1752  }
1753 
1754  /* if any subexpression contained a SRF, complain */
1755  if (pstate->p_last_srf != last_srf)
1756  ereport(ERROR,
1757  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1758  /* translator: %s is name of a SQL construct, eg GROUP BY */
1759  errmsg("set-returning functions are not allowed in %s",
1760  "CASE"),
1761  errhint("You might be able to move the set-returning function into a LATERAL FROM item."),
1762  parser_errposition(pstate,
1763  exprLocation(pstate->p_last_srf))));
1764 
1765  newc->location = c->location;
1766 
1767  return (Node *) newc;
1768 }
1769 
1770 static Node *
1772 {
1773  Node *result = (Node *) sublink;
1774  Query *qtree;
1775  const char *err;
1776 
1777  /*
1778  * Check to see if the sublink is in an invalid place within the query. We
1779  * allow sublinks everywhere in SELECT/INSERT/UPDATE/DELETE, but generally
1780  * not in utility statements.
1781  */
1782  err = NULL;
1783  switch (pstate->p_expr_kind)
1784  {
1785  case EXPR_KIND_NONE:
1786  Assert(false); /* can't happen */
1787  break;
1788  case EXPR_KIND_OTHER:
1789  /* Accept sublink here; caller must throw error if wanted */
1790  break;
1791  case EXPR_KIND_JOIN_ON:
1792  case EXPR_KIND_JOIN_USING:
1795  case EXPR_KIND_WHERE:
1796  case EXPR_KIND_POLICY:
1797  case EXPR_KIND_HAVING:
1798  case EXPR_KIND_FILTER:
1807  case EXPR_KIND_GROUP_BY:
1808  case EXPR_KIND_ORDER_BY:
1809  case EXPR_KIND_DISTINCT_ON:
1810  case EXPR_KIND_LIMIT:
1811  case EXPR_KIND_OFFSET:
1812  case EXPR_KIND_RETURNING:
1813  case EXPR_KIND_VALUES:
1815  /* okay */
1816  break;
1819  err = _("cannot use subquery in check constraint");
1820  break;
1823  err = _("cannot use subquery in DEFAULT expression");
1824  break;
1826  err = _("cannot use subquery in index expression");
1827  break;
1829  err = _("cannot use subquery in index predicate");
1830  break;
1832  err = _("cannot use subquery in transform expression");
1833  break;
1835  err = _("cannot use subquery in EXECUTE parameter");
1836  break;
1838  err = _("cannot use subquery in trigger WHEN condition");
1839  break;
1841  err = _("cannot use subquery in partition key expression");
1842  break;
1843 
1844  /*
1845  * There is intentionally no default: case here, so that the
1846  * compiler will warn if we add a new ParseExprKind without
1847  * extending this switch. If we do see an unrecognized value at
1848  * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
1849  * which is sane anyway.
1850  */
1851  }
1852  if (err)
1853  ereport(ERROR,
1854  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1855  errmsg_internal("%s", err),
1856  parser_errposition(pstate, sublink->location)));
1857 
1858  pstate->p_hasSubLinks = true;
1859 
1860  /*
1861  * OK, let's transform the sub-SELECT.
1862  */
1863  qtree = parse_sub_analyze(sublink->subselect, pstate, NULL, false, true);
1864 
1865  /*
1866  * Check that we got a SELECT. Anything else should be impossible given
1867  * restrictions of the grammar, but check anyway.
1868  */
1869  if (!IsA(qtree, Query) ||
1870  qtree->commandType != CMD_SELECT)
1871  elog(ERROR, "unexpected non-SELECT command in SubLink");
1872 
1873  sublink->subselect = (Node *) qtree;
1874 
1875  if (sublink->subLinkType == EXISTS_SUBLINK)
1876  {
1877  /*
1878  * EXISTS needs no test expression or combining operator. These fields
1879  * should be null already, but make sure.
1880  */
1881  sublink->testexpr = NULL;
1882  sublink->operName = NIL;
1883  }
1884  else if (sublink->subLinkType == EXPR_SUBLINK ||
1885  sublink->subLinkType == ARRAY_SUBLINK)
1886  {
1887  /*
1888  * Make sure the subselect delivers a single column (ignoring resjunk
1889  * targets).
1890  */
1891  if (count_nonjunk_tlist_entries(qtree->targetList) != 1)
1892  ereport(ERROR,
1893  (errcode(ERRCODE_SYNTAX_ERROR),
1894  errmsg("subquery must return only one column"),
1895  parser_errposition(pstate, sublink->location)));
1896 
1897  /*
1898  * EXPR and ARRAY need no test expression or combining operator. These
1899  * fields should be null already, but make sure.
1900  */
1901  sublink->testexpr = NULL;
1902  sublink->operName = NIL;
1903  }
1904  else if (sublink->subLinkType == MULTIEXPR_SUBLINK)
1905  {
1906  /* Same as EXPR case, except no restriction on number of columns */
1907  sublink->testexpr = NULL;
1908  sublink->operName = NIL;
1909  }
1910  else
1911  {
1912  /* ALL, ANY, or ROWCOMPARE: generate row-comparing expression */
1913  Node *lefthand;
1914  List *left_list;
1915  List *right_list;
1916  ListCell *l;
1917 
1919  {
1920  if (sublink->operName == NIL)
1922  sublink->testexpr, NULL,
1923  sublink->location);
1924  else
1926  strVal(llast(sublink->operName)),
1927  sublink->testexpr, NULL,
1928  sublink->location);
1929  }
1930 
1931  /*
1932  * If the source was "x IN (select)", convert to "x = ANY (select)".
1933  */
1934  if (sublink->operName == NIL)
1935  sublink->operName = list_make1(makeString("="));
1936 
1937  /*
1938  * Transform lefthand expression, and convert to a list
1939  */
1940  lefthand = transformExprRecurse(pstate, sublink->testexpr);
1941  if (lefthand && IsA(lefthand, RowExpr))
1942  left_list = ((RowExpr *) lefthand)->args;
1943  else
1944  left_list = list_make1(lefthand);
1945 
1946  /*
1947  * Build a list of PARAM_SUBLINK nodes representing the output columns
1948  * of the subquery.
1949  */
1950  right_list = NIL;
1951  foreach(l, qtree->targetList)
1952  {
1953  TargetEntry *tent = (TargetEntry *) lfirst(l);
1954  Param *param;
1955 
1956  if (tent->resjunk)
1957  continue;
1958 
1959  param = makeNode(Param);
1960  param->paramkind = PARAM_SUBLINK;
1961  param->paramid = tent->resno;
1962  param->paramtype = exprType((Node *) tent->expr);
1963  param->paramtypmod = exprTypmod((Node *) tent->expr);
1964  param->paramcollid = exprCollation((Node *) tent->expr);
1965  param->location = -1;
1966 
1967  right_list = lappend(right_list, param);
1968  }
1969 
1970  /*
1971  * We could rely on make_row_comparison_op to complain if the list
1972  * lengths differ, but we prefer to generate a more specific error
1973  * message.
1974  */
1975  if (list_length(left_list) < list_length(right_list))
1976  ereport(ERROR,
1977  (errcode(ERRCODE_SYNTAX_ERROR),
1978  errmsg("subquery has too many columns"),
1979  parser_errposition(pstate, sublink->location)));
1980  if (list_length(left_list) > list_length(right_list))
1981  ereport(ERROR,
1982  (errcode(ERRCODE_SYNTAX_ERROR),
1983  errmsg("subquery has too few columns"),
1984  parser_errposition(pstate, sublink->location)));
1985 
1986  /*
1987  * Identify the combining operator(s) and generate a suitable
1988  * row-comparison expression.
1989  */
1990  sublink->testexpr = make_row_comparison_op(pstate,
1991  sublink->operName,
1992  left_list,
1993  right_list,
1994  sublink->location);
1995  }
1996 
1997  return result;
1998 }
1999 
2000 /*
2001  * transformArrayExpr
2002  *
2003  * If the caller specifies the target type, the resulting array will
2004  * be of exactly that type. Otherwise we try to infer a common type
2005  * for the elements using select_common_type().
2006  */
2007 static Node *
2009  Oid array_type, Oid element_type, int32 typmod)
2010 {
2011  ArrayExpr *newa = makeNode(ArrayExpr);
2012  List *newelems = NIL;
2013  List *newcoercedelems = NIL;
2014  ListCell *element;
2015  Oid coerce_type;
2016  bool coerce_hard;
2017 
2018  /*
2019  * Transform the element expressions
2020  *
2021  * Assume that the array is one-dimensional unless we find an array-type
2022  * element expression.
2023  */
2024  newa->multidims = false;
2025  foreach(element, a->elements)
2026  {
2027  Node *e = (Node *) lfirst(element);
2028  Node *newe;
2029 
2030  /* Look through AEXPR_PAREN nodes so they don't affect test below */
2031  while (e && IsA(e, A_Expr) &&
2032  ((A_Expr *) e)->kind == AEXPR_PAREN)
2033  e = ((A_Expr *) e)->lexpr;
2034 
2035  /*
2036  * If an element is itself an A_ArrayExpr, recurse directly so that we
2037  * can pass down any target type we were given.
2038  */
2039  if (IsA(e, A_ArrayExpr))
2040  {
2041  newe = transformArrayExpr(pstate,
2042  (A_ArrayExpr *) e,
2043  array_type,
2044  element_type,
2045  typmod);
2046  /* we certainly have an array here */
2047  Assert(array_type == InvalidOid || array_type == exprType(newe));
2048  newa->multidims = true;
2049  }
2050  else
2051  {
2052  newe = transformExprRecurse(pstate, e);
2053 
2054  /*
2055  * Check for sub-array expressions, if we haven't already found
2056  * one.
2057  */
2058  if (!newa->multidims && type_is_array(exprType(newe)))
2059  newa->multidims = true;
2060  }
2061 
2062  newelems = lappend(newelems, newe);
2063  }
2064 
2065  /*
2066  * Select a target type for the elements.
2067  *
2068  * If we haven't been given a target array type, we must try to deduce a
2069  * common type based on the types of the individual elements present.
2070  */
2071  if (OidIsValid(array_type))
2072  {
2073  /* Caller must ensure array_type matches element_type */
2074  Assert(OidIsValid(element_type));
2075  coerce_type = (newa->multidims ? array_type : element_type);
2076  coerce_hard = true;
2077  }
2078  else
2079  {
2080  /* Can't handle an empty array without a target type */
2081  if (newelems == NIL)
2082  ereport(ERROR,
2083  (errcode(ERRCODE_INDETERMINATE_DATATYPE),
2084  errmsg("cannot determine type of empty array"),
2085  errhint("Explicitly cast to the desired type, "
2086  "for example ARRAY[]::integer[]."),
2087  parser_errposition(pstate, a->location)));
2088 
2089  /* Select a common type for the elements */
2090  coerce_type = select_common_type(pstate, newelems, "ARRAY", NULL);
2091 
2092  if (newa->multidims)
2093  {
2094  array_type = coerce_type;
2095  element_type = get_element_type(array_type);
2096  if (!OidIsValid(element_type))
2097  ereport(ERROR,
2098  (errcode(ERRCODE_UNDEFINED_OBJECT),
2099  errmsg("could not find element type for data type %s",
2100  format_type_be(array_type)),
2101  parser_errposition(pstate, a->location)));
2102  }
2103  else
2104  {
2105  element_type = coerce_type;
2106  array_type = get_array_type(element_type);
2107  if (!OidIsValid(array_type))
2108  ereport(ERROR,
2109  (errcode(ERRCODE_UNDEFINED_OBJECT),
2110  errmsg("could not find array type for data type %s",
2111  format_type_be(element_type)),
2112  parser_errposition(pstate, a->location)));
2113  }
2114  coerce_hard = false;
2115  }
2116 
2117  /*
2118  * Coerce elements to target type
2119  *
2120  * If the array has been explicitly cast, then the elements are in turn
2121  * explicitly coerced.
2122  *
2123  * If the array's type was merely derived from the common type of its
2124  * elements, then the elements are implicitly coerced to the common type.
2125  * This is consistent with other uses of select_common_type().
2126  */
2127  foreach(element, newelems)
2128  {
2129  Node *e = (Node *) lfirst(element);
2130  Node *newe;
2131 
2132  if (coerce_hard)
2133  {
2134  newe = coerce_to_target_type(pstate, e,
2135  exprType(e),
2136  coerce_type,
2137  typmod,
2140  -1);
2141  if (newe == NULL)
2142  ereport(ERROR,
2143  (errcode(ERRCODE_CANNOT_COERCE),
2144  errmsg("cannot cast type %s to %s",
2146  format_type_be(coerce_type)),
2147  parser_errposition(pstate, exprLocation(e))));
2148  }
2149  else
2150  newe = coerce_to_common_type(pstate, e,
2151  coerce_type,
2152  "ARRAY");
2153  newcoercedelems = lappend(newcoercedelems, newe);
2154  }
2155 
2156  newa->array_typeid = array_type;
2157  /* array_collid will be set by parse_collate.c */
2158  newa->element_typeid = element_type;
2159  newa->elements = newcoercedelems;
2160  newa->location = a->location;
2161 
2162  return (Node *) newa;
2163 }
2164 
2165 static Node *
2166 transformRowExpr(ParseState *pstate, RowExpr *r, bool allowDefault)
2167 {
2168  RowExpr *newr;
2169  char fname[16];
2170  int fnum;
2171  ListCell *lc;
2172 
2173  newr = makeNode(RowExpr);
2174 
2175  /* Transform the field expressions */
2176  newr->args = transformExpressionList(pstate, r->args,
2177  pstate->p_expr_kind, allowDefault);
2178 
2179  /* Barring later casting, we consider the type RECORD */
2180  newr->row_typeid = RECORDOID;
2182 
2183  /* ROW() has anonymous columns, so invent some field names */
2184  newr->colnames = NIL;
2185  fnum = 1;
2186  foreach(lc, newr->args)
2187  {
2188  snprintf(fname, sizeof(fname), "f%d", fnum++);
2189  newr->colnames = lappend(newr->colnames, makeString(pstrdup(fname)));
2190  }
2191 
2192  newr->location = r->location;
2193 
2194  return (Node *) newr;
2195 }
2196 
2197 static Node *
2199 {
2201  Node *last_srf = pstate->p_last_srf;
2202  List *newargs = NIL;
2203  List *newcoercedargs = NIL;
2204  ListCell *args;
2205 
2206  foreach(args, c->args)
2207  {
2208  Node *e = (Node *) lfirst(args);
2209  Node *newe;
2210 
2211  newe = transformExprRecurse(pstate, e);
2212  newargs = lappend(newargs, newe);
2213  }
2214 
2215  newc->coalescetype = select_common_type(pstate, newargs, "COALESCE", NULL);
2216  /* coalescecollid will be set by parse_collate.c */
2217 
2218  /* Convert arguments if necessary */
2219  foreach(args, newargs)
2220  {
2221  Node *e = (Node *) lfirst(args);
2222  Node *newe;
2223 
2224  newe = coerce_to_common_type(pstate, e,
2225  newc->coalescetype,
2226  "COALESCE");
2227  newcoercedargs = lappend(newcoercedargs, newe);
2228  }
2229 
2230  /* if any subexpression contained a SRF, complain */
2231  if (pstate->p_last_srf != last_srf)
2232  ereport(ERROR,
2233  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2234  /* translator: %s is name of a SQL construct, eg GROUP BY */
2235  errmsg("set-returning functions are not allowed in %s",
2236  "COALESCE"),
2237  errhint("You might be able to move the set-returning function into a LATERAL FROM item."),
2238  parser_errposition(pstate,
2239  exprLocation(pstate->p_last_srf))));
2240 
2241  newc->args = newcoercedargs;
2242  newc->location = c->location;
2243  return (Node *) newc;
2244 }
2245 
2246 static Node *
2248 {
2249  MinMaxExpr *newm = makeNode(MinMaxExpr);
2250  List *newargs = NIL;
2251  List *newcoercedargs = NIL;
2252  const char *funcname = (m->op == IS_GREATEST) ? "GREATEST" : "LEAST";
2253  ListCell *args;
2254 
2255  newm->op = m->op;
2256  foreach(args, m->args)
2257  {
2258  Node *e = (Node *) lfirst(args);
2259  Node *newe;
2260 
2261  newe = transformExprRecurse(pstate, e);
2262  newargs = lappend(newargs, newe);
2263  }
2264 
2265  newm->minmaxtype = select_common_type(pstate, newargs, funcname, NULL);
2266  /* minmaxcollid and inputcollid will be set by parse_collate.c */
2267 
2268  /* Convert arguments if necessary */
2269  foreach(args, newargs)
2270  {
2271  Node *e = (Node *) lfirst(args);
2272  Node *newe;
2273 
2274  newe = coerce_to_common_type(pstate, e,
2275  newm->minmaxtype,
2276  funcname);
2277  newcoercedargs = lappend(newcoercedargs, newe);
2278  }
2279 
2280  newm->args = newcoercedargs;
2281  newm->location = m->location;
2282  return (Node *) newm;
2283 }
2284 
2285 static Node *
2287 {
2288  /*
2289  * All we need to do is insert the correct result type and (where needed)
2290  * validate the typmod, so we just modify the node in-place.
2291  */
2292  switch (svf->op)
2293  {
2294  case SVFOP_CURRENT_DATE:
2295  svf->type = DATEOID;
2296  break;
2297  case SVFOP_CURRENT_TIME:
2298  svf->type = TIMETZOID;
2299  break;
2300  case SVFOP_CURRENT_TIME_N:
2301  svf->type = TIMETZOID;
2302  svf->typmod = anytime_typmod_check(true, svf->typmod);
2303  break;
2305  svf->type = TIMESTAMPTZOID;
2306  break;
2308  svf->type = TIMESTAMPTZOID;
2309  svf->typmod = anytimestamp_typmod_check(true, svf->typmod);
2310  break;
2311  case SVFOP_LOCALTIME:
2312  svf->type = TIMEOID;
2313  break;
2314  case SVFOP_LOCALTIME_N:
2315  svf->type = TIMEOID;
2316  svf->typmod = anytime_typmod_check(false, svf->typmod);
2317  break;
2318  case SVFOP_LOCALTIMESTAMP:
2319  svf->type = TIMESTAMPOID;
2320  break;
2322  svf->type = TIMESTAMPOID;
2323  svf->typmod = anytimestamp_typmod_check(false, svf->typmod);
2324  break;
2325  case SVFOP_CURRENT_ROLE:
2326  case SVFOP_CURRENT_USER:
2327  case SVFOP_USER:
2328  case SVFOP_SESSION_USER:
2329  case SVFOP_CURRENT_CATALOG:
2330  case SVFOP_CURRENT_SCHEMA:
2331  svf->type = NAMEOID;
2332  break;
2333  }
2334 
2335  return (Node *) svf;
2336 }
2337 
2338 static Node *
2340 {
2341  XmlExpr *newx;
2342  ListCell *lc;
2343  int i;
2344 
2347  (Node *) linitial(x->args), NULL,
2348  x->location);
2349 
2350  newx = makeNode(XmlExpr);
2351  newx->op = x->op;
2352  if (x->name)
2353  newx->name = map_sql_identifier_to_xml_name(x->name, false, false);
2354  else
2355  newx->name = NULL;
2356  newx->xmloption = x->xmloption;
2357  newx->type = XMLOID; /* this just marks the node as transformed */
2358  newx->typmod = -1;
2359  newx->location = x->location;
2360 
2361  /*
2362  * gram.y built the named args as a list of ResTarget. Transform each,
2363  * and break the names out as a separate list.
2364  */
2365  newx->named_args = NIL;
2366  newx->arg_names = NIL;
2367 
2368  foreach(lc, x->named_args)
2369  {
2370  ResTarget *r = lfirst_node(ResTarget, lc);
2371  Node *expr;
2372  char *argname;
2373 
2374  expr = transformExprRecurse(pstate, r->val);
2375 
2376  if (r->name)
2377  argname = map_sql_identifier_to_xml_name(r->name, false, false);
2378  else if (IsA(r->val, ColumnRef))
2380  true, false);
2381  else
2382  {
2383  ereport(ERROR,
2384  (errcode(ERRCODE_SYNTAX_ERROR),
2385  x->op == IS_XMLELEMENT
2386  ? errmsg("unnamed XML attribute value must be a column reference")
2387  : errmsg("unnamed XML element value must be a column reference"),
2388  parser_errposition(pstate, r->location)));
2389  argname = NULL; /* keep compiler quiet */
2390  }
2391 
2392  /* reject duplicate argnames in XMLELEMENT only */
2393  if (x->op == IS_XMLELEMENT)
2394  {
2395  ListCell *lc2;
2396 
2397  foreach(lc2, newx->arg_names)
2398  {
2399  if (strcmp(argname, strVal(lfirst(lc2))) == 0)
2400  ereport(ERROR,
2401  (errcode(ERRCODE_SYNTAX_ERROR),
2402  errmsg("XML attribute name \"%s\" appears more than once",
2403  argname),
2404  parser_errposition(pstate, r->location)));
2405  }
2406  }
2407 
2408  newx->named_args = lappend(newx->named_args, expr);
2409  newx->arg_names = lappend(newx->arg_names, makeString(argname));
2410  }
2411 
2412  /* The other arguments are of varying types depending on the function */
2413  newx->args = NIL;
2414  i = 0;
2415  foreach(lc, x->args)
2416  {
2417  Node *e = (Node *) lfirst(lc);
2418  Node *newe;
2419 
2420  newe = transformExprRecurse(pstate, e);
2421  switch (x->op)
2422  {
2423  case IS_XMLCONCAT:
2424  newe = coerce_to_specific_type(pstate, newe, XMLOID,
2425  "XMLCONCAT");
2426  break;
2427  case IS_XMLELEMENT:
2428  /* no coercion necessary */
2429  break;
2430  case IS_XMLFOREST:
2431  newe = coerce_to_specific_type(pstate, newe, XMLOID,
2432  "XMLFOREST");
2433  break;
2434  case IS_XMLPARSE:
2435  if (i == 0)
2436  newe = coerce_to_specific_type(pstate, newe, TEXTOID,
2437  "XMLPARSE");
2438  else
2439  newe = coerce_to_boolean(pstate, newe, "XMLPARSE");
2440  break;
2441  case IS_XMLPI:
2442  newe = coerce_to_specific_type(pstate, newe, TEXTOID,
2443  "XMLPI");
2444  break;
2445  case IS_XMLROOT:
2446  if (i == 0)
2447  newe = coerce_to_specific_type(pstate, newe, XMLOID,
2448  "XMLROOT");
2449  else if (i == 1)
2450  newe = coerce_to_specific_type(pstate, newe, TEXTOID,
2451  "XMLROOT");
2452  else
2453  newe = coerce_to_specific_type(pstate, newe, INT4OID,
2454  "XMLROOT");
2455  break;
2456  case IS_XMLSERIALIZE:
2457  /* not handled here */
2458  Assert(false);
2459  break;
2460  case IS_DOCUMENT:
2461  newe = coerce_to_specific_type(pstate, newe, XMLOID,
2462  "IS DOCUMENT");
2463  break;
2464  }
2465  newx->args = lappend(newx->args, newe);
2466  i++;
2467  }
2468 
2469  return (Node *) newx;
2470 }
2471 
2472 static Node *
2474 {
2475  Node *result;
2476  XmlExpr *xexpr;
2477  Oid targetType;
2478  int32 targetTypmod;
2479 
2480  xexpr = makeNode(XmlExpr);
2481  xexpr->op = IS_XMLSERIALIZE;
2482  xexpr->args = list_make1(coerce_to_specific_type(pstate,
2483  transformExprRecurse(pstate, xs->expr),
2484  XMLOID,
2485  "XMLSERIALIZE"));
2486 
2487  typenameTypeIdAndMod(pstate, xs->typeName, &targetType, &targetTypmod);
2488 
2489  xexpr->xmloption = xs->xmloption;
2490  xexpr->location = xs->location;
2491  /* We actually only need these to be able to parse back the expression. */
2492  xexpr->type = targetType;
2493  xexpr->typmod = targetTypmod;
2494 
2495  /*
2496  * The actual target type is determined this way. SQL allows char and
2497  * varchar as target types. We allow anything that can be cast implicitly
2498  * from text. This way, user-defined text-like data types automatically
2499  * fit in.
2500  */
2501  result = coerce_to_target_type(pstate, (Node *) xexpr,
2502  TEXTOID, targetType, targetTypmod,
2505  -1);
2506  if (result == NULL)
2507  ereport(ERROR,
2508  (errcode(ERRCODE_CANNOT_COERCE),
2509  errmsg("cannot cast XMLSERIALIZE result to %s",
2510  format_type_be(targetType)),
2511  parser_errposition(pstate, xexpr->location)));
2512  return result;
2513 }
2514 
2515 static Node *
2517 {
2518  const char *clausename;
2519 
2522  (Node *) b->arg, NULL,
2523  b->location);
2524 
2525  switch (b->booltesttype)
2526  {
2527  case IS_TRUE:
2528  clausename = "IS TRUE";
2529  break;
2530  case IS_NOT_TRUE:
2531  clausename = "IS NOT TRUE";
2532  break;
2533  case IS_FALSE:
2534  clausename = "IS FALSE";
2535  break;
2536  case IS_NOT_FALSE:
2537  clausename = "IS NOT FALSE";
2538  break;
2539  case IS_UNKNOWN:
2540  clausename = "IS UNKNOWN";
2541  break;
2542  case IS_NOT_UNKNOWN:
2543  clausename = "IS NOT UNKNOWN";
2544  break;
2545  default:
2546  elog(ERROR, "unrecognized booltesttype: %d",
2547  (int) b->booltesttype);
2548  clausename = NULL; /* keep compiler quiet */
2549  }
2550 
2551  b->arg = (Expr *) transformExprRecurse(pstate, (Node *) b->arg);
2552 
2553  b->arg = (Expr *) coerce_to_boolean(pstate,
2554  (Node *) b->arg,
2555  clausename);
2556 
2557  return (Node *) b;
2558 }
2559 
2560 static Node *
2562 {
2563  int sublevels_up;
2564 
2565  /* CURRENT OF can only appear at top level of UPDATE/DELETE */
2566  Assert(pstate->p_target_rangetblentry != NULL);
2567  cexpr->cvarno = RTERangeTablePosn(pstate,
2568  pstate->p_target_rangetblentry,
2569  &sublevels_up);
2570  Assert(sublevels_up == 0);
2571 
2572  /*
2573  * Check to see if the cursor name matches a parameter of type REFCURSOR.
2574  * If so, replace the raw name reference with a parameter reference. (This
2575  * is a hack for the convenience of plpgsql.)
2576  */
2577  if (cexpr->cursor_name != NULL) /* in case already transformed */
2578  {
2579  ColumnRef *cref = makeNode(ColumnRef);
2580  Node *node = NULL;
2581 
2582  /* Build an unqualified ColumnRef with the given name */
2583  cref->fields = list_make1(makeString(cexpr->cursor_name));
2584  cref->location = -1;
2585 
2586  /* See if there is a translation available from a parser hook */
2587  if (pstate->p_pre_columnref_hook != NULL)
2588  node = (*pstate->p_pre_columnref_hook) (pstate, cref);
2589  if (node == NULL && pstate->p_post_columnref_hook != NULL)
2590  node = (*pstate->p_post_columnref_hook) (pstate, cref, NULL);
2591 
2592  /*
2593  * XXX Should we throw an error if we get a translation that isn't a
2594  * refcursor Param? For now it seems best to silently ignore false
2595  * matches.
2596  */
2597  if (node != NULL && IsA(node, Param))
2598  {
2599  Param *p = (Param *) node;
2600 
2601  if (p->paramkind == PARAM_EXTERN &&
2602  p->paramtype == REFCURSOROID)
2603  {
2604  /* Matches, so convert CURRENT OF to a param reference */
2605  cexpr->cursor_name = NULL;
2606  cexpr->cursor_param = p->paramid;
2607  }
2608  }
2609  }
2610 
2611  return (Node *) cexpr;
2612 }
2613 
2614 /*
2615  * Construct a whole-row reference to represent the notation "relation.*".
2616  */
2617 static Node *
2618 transformWholeRowRef(ParseState *pstate, RangeTblEntry *rte, int location)
2619 {
2620  Var *result;
2621  int vnum;
2622  int sublevels_up;
2623 
2624  /* Find the RTE's rangetable location */
2625  vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
2626 
2627  /*
2628  * Build the appropriate referencing node. Note that if the RTE is a
2629  * function returning scalar, we create just a plain reference to the
2630  * function value, not a composite containing a single column. This is
2631  * pretty inconsistent at first sight, but it's what we've done
2632  * historically. One argument for it is that "rel" and "rel.*" mean the
2633  * same thing for composite relations, so why not for scalar functions...
2634  */
2635  result = makeWholeRowVar(rte, vnum, sublevels_up, true);
2636 
2637  /* location is not filled in by makeWholeRowVar */
2638  result->location = location;
2639 
2640  /* mark relation as requiring whole-row SELECT access */
2641  markVarForSelectPriv(pstate, result, rte);
2642 
2643  return (Node *) result;
2644 }
2645 
2646 /*
2647  * Handle an explicit CAST construct.
2648  *
2649  * Transform the argument, look up the type name, and apply any necessary
2650  * coercion function(s).
2651  */
2652 static Node *
2654 {
2655  Node *result;
2656  Node *arg = tc->arg;
2657  Node *expr;
2658  Oid inputType;
2659  Oid targetType;
2660  int32 targetTypmod;
2661  int location;
2662 
2663  /* Look up the type name first */
2664  typenameTypeIdAndMod(pstate, tc->typeName, &targetType, &targetTypmod);
2665 
2666  /*
2667  * Look through any AEXPR_PAREN nodes that may have been inserted thanks
2668  * to operator_precedence_warning. Otherwise, ARRAY[]::foo[] behaves
2669  * differently from (ARRAY[])::foo[].
2670  */
2671  while (arg && IsA(arg, A_Expr) &&
2672  ((A_Expr *) arg)->kind == AEXPR_PAREN)
2673  arg = ((A_Expr *) arg)->lexpr;
2674 
2675  /*
2676  * If the subject of the typecast is an ARRAY[] construct and the target
2677  * type is an array type, we invoke transformArrayExpr() directly so that
2678  * we can pass down the type information. This avoids some cases where
2679  * transformArrayExpr() might not infer the correct type. Otherwise, just
2680  * transform the argument normally.
2681  */
2682  if (IsA(arg, A_ArrayExpr))
2683  {
2684  Oid targetBaseType;
2685  int32 targetBaseTypmod;
2686  Oid elementType;
2687 
2688  /*
2689  * If target is a domain over array, work with the base array type
2690  * here. Below, we'll cast the array type to the domain. In the
2691  * usual case that the target is not a domain, the remaining steps
2692  * will be a no-op.
2693  */
2694  targetBaseTypmod = targetTypmod;
2695  targetBaseType = getBaseTypeAndTypmod(targetType, &targetBaseTypmod);
2696  elementType = get_element_type(targetBaseType);
2697  if (OidIsValid(elementType))
2698  {
2699  expr = transformArrayExpr(pstate,
2700  (A_ArrayExpr *) arg,
2701  targetBaseType,
2702  elementType,
2703  targetBaseTypmod);
2704  }
2705  else
2706  expr = transformExprRecurse(pstate, arg);
2707  }
2708  else
2709  expr = transformExprRecurse(pstate, arg);
2710 
2711  inputType = exprType(expr);
2712  if (inputType == InvalidOid)
2713  return expr; /* do nothing if NULL input */
2714 
2715  /*
2716  * Location of the coercion is preferentially the location of the :: or
2717  * CAST symbol, but if there is none then use the location of the type
2718  * name (this can happen in TypeName 'string' syntax, for instance).
2719  */
2720  location = tc->location;
2721  if (location < 0)
2722  location = tc->typeName->location;
2723 
2724  result = coerce_to_target_type(pstate, expr, inputType,
2725  targetType, targetTypmod,
2728  location);
2729  if (result == NULL)
2730  ereport(ERROR,
2731  (errcode(ERRCODE_CANNOT_COERCE),
2732  errmsg("cannot cast type %s to %s",
2733  format_type_be(inputType),
2734  format_type_be(targetType)),
2735  parser_coercion_errposition(pstate, location, expr)));
2736 
2737  return result;
2738 }
2739 
2740 /*
2741  * Handle an explicit COLLATE clause.
2742  *
2743  * Transform the argument, and look up the collation name.
2744  */
2745 static Node *
2747 {
2748  CollateExpr *newc;
2749  Oid argtype;
2750 
2751  newc = makeNode(CollateExpr);
2752  newc->arg = (Expr *) transformExprRecurse(pstate, c->arg);
2753 
2754  argtype = exprType((Node *) newc->arg);
2755 
2756  /*
2757  * The unknown type is not collatable, but coerce_type() takes care of it
2758  * separately, so we'll let it go here.
2759  */
2760  if (!type_is_collatable(argtype) && argtype != UNKNOWNOID)
2761  ereport(ERROR,
2762  (errcode(ERRCODE_DATATYPE_MISMATCH),
2763  errmsg("collations are not supported by type %s",
2764  format_type_be(argtype)),
2765  parser_errposition(pstate, c->location)));
2766 
2767  newc->collOid = LookupCollation(pstate, c->collname, c->location);
2768  newc->location = c->location;
2769 
2770  return (Node *) newc;
2771 }
2772 
2773 /*
2774  * Transform a "row compare-op row" construct
2775  *
2776  * The inputs are lists of already-transformed expressions.
2777  * As with coerce_type, pstate may be NULL if no special unknown-Param
2778  * processing is wanted.
2779  *
2780  * The output may be a single OpExpr, an AND or OR combination of OpExprs,
2781  * or a RowCompareExpr. In all cases it is guaranteed to return boolean.
2782  * The AND, OR, and RowCompareExpr cases further imply things about the
2783  * behavior of the operators (ie, they behave as =, <>, or < <= > >=).
2784  */
2785 static Node *
2787  List *largs, List *rargs, int location)
2788 {
2789  RowCompareExpr *rcexpr;
2790  RowCompareType rctype;
2791  List *opexprs;
2792  List *opnos;
2793  List *opfamilies;
2794  ListCell *l,
2795  *r;
2796  List **opinfo_lists;
2797  Bitmapset *strats;
2798  int nopers;
2799  int i;
2800 
2801  nopers = list_length(largs);
2802  if (nopers != list_length(rargs))
2803  ereport(ERROR,
2804  (errcode(ERRCODE_SYNTAX_ERROR),
2805  errmsg("unequal number of entries in row expressions"),
2806  parser_errposition(pstate, location)));
2807 
2808  /*
2809  * We can't compare zero-length rows because there is no principled basis
2810  * for figuring out what the operator is.
2811  */
2812  if (nopers == 0)
2813  ereport(ERROR,
2814  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2815  errmsg("cannot compare rows of zero length"),
2816  parser_errposition(pstate, location)));
2817 
2818  /*
2819  * Identify all the pairwise operators, using make_op so that behavior is
2820  * the same as in the simple scalar case.
2821  */
2822  opexprs = NIL;
2823  forboth(l, largs, r, rargs)
2824  {
2825  Node *larg = (Node *) lfirst(l);
2826  Node *rarg = (Node *) lfirst(r);
2827  OpExpr *cmp;
2828 
2829  cmp = castNode(OpExpr, make_op(pstate, opname, larg, rarg,
2830  pstate->p_last_srf, location));
2831 
2832  /*
2833  * We don't use coerce_to_boolean here because we insist on the
2834  * operator yielding boolean directly, not via coercion. If it
2835  * doesn't yield bool it won't be in any index opfamilies...
2836  */
2837  if (cmp->opresulttype != BOOLOID)
2838  ereport(ERROR,
2839  (errcode(ERRCODE_DATATYPE_MISMATCH),
2840  errmsg("row comparison operator must yield type boolean, "
2841  "not type %s",
2843  parser_errposition(pstate, location)));
2844  if (expression_returns_set((Node *) cmp))
2845  ereport(ERROR,
2846  (errcode(ERRCODE_DATATYPE_MISMATCH),
2847  errmsg("row comparison operator must not return a set"),
2848  parser_errposition(pstate, location)));
2849  opexprs = lappend(opexprs, cmp);
2850  }
2851 
2852  /*
2853  * If rows are length 1, just return the single operator. In this case we
2854  * don't insist on identifying btree semantics for the operator (but we
2855  * still require it to return boolean).
2856  */
2857  if (nopers == 1)
2858  return (Node *) linitial(opexprs);
2859 
2860  /*
2861  * Now we must determine which row comparison semantics (= <> < <= > >=)
2862  * apply to this set of operators. We look for btree opfamilies
2863  * containing the operators, and see which interpretations (strategy
2864  * numbers) exist for each operator.
2865  */
2866  opinfo_lists = (List **) palloc(nopers * sizeof(List *));
2867  strats = NULL;
2868  i = 0;
2869  foreach(l, opexprs)
2870  {
2871  Oid opno = ((OpExpr *) lfirst(l))->opno;
2872  Bitmapset *this_strats;
2873  ListCell *j;
2874 
2875  opinfo_lists[i] = get_op_btree_interpretation(opno);
2876 
2877  /*
2878  * convert strategy numbers into a Bitmapset to make the intersection
2879  * calculation easy.
2880  */
2881  this_strats = NULL;
2882  foreach(j, opinfo_lists[i])
2883  {
2884  OpBtreeInterpretation *opinfo = lfirst(j);
2885 
2886  this_strats = bms_add_member(this_strats, opinfo->strategy);
2887  }
2888  if (i == 0)
2889  strats = this_strats;
2890  else
2891  strats = bms_int_members(strats, this_strats);
2892  i++;
2893  }
2894 
2895  /*
2896  * If there are multiple common interpretations, we may use any one of
2897  * them ... this coding arbitrarily picks the lowest btree strategy
2898  * number.
2899  */
2900  i = bms_first_member(strats);
2901  if (i < 0)
2902  {
2903  /* No common interpretation, so fail */
2904  ereport(ERROR,
2905  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2906  errmsg("could not determine interpretation of row comparison operator %s",
2907  strVal(llast(opname))),
2908  errhint("Row comparison operators must be associated with btree operator families."),
2909  parser_errposition(pstate, location)));
2910  }
2911  rctype = (RowCompareType) i;
2912 
2913  /*
2914  * For = and <> cases, we just combine the pairwise operators with AND or
2915  * OR respectively.
2916  */
2917  if (rctype == ROWCOMPARE_EQ)
2918  return (Node *) makeBoolExpr(AND_EXPR, opexprs, location);
2919  if (rctype == ROWCOMPARE_NE)
2920  return (Node *) makeBoolExpr(OR_EXPR, opexprs, location);
2921 
2922  /*
2923  * Otherwise we need to choose exactly which opfamily to associate with
2924  * each operator.
2925  */
2926  opfamilies = NIL;
2927  for (i = 0; i < nopers; i++)
2928  {
2929  Oid opfamily = InvalidOid;
2930  ListCell *j;
2931 
2932  foreach(j, opinfo_lists[i])
2933  {
2934  OpBtreeInterpretation *opinfo = lfirst(j);
2935 
2936  if (opinfo->strategy == rctype)
2937  {
2938  opfamily = opinfo->opfamily_id;
2939  break;
2940  }
2941  }
2942  if (OidIsValid(opfamily))
2943  opfamilies = lappend_oid(opfamilies, opfamily);
2944  else /* should not happen */
2945  ereport(ERROR,
2946  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2947  errmsg("could not determine interpretation of row comparison operator %s",
2948  strVal(llast(opname))),
2949  errdetail("There are multiple equally-plausible candidates."),
2950  parser_errposition(pstate, location)));
2951  }
2952 
2953  /*
2954  * Now deconstruct the OpExprs and create a RowCompareExpr.
2955  *
2956  * Note: can't just reuse the passed largs/rargs lists, because of
2957  * possibility that make_op inserted coercion operations.
2958  */
2959  opnos = NIL;
2960  largs = NIL;
2961  rargs = NIL;
2962  foreach(l, opexprs)
2963  {
2964  OpExpr *cmp = (OpExpr *) lfirst(l);
2965 
2966  opnos = lappend_oid(opnos, cmp->opno);
2967  largs = lappend(largs, linitial(cmp->args));
2968  rargs = lappend(rargs, lsecond(cmp->args));
2969  }
2970 
2971  rcexpr = makeNode(RowCompareExpr);
2972  rcexpr->rctype = rctype;
2973  rcexpr->opnos = opnos;
2974  rcexpr->opfamilies = opfamilies;
2975  rcexpr->inputcollids = NIL; /* assign_expr_collations will fix this */
2976  rcexpr->largs = largs;
2977  rcexpr->rargs = rargs;
2978 
2979  return (Node *) rcexpr;
2980 }
2981 
2982 /*
2983  * Transform a "row IS DISTINCT FROM row" construct
2984  *
2985  * The input RowExprs are already transformed
2986  */
2987 static Node *
2989  RowExpr *lrow, RowExpr *rrow,
2990  int location)
2991 {
2992  Node *result = NULL;
2993  List *largs = lrow->args;
2994  List *rargs = rrow->args;
2995  ListCell *l,
2996  *r;
2997 
2998  if (list_length(largs) != list_length(rargs))
2999  ereport(ERROR,
3000  (errcode(ERRCODE_SYNTAX_ERROR),
3001  errmsg("unequal number of entries in row expressions"),
3002  parser_errposition(pstate, location)));
3003 
3004  forboth(l, largs, r, rargs)
3005  {
3006  Node *larg = (Node *) lfirst(l);
3007  Node *rarg = (Node *) lfirst(r);
3008  Node *cmp;
3009 
3010  cmp = (Node *) make_distinct_op(pstate, opname, larg, rarg, location);
3011  if (result == NULL)
3012  result = cmp;
3013  else
3014  result = (Node *) makeBoolExpr(OR_EXPR,
3015  list_make2(result, cmp),
3016  location);
3017  }
3018 
3019  if (result == NULL)
3020  {
3021  /* zero-length rows? Generate constant FALSE */
3022  result = makeBoolConst(false, false);
3023  }
3024 
3025  return result;
3026 }
3027 
3028 /*
3029  * make the node for an IS DISTINCT FROM operator
3030  */
3031 static Expr *
3032 make_distinct_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree,
3033  int location)
3034 {
3035  Expr *result;
3036 
3037  result = make_op(pstate, opname, ltree, rtree,
3038  pstate->p_last_srf, location);
3039  if (((OpExpr *) result)->opresulttype != BOOLOID)
3040  ereport(ERROR,
3041  (errcode(ERRCODE_DATATYPE_MISMATCH),
3042  errmsg("IS DISTINCT FROM requires = operator to yield boolean"),
3043  parser_errposition(pstate, location)));
3044  if (((OpExpr *) result)->opretset)
3045  ereport(ERROR,
3046  (errcode(ERRCODE_DATATYPE_MISMATCH),
3047  /* translator: %s is name of a SQL construct, eg NULLIF */
3048  errmsg("%s must not return a set", "IS DISTINCT FROM"),
3049  parser_errposition(pstate, location)));
3050 
3051  /*
3052  * We rely on DistinctExpr and OpExpr being same struct
3053  */
3054  NodeSetTag(result, T_DistinctExpr);
3055 
3056  return result;
3057 }
3058 
3059 /*
3060  * Produce a NullTest node from an IS [NOT] DISTINCT FROM NULL construct
3061  *
3062  * "arg" is the untransformed other argument
3063  */
3064 static Node *
3066 {
3067  NullTest *nt = makeNode(NullTest);
3068 
3069  nt->arg = (Expr *) transformExprRecurse(pstate, arg);
3070  /* the argument can be any type, so don't coerce it */
3071  if (distincta->kind == AEXPR_NOT_DISTINCT)
3072  nt->nulltesttype = IS_NULL;
3073  else
3074  nt->nulltesttype = IS_NOT_NULL;
3075  /* argisrow = false is correct whether or not arg is composite */
3076  nt->argisrow = false;
3077  nt->location = distincta->location;
3078  return (Node *) nt;
3079 }
3080 
3081 /*
3082  * Identify node's group for operator precedence warnings
3083  *
3084  * For items in nonzero groups, also return a suitable node name into *nodename
3085  *
3086  * Note: group zero is used for nodes that are higher or lower precedence
3087  * than everything that changed precedence; we need never issue warnings
3088  * related to such nodes.
3089  */
3090 static int
3091 operator_precedence_group(Node *node, const char **nodename)
3092 {
3093  int group = 0;
3094 
3095  *nodename = NULL;
3096  if (node == NULL)
3097  return 0;
3098 
3099  if (IsA(node, A_Expr))
3100  {
3101  A_Expr *aexpr = (A_Expr *) node;
3102 
3103  if (aexpr->kind == AEXPR_OP &&
3104  aexpr->lexpr != NULL &&
3105  aexpr->rexpr != NULL)
3106  {
3107  /* binary operator */
3108  if (list_length(aexpr->name) == 1)
3109  {
3110  *nodename = strVal(linitial(aexpr->name));
3111  /* Ignore if op was always higher priority than IS-tests */
3112  if (strcmp(*nodename, "+") == 0 ||
3113  strcmp(*nodename, "-") == 0 ||
3114  strcmp(*nodename, "*") == 0 ||
3115  strcmp(*nodename, "/") == 0 ||
3116  strcmp(*nodename, "%") == 0 ||
3117  strcmp(*nodename, "^") == 0)
3118  group = 0;
3119  else if (strcmp(*nodename, "<") == 0 ||
3120  strcmp(*nodename, ">") == 0)
3121  group = PREC_GROUP_LESS;
3122  else if (strcmp(*nodename, "=") == 0)
3123  group = PREC_GROUP_EQUAL;
3124  else if (strcmp(*nodename, "<=") == 0 ||
3125  strcmp(*nodename, ">=") == 0 ||
3126  strcmp(*nodename, "<>") == 0)
3127  group = PREC_GROUP_LESS_EQUAL;
3128  else
3129  group = PREC_GROUP_INFIX_OP;
3130  }
3131  else
3132  {
3133  /* schema-qualified operator syntax */
3134  *nodename = "OPERATOR()";
3135  group = PREC_GROUP_INFIX_OP;
3136  }
3137  }
3138  else if (aexpr->kind == AEXPR_OP &&
3139  aexpr->lexpr == NULL &&
3140  aexpr->rexpr != NULL)
3141  {
3142  /* prefix operator */
3143  if (list_length(aexpr->name) == 1)
3144  {
3145  *nodename = strVal(linitial(aexpr->name));
3146  /* Ignore if op was always higher priority than IS-tests */
3147  if (strcmp(*nodename, "+") == 0 ||
3148  strcmp(*nodename, "-"))
3149  group = 0;
3150  else
3151  group = PREC_GROUP_PREFIX_OP;
3152  }
3153  else
3154  {
3155  /* schema-qualified operator syntax */
3156  *nodename = "OPERATOR()";
3157  group = PREC_GROUP_PREFIX_OP;
3158  }
3159  }
3160  else if (aexpr->kind == AEXPR_OP &&
3161  aexpr->lexpr != NULL &&
3162  aexpr->rexpr == NULL)
3163  {
3164  /* postfix operator */
3165  if (list_length(aexpr->name) == 1)
3166  {
3167  *nodename = strVal(linitial(aexpr->name));
3168  group = PREC_GROUP_POSTFIX_OP;
3169  }
3170  else
3171  {
3172  /* schema-qualified operator syntax */
3173  *nodename = "OPERATOR()";
3174  group = PREC_GROUP_POSTFIX_OP;
3175  }
3176  }
3177  else if (aexpr->kind == AEXPR_OP_ANY ||
3178  aexpr->kind == AEXPR_OP_ALL)
3179  {
3180  *nodename = strVal(llast(aexpr->name));
3181  group = PREC_GROUP_POSTFIX_OP;
3182  }
3183  else if (aexpr->kind == AEXPR_DISTINCT ||
3184  aexpr->kind == AEXPR_NOT_DISTINCT)
3185  {
3186  *nodename = "IS";
3187  group = PREC_GROUP_INFIX_IS;
3188  }
3189  else if (aexpr->kind == AEXPR_OF)
3190  {
3191  *nodename = "IS";
3192  group = PREC_GROUP_POSTFIX_IS;
3193  }
3194  else if (aexpr->kind == AEXPR_IN)
3195  {
3196  *nodename = "IN";
3197  if (strcmp(strVal(linitial(aexpr->name)), "=") == 0)
3198  group = PREC_GROUP_IN;
3199  else
3200  group = PREC_GROUP_NOT_IN;
3201  }
3202  else if (aexpr->kind == AEXPR_LIKE)
3203  {
3204  *nodename = "LIKE";
3205  if (strcmp(strVal(linitial(aexpr->name)), "~~") == 0)
3206  group = PREC_GROUP_LIKE;
3207  else
3208  group = PREC_GROUP_NOT_LIKE;
3209  }
3210  else if (aexpr->kind == AEXPR_ILIKE)
3211  {
3212  *nodename = "ILIKE";
3213  if (strcmp(strVal(linitial(aexpr->name)), "~~*") == 0)
3214  group = PREC_GROUP_LIKE;
3215  else
3216  group = PREC_GROUP_NOT_LIKE;
3217  }
3218  else if (aexpr->kind == AEXPR_SIMILAR)
3219  {
3220  *nodename = "SIMILAR";
3221  if (strcmp(strVal(linitial(aexpr->name)), "~") == 0)
3222  group = PREC_GROUP_LIKE;
3223  else
3224  group = PREC_GROUP_NOT_LIKE;
3225  }
3226  else if (aexpr->kind == AEXPR_BETWEEN ||
3227  aexpr->kind == AEXPR_BETWEEN_SYM)
3228  {
3229  Assert(list_length(aexpr->name) == 1);
3230  *nodename = strVal(linitial(aexpr->name));
3231  group = PREC_GROUP_BETWEEN;
3232  }
3233  else if (aexpr->kind == AEXPR_NOT_BETWEEN ||
3234  aexpr->kind == AEXPR_NOT_BETWEEN_SYM)
3235  {
3236  Assert(list_length(aexpr->name) == 1);
3237  *nodename = strVal(linitial(aexpr->name));
3238  group = PREC_GROUP_NOT_BETWEEN;
3239  }
3240  }
3241  else if (IsA(node, NullTest) ||
3242  IsA(node, BooleanTest))
3243  {
3244  *nodename = "IS";
3245  group = PREC_GROUP_POSTFIX_IS;
3246  }
3247  else if (IsA(node, XmlExpr))
3248  {
3249  XmlExpr *x = (XmlExpr *) node;
3250 
3251  if (x->op == IS_DOCUMENT)
3252  {
3253  *nodename = "IS";
3254  group = PREC_GROUP_POSTFIX_IS;
3255  }
3256  }
3257  else if (IsA(node, SubLink))
3258  {
3259  SubLink *s = (SubLink *) node;
3260 
3261  if (s->subLinkType == ANY_SUBLINK ||
3262  s->subLinkType == ALL_SUBLINK)
3263  {
3264  if (s->operName == NIL)
3265  {
3266  *nodename = "IN";
3267  group = PREC_GROUP_IN;
3268  }
3269  else
3270  {
3271  *nodename = strVal(llast(s->operName));
3272  group = PREC_GROUP_POSTFIX_OP;
3273  }
3274  }
3275  }
3276  else if (IsA(node, BoolExpr))
3277  {
3278  /*
3279  * Must dig into NOTs to see if it's IS NOT DOCUMENT or NOT IN. This
3280  * opens us to possibly misrecognizing, eg, NOT (x IS DOCUMENT) as a
3281  * problematic construct. We can tell the difference by checking
3282  * whether the parse locations of the two nodes are identical.
3283  *
3284  * Note that when we are comparing the child node to its own children,
3285  * we will not know that it was a NOT. Fortunately, that doesn't
3286  * matter for these cases.
3287  */
3288  BoolExpr *b = (BoolExpr *) node;
3289 
3290  if (b->boolop == NOT_EXPR)
3291  {
3292  Node *child = (Node *) linitial(b->args);
3293 
3294  if (IsA(child, XmlExpr))
3295  {
3296  XmlExpr *x = (XmlExpr *) child;
3297 
3298  if (x->op == IS_DOCUMENT &&
3299  x->location == b->location)
3300  {
3301  *nodename = "IS";
3302  group = PREC_GROUP_POSTFIX_IS;
3303  }
3304  }
3305  else if (IsA(child, SubLink))
3306  {
3307  SubLink *s = (SubLink *) child;
3308 
3309  if (s->subLinkType == ANY_SUBLINK && s->operName == NIL &&
3310  s->location == b->location)
3311  {
3312  *nodename = "IN";
3313  group = PREC_GROUP_NOT_IN;
3314  }
3315  }
3316  }
3317  }
3318  return group;
3319 }
3320 
3321 /*
3322  * helper routine for delivering 9.4-to-9.5 operator precedence warnings
3323  *
3324  * opgroup/opname/location represent some parent node
3325  * lchild, rchild are its left and right children (either could be NULL)
3326  *
3327  * This should be called before transforming the child nodes, since if a
3328  * precedence-driven parsing change has occurred in a query that used to work,
3329  * it's quite possible that we'll get a semantic failure while analyzing the
3330  * child expression. We want to produce the warning before that happens.
3331  * In any case, operator_precedence_group() expects untransformed input.
3332  */
3333 static void
3335  int opgroup, const char *opname,
3336  Node *lchild, Node *rchild,
3337  int location)
3338 {
3339  int cgroup;
3340  const char *copname;
3341 
3342  Assert(opgroup > 0);
3343 
3344  /*
3345  * Complain if left child, which should be same or higher precedence
3346  * according to current rules, used to be lower precedence.
3347  *
3348  * Exception to precedence rules: if left child is IN or NOT IN or a
3349  * postfix operator, the grouping is syntactically forced regardless of
3350  * precedence.
3351  */
3352  cgroup = operator_precedence_group(lchild, &copname);
3353  if (cgroup > 0)
3354  {
3355  if (oldprecedence_l[cgroup] < oldprecedence_r[opgroup] &&
3356  cgroup != PREC_GROUP_IN &&
3357  cgroup != PREC_GROUP_NOT_IN &&
3358  cgroup != PREC_GROUP_POSTFIX_OP &&
3359  cgroup != PREC_GROUP_POSTFIX_IS)
3360  ereport(WARNING,
3361  (errmsg("operator precedence change: %s is now lower precedence than %s",
3362  opname, copname),
3363  parser_errposition(pstate, location)));
3364  }
3365 
3366  /*
3367  * Complain if right child, which should be higher precedence according to
3368  * current rules, used to be same or lower precedence.
3369  *
3370  * Exception to precedence rules: if right child is a prefix operator, the
3371  * grouping is syntactically forced regardless of precedence.
3372  */
3373  cgroup = operator_precedence_group(rchild, &copname);
3374  if (cgroup > 0)
3375  {
3376  if (oldprecedence_r[cgroup] <= oldprecedence_l[opgroup] &&
3377  cgroup != PREC_GROUP_PREFIX_OP)
3378  ereport(WARNING,
3379  (errmsg("operator precedence change: %s is now lower precedence than %s",
3380  opname, copname),
3381  parser_errposition(pstate, location)));
3382  }
3383 }
3384 
3385 /*
3386  * Produce a string identifying an expression by kind.
3387  *
3388  * Note: when practical, use a simple SQL keyword for the result. If that
3389  * doesn't work well, check call sites to see whether custom error message
3390  * strings are required.
3391  */
3392 const char *
3394 {
3395  switch (exprKind)
3396  {
3397  case EXPR_KIND_NONE:
3398  return "invalid expression context";
3399  case EXPR_KIND_OTHER:
3400  return "extension expression";
3401  case EXPR_KIND_JOIN_ON:
3402  return "JOIN/ON";
3403  case EXPR_KIND_JOIN_USING:
3404  return "JOIN/USING";
3406  return "sub-SELECT in FROM";
3408  return "function in FROM";
3409  case EXPR_KIND_WHERE:
3410  return "WHERE";
3411  case EXPR_KIND_POLICY:
3412  return "POLICY";
3413  case EXPR_KIND_HAVING:
3414  return "HAVING";
3415  case EXPR_KIND_FILTER:
3416  return "FILTER";
3418  return "window PARTITION BY";
3420  return "window ORDER BY";
3422  return "window RANGE";
3424  return "window ROWS";
3426  return "SELECT";
3428  return "INSERT";
3431  return "UPDATE";
3432  case EXPR_KIND_GROUP_BY:
3433  return "GROUP BY";
3434  case EXPR_KIND_ORDER_BY:
3435  return "ORDER BY";
3436  case EXPR_KIND_DISTINCT_ON:
3437  return "DISTINCT ON";
3438  case EXPR_KIND_LIMIT:
3439  return "LIMIT";
3440  case EXPR_KIND_OFFSET:
3441  return "OFFSET";
3442  case EXPR_KIND_RETURNING:
3443  return "RETURNING";
3444  case EXPR_KIND_VALUES:
3446  return "VALUES";
3449  return "CHECK";
3452  return "DEFAULT";
3454  return "index expression";
3456  return "index predicate";
3458  return "USING";
3460  return "EXECUTE";
3462  return "WHEN";
3464  return "PARTITION BY";
3465 
3466  /*
3467  * There is intentionally no default: case here, so that the
3468  * compiler will warn if we add a new ParseExprKind without
3469  * extending this switch. If we do see an unrecognized value at
3470  * runtime, we'll fall through to the "unrecognized" return.
3471  */
3472  }
3473  return "unrecognized expression kind";
3474 }
#define list_make2(x1, x2)
Definition: pg_list.h:140
Node * scanRTEForColumn(ParseState *pstate, RangeTblEntry *rte, char *colname, int location, int fuzzy_rte_penalty, FuzzyAttrMatchState *fuzzystate)
Value * makeString(char *str)
Definition: value.c:53
#define TIMESTAMPTZOID
Definition: pg_type.h:525
Expr * make_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree, Node *last_srf, int location)
Definition: parse_oper.c:744
static Node * transformAExprDistinct(ParseState *pstate, A_Expr *a)
Definition: parse_expr.c:991
Oid minmaxtype
Definition: primnodes.h:1063
bool multidims
Definition: primnodes.h:956
#define TIMEOID
Definition: pg_type.h:514
#define NIL
Definition: pg_list.h:69
static Node * transformRowExpr(ParseState *pstate, RowExpr *r, bool allowDefault)
Definition: parse_expr.c:2166
static bool exprIsNullConstant(Node *arg)
Definition: parse_expr.c:831
static Node * transformExprRecurse(ParseState *pstate, Node *expr)
Definition: parse_expr.c:164
List * args
Definition: primnodes.h:1067
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Definition: lsyscache.c:2288
bool p_hasSubLinks
Definition: parse_node.h:201
List * args
Definition: primnodes.h:986
int bms_first_member(Bitmapset *a)
Definition: bitmapset.c:885
#define DATEOID
Definition: pg_type.h:511
#define PREC_GROUP_PREFIX_OP
Definition: parse_expr.c:64
#define IsA(nodeptr, _type_)
Definition: nodes.h:560
static Node * transformIndirection(ParseState *pstate, A_Indirection *ind)
Definition: parse_expr.c:435
#define PREC_GROUP_INFIX_OP
Definition: parse_expr.c:63
#define NAMEOID
Definition: pg_type.h:300
Node * val
Definition: parsenodes.h:441
int errhint(const char *fmt,...)
Definition: elog.c:987
static Node * transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
Definition: parse_expr.c:2561
Expr * make_scalar_array_op(ParseState *pstate, List *opname, bool useOr, Node *ltree, Node *rtree, int location)
Definition: parse_oper.c:864
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:180
static Node * transformAExprOpAny(ParseState *pstate, A_Expr *a)
Definition: parse_expr.c:945
char * name
Definition: primnodes.h:1143
A_Expr_Kind kind
Definition: parsenodes.h:274
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1186
#define PREC_GROUP_POSTFIX_IS
Definition: parse_expr.c:51
static Node * transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m)
Definition: parse_expr.c:2247
char * name
Definition: parsenodes.h:439
void markVarForSelectPriv(ParseState *pstate, Var *var, RangeTblEntry *rte)
int32 anytime_typmod_check(bool istz, int32 typmod)
Definition: date.c:74
#define castNode(_type_, nodeptr)
Definition: nodes.h:578
#define TEXTOID
Definition: pg_type.h:324
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:276
Oid get_element_type(Oid typid)
Definition: lsyscache.c:2484
#define NodeSetTag(nodeptr, t)
Definition: nodes.h:558
Node * ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs, Node *last_srf, FuncCall *fn, int location)
Definition: parse_func.c:73
Oid get_array_type(Oid typid)
Definition: lsyscache.c:2512
int location
Definition: primnodes.h:1150
char * pstrdup(const char *in)
Definition: mcxt.c:1077
static int operator_precedence_group(Node *node, const char **nodename)
Definition: parse_expr.c:3091
static Node * transformAExprNullIf(ParseState *pstate, A_Expr *a)
Definition: parse_expr.c:1047
RowCompareType rctype
Definition: primnodes.h:1031
List * opfamilies
Definition: primnodes.h:1033
bool expression_returns_set(Node *clause)
Definition: nodeFuncs.c:670
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:146
#define PREC_GROUP_IN
Definition: parse_expr.c:58
#define llast(l)
Definition: pg_list.h:131
Oid type
Definition: primnodes.h:1148
static Node * transformSubLink(ParseState *pstate, SubLink *sublink)
Definition: parse_expr.c:1771
Node * coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition: parse_coerce.c:156
#define INT4OID
Definition: pg_type.h:316
ParamKind paramkind
Definition: primnodes.h:244
Definition: nodes.h:509
#define strVal(v)
Definition: value.h:54
Var * makeWholeRowVar(RangeTblEntry *rte, Index varno, Index varlevelsup, bool allowScalar)
Definition: makefuncs.c:132
int errcode(int sqlerrcode)
Definition: elog.c:575
List * p_multiassign_exprs
Definition: parse_node.h:188
Oid array_typeid
Definition: primnodes.h:952
char * format_type_be(Oid type_oid)
Definition: format_type.c:94
static Expr * make_distinct_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree, int location)
Definition: parse_expr.c:3032
List * list_concat(List *list1, List *list2)
Definition: list.c:321
#define PREC_GROUP_INFIX_IS
Definition: parse_expr.c:52
return result
Definition: formatting.c:1633
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
TypeName * typeName
Definition: parsenodes.h:750
List * list_delete_ptr(List *list, void *datum)
Definition: list.c:590
int location
Definition: parsenodes.h:358
Oid casetype
Definition: primnodes.h:906
unsigned int Oid
Definition: postgres_ext.h:31
A_Expr * makeSimpleA_Expr(A_Expr_Kind kind, char *name, Node *lexpr, Node *rexpr, int location)
Definition: makefuncs.c:49
List * arg_names
Definition: primnodes.h:1145
Definition: primnodes.h:163
Const * make_const(ParseState *pstate, Value *value, int location)
Definition: parse_node.c:470
static Node * transformBooleanTest(ParseState *pstate, BooleanTest *b)
Definition: parse_expr.c:2516
static Node * transformXmlExpr(ParseState *pstate, XmlExpr *x)
Definition: parse_expr.c:2339
List * lappend_oid(List *list, Oid datum)
Definition: list.c:164
#define OidIsValid(objectId)
Definition: c.h:538
ParseExprKind
Definition: parse_node.h:33
RangeTblEntry * refnameRangeTblEntry(ParseState *pstate, const char *schemaname, const char *refname, int location, int *sublevels_up)
List * agg_order
Definition: parsenodes.h:351
#define lsecond(l)
Definition: pg_list.h:116
static Node * transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c)
Definition: parse_expr.c:2198
int32 typeMod
Definition: primnodes.h:937
int location
Definition: primnodes.h:564
int location
Definition: primnodes.h:922
SQLValueFunctionOp op
Definition: primnodes.h:1104
static Node * make_row_comparison_op(ParseState *pstate, List *opname, List *largs, List *rargs, int location)
Definition: parse_expr.c:2786
const char * ParseExprKindName(ParseExprKind exprKind)
Definition: parse_expr.c:3393
PostParseColumnRefHook p_post_columnref_hook
Definition: parse_node.h:211
signed int int32
Definition: c.h:256
Expr * makeBoolExpr(BoolExprType boolop, List *args, int location)
Definition: makefuncs.c:366
List * targetList
Definition: parsenodes.h:138
int location
Definition: parsenodes.h:299
int location
Definition: parsenodes.h:235
int location
Definition: parsenodes.h:442
#define list_make1(x1)
Definition: pg_list.h:139
void assign_expr_collations(ParseState *pstate, Node *expr)
Oid opresulttype
Definition: primnodes.h:498
char * map_sql_identifier_to_xml_name(char *ident, bool fully_escaped, bool escape_period)
Definition: xml.c:1897
#define TIMESTAMPOID
Definition: pg_type.h:519
bool resjunk
Definition: primnodes.h:1375
#define linitial(l)
Definition: pg_list.h:111
#define ERROR
Definition: elog.h:43
List * colnames
Definition: primnodes.h:999
Oid paramcollid
Definition: primnodes.h:248
static Node * transformBoolExpr(ParseState *pstate, BoolExpr *a)
Definition: parse_expr.c:1404
int location
Definition: primnodes.h:249
char * FigureColname(Node *node)
List * args
Definition: primnodes.h:1047
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:77
#define PREC_GROUP_BETWEEN
Definition: parse_expr.c:57
BoolExprType boolop
Definition: primnodes.h:562
Node * makeBoolConst(bool value, bool isnull)
Definition: makefuncs.c:354
Expr * arg
Definition: primnodes.h:1180
#define PREC_GROUP_NOT_IN
Definition: parse_expr.c:61
static Node * transformArrayExpr(ParseState *pstate, A_ArrayExpr *a, Oid array_type, Oid element_type, int32 typmod)
Definition: parse_expr.c:2008
#define lfirst_node(type, lc)
Definition: pg_list.h:109
static Node * transformAExprOpAll(ParseState *pstate, A_Expr *a)
Definition: parse_expr.c:968
char * get_database_name(Oid dbid)
Definition: dbcommands.c:2056
int location
Definition: primnodes.h:178
#define XMLOID
Definition: pg_type.h:359
static Node * transformFuncCall(ParseState *pstate, FuncCall *fn)
Definition: parse_expr.c:1440
int location
Definition: primnodes.h:1000
char * c
void * list_nth(const List *list, int n)
Definition: list.c:410
List * elements
Definition: parsenodes.h:414
ParseParamRefHook p_paramref_hook
Definition: parse_node.h:212
int location
Definition: primnodes.h:1068
void check_stack_depth(void)
Definition: postgres.c:3117
Node * rexpr
Definition: parsenodes.h:277
#define PREC_GROUP_NOT_LIKE
Definition: parse_expr.c:59
int errdetail(const char *fmt,...)
Definition: elog.c:873
Expr * arg
Definition: primnodes.h:1203
AttrNumber resno
Definition: primnodes.h:1369
static Node * transformParamRef(ParseState *pstate, ParamRef *pref)
Definition: parse_expr.c:807
int location
Definition: parsenodes.h:278
void errorMissingRTE(ParseState *pstate, RangeVar *relation)
char * cursor_name
Definition: primnodes.h:1278
#define RECORDOID
Definition: pg_type.h:680
A_Expr * makeA_Expr(A_Expr_Kind kind, List *name, Node *lexpr, Node *rexpr, int location)
Definition: makefuncs.c:31
static Node * transformAExprOf(ParseState *pstate, A_Expr *a)
Definition: parse_expr.c:1093
List * elements
Definition: primnodes.h:955
bool type_is_rowtype(Oid typid)
Definition: lsyscache.c:2404
#define ereport(elevel, rest)
Definition: elog.h:122
Node * lexpr
Definition: parsenodes.h:276
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:235
static Node * transformAExprOp(ParseState *pstate, A_Expr *a)
Definition: parse_expr.c:844
#define PREC_GROUP_LIKE
Definition: parse_expr.c:56
Definition: ltree.h:19
void errorMissingColumn(ParseState *pstate, char *relname, char *colname, int location)
XmlOptionType xmloption
Definition: parsenodes.h:748
Node * coerce_to_common_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *context)
#define REFCURSOROID
Definition: pg_type.h:558
List * lappend(List *list, void *datum)
Definition: list.c:128
static chr element(struct vars *v, const chr *startp, const chr *endp)
Definition: regc_locale.c:380
#define WARNING
Definition: elog.h:40
Definition: nodes.h:146
XmlExprOp op
Definition: primnodes.h:1142
char * NameListToString(List *names)
Definition: namespace.c:3063
static Node * transformMultiAssignRef(ParseState *pstate, MultiAssignRef *maref)
Definition: parse_expr.c:1484
static Node * transformCollateClause(ParseState *pstate, CollateClause *c)
Definition: parse_expr.c:2746
List * args
Definition: primnodes.h:909
bool Transform_null_equals
Definition: parse_expr.c:45
int location
Definition: primnodes.h:203
List * get_op_btree_interpretation(Oid opno)
Definition: lsyscache.c:598
int location
Definition: primnodes.h:957
BoolTestType booltesttype
Definition: primnodes.h:1204
List * transformExpressionList(ParseState *pstate, List *exprlist, ParseExprKind exprKind, bool allowDefault)
Definition: parse_target.c:228
Node * p_last_srf
Definition: parse_node.h:204
Oid MyDatabaseId
Definition: globals.c:77
Node * transformGroupingFunc(ParseState *pstate, GroupingFunc *p)
Definition: parse_agg.c:248
RangeTblEntry * GetRTEByRangeTablePosn(ParseState *pstate, int varno, int sublevels_up)
RangeTblEntry * p_target_rangetblentry
Definition: parse_node.h:183
bool operator_precedence_warning
Definition: parse_expr.c:44
TypeName * typeName
Definition: parsenodes.h:298
static Node * make_row_distinct_op(ParseState *pstate, List *opname, RowExpr *lrow, RowExpr *rrow, int location)
Definition: parse_expr.c:2988
int number
Definition: parsenodes.h:244
static void emit_precedence_warnings(ParseState *pstate, int opgroup, const char *opname, Node *lchild, Node *rchild, int location)
Definition: parse_expr.c:3334
static Node * transformWholeRowRef(ParseState *pstate, RangeTblEntry *rte, int location)
Definition: parse_expr.c:2618
ParseExprKind p_expr_kind
Definition: parse_node.h:186
#define PREC_GROUP_EQUAL
Definition: parse_expr.c:54
NullTestType nulltesttype
Definition: primnodes.h:1181
int32 typmod
Definition: primnodes.h:1149
void typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
Definition: parse_type.c:293
Oid LookupCollation(ParseState *pstate, List *collnames, int location)
Definition: parse_type.c:496
#define InvalidOid
Definition: postgres_ext.h:36
Query * parse_sub_analyze(Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE, bool locked_from_parent, bool resolve_unknowns)
Definition: analyze.c:160
List * named_args
Definition: primnodes.h:1144
RowCompareType
Definition: primnodes.h:1017
static void * fn(void *arg)
CmdType commandType
Definition: parsenodes.h:110
List * args
Definition: primnodes.h:1146
int32 paramtypmod
Definition: primnodes.h:247
int location
Definition: parsenodes.h:245
Node * colNameToVar(ParseState *pstate, char *colname, bool localonly, int location)
List * lcons(void *datum, List *list)
Definition: list.c:259
int errmsg_internal(const char *fmt,...)
Definition: elog.c:827
#define makeNode(_type_)
Definition: nodes.h:557
Expr * arg
Definition: primnodes.h:478
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:675
#define lfirst(lc)
Definition: pg_list.h:106
char * aliasname
Definition: primnodes.h:42
int location
Definition: parsenodes.h:288
Definition: value.h:42
List * indirection
Definition: parsenodes.h:405
int32 anytimestamp_typmod_check(bool istz, int32 typmod)
Definition: timestamp.c:102
bool contain_vars_of_level(Node *node, int levelsup)
Definition: var.c:369
Expr * expr
Definition: primnodes.h:1368
XmlOptionType xmloption
Definition: primnodes.h:1147
int paramid
Definition: primnodes.h:245
#define ISCOMPLEX(typeid)
Definition: parse_type.h:53
#define TIMETZOID
Definition: pg_type.h:536
#define lfourth(l)
Definition: pg_list.h:126
int location
Definition: parsenodes.h:215
int location
Definition: primnodes.h:1183
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
List * args
Definition: parsenodes.h:350
Oid row_typeid
Definition: primnodes.h:987
static int list_length(const List *l)
Definition: pg_list.h:89
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:720
Expr * arg
Definition: primnodes.h:876
int location
Definition: primnodes.h:911
#define type_is_array(typid)
Definition: lsyscache.h:180
static Node * make_nulltest_from_distinct(ParseState *pstate, A_Expr *distincta, Node *arg)
Definition: parse_expr.c:3065
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:698
#define BOOLOID
Definition: pg_type.h:288
List * args
Definition: primnodes.h:563
#define UNKNOWNOID
Definition: pg_type.h:431
List * name
Definition: parsenodes.h:275
static Node * transformCaseExpr(ParseState *pstate, CaseExpr *c)
Definition: parse_expr.c:1631
#define PREC_GROUP_LESS
Definition: parse_expr.c:53
#define InvalidAttrNumber
Definition: attnum.h:23
#define nodeTag(nodeptr)
Definition: nodes.h:514
Oid element_typeid
Definition: primnodes.h:954
int RTERangeTablePosn(ParseState *pstate, RangeTblEntry *rte, int *sublevels_up)
Definition: nodes.h:286
static Node * transformTypeCast(ParseState *pstate, TypeCast *tc)
Definition: parse_expr.c:2653
static const int oldprecedence_l[]
Definition: parse_expr.c:85
List * collname
Definition: parsenodes.h:309
e
Definition: preproc-init.c:82
static Node * transformColumnRef(ParseState *pstate, ColumnRef *cref)
Definition: parse_expr.c:508
void * palloc(Size size)
Definition: mcxt.c:849
int errmsg(const char *fmt,...)
Definition: elog.c:797
static Node * transformXmlSerialize(ParseState *pstate, XmlSerialize *xs)
Definition: parse_expr.c:2473
static const int oldprecedence_r[]
Definition: parse_expr.c:88
static void unknown_attribute(ParseState *pstate, Node *relref, char *attname, int location)
Definition: parse_expr.c:389
int parser_coercion_errposition(ParseState *pstate, int coerce_location, Node *input_expr)
int i
#define PREC_GROUP_LESS_EQUAL
Definition: parse_expr.c:55
Oid coalescetype
Definition: primnodes.h:1045
int count_nonjunk_tlist_entries(List *tlist)
Definition: tlist.c:189
static Node * transformSQLValueFunction(ParseState *pstate, SQLValueFunction *svf)
Definition: parse_expr.c:2286
Node * coerce_to_specific_type(ParseState *pstate, Node *node, Oid targetTypeId, const char *constructName)
Node * expr
Definition: parsenodes.h:749
void * arg
Oid select_common_type(ParseState *pstate, List *exprs, const char *context, Node **which_expr)
#define lthird(l)
Definition: pg_list.h:121
bool argisrow
Definition: primnodes.h:1182
MinMaxOp op
Definition: primnodes.h:1066
Expr * arg
Definition: primnodes.h:908
Oid opno
Definition: primnodes.h:496
#define elog
Definition: elog.h:219
PreParseColumnRefHook p_pre_columnref_hook
Definition: parse_node.h:210
#define PREC_GROUP_POSTFIX_OP
Definition: parse_expr.c:62
List * funcname
Definition: parsenodes.h:349
Alias * eref
Definition: parsenodes.h:1043
Expr * result
Definition: primnodes.h:921
Node * node
Definition: parsenodes.h:468
bool agg_within_group
Definition: parsenodes.h:353
#define copyObject(obj)
Definition: nodes.h:622
List * args
Definition: primnodes.h:502
Bitmapset * bms_int_members(Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:791
List * inputcollids
Definition: primnodes.h:1034
#define PREC_GROUP_NOT_BETWEEN
Definition: parse_expr.c:60
Expr * defresult
Definition: primnodes.h:910
Expr * expr
Definition: primnodes.h:920
int location
Definition: primnodes.h:878
CoercionForm row_format
Definition: primnodes.h:998
bool type_is_collatable(Oid typid)
Definition: lsyscache.c:2806
Value val
Definition: parsenodes.h:287
Definition: pg_list.h:45
#define _(x)
Definition: elog.c:84
long val
Definition: informix.c:689
Oid paramtype
Definition: primnodes.h:246
ArrayRef * transformArraySubscripts(ParseState *pstate, Node *arrayBase, Oid arrayType, Oid elementType, int32 arrayTypMod, List *indirection, Node *assignFrom)
Definition: parse_node.c:294
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
Definition: makefuncs.c:419
static Node * transformAExprBetween(ParseState *pstate, A_Expr *a)
Definition: parse_expr.c:1294
List * fields
Definition: parsenodes.h:234
NodeTag type
Definition: value.h:44
bool opretset
Definition: primnodes.h:499
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:742
Oid typenameTypeId(ParseState *pstate, const TypeName *typeName)
Definition: parse_type.c:274
Node * arg
Definition: parsenodes.h:297
static Node * transformAExprIn(ParseState *pstate, A_Expr *a)
Definition: parse_expr.c:1134
Node * coerce_to_boolean(ParseState *pstate, Node *node, const char *constructName)