PostgreSQL Source Code  git master
nodeFuncs.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * nodeFuncs.c
4  * Various general-purpose manipulations of Node trees
5  *
6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/nodes/nodeFuncs.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include "catalog/pg_collation.h"
18 #include "catalog/pg_type.h"
19 #include "miscadmin.h"
20 #include "nodes/execnodes.h"
21 #include "nodes/nodeFuncs.h"
22 #include "nodes/pathnodes.h"
23 #include "utils/builtins.h"
24 #include "utils/lsyscache.h"
25 
26 static bool expression_returns_set_walker(Node *node, void *context);
27 static int leftmostLoc(int loc1, int loc2);
28 static bool fix_opfuncids_walker(Node *node, void *context);
29 static bool planstate_walk_subplans(List *plans,
30  planstate_tree_walker_callback walker,
31  void *context);
32 static bool planstate_walk_members(PlanState **planstates, int nplans,
33  planstate_tree_walker_callback walker,
34  void *context);
35 
36 
37 /*
38  * exprType -
39  * returns the Oid of the type of the expression's result.
40  */
41 Oid
42 exprType(const Node *expr)
43 {
44  Oid type;
45 
46  if (!expr)
47  return InvalidOid;
48 
49  switch (nodeTag(expr))
50  {
51  case T_Var:
52  type = ((const Var *) expr)->vartype;
53  break;
54  case T_Const:
55  type = ((const Const *) expr)->consttype;
56  break;
57  case T_Param:
58  type = ((const Param *) expr)->paramtype;
59  break;
60  case T_Aggref:
61  type = ((const Aggref *) expr)->aggtype;
62  break;
63  case T_GroupingFunc:
64  type = INT4OID;
65  break;
66  case T_WindowFunc:
67  type = ((const WindowFunc *) expr)->wintype;
68  break;
69  case T_MergeSupportFunc:
70  type = ((const MergeSupportFunc *) expr)->msftype;
71  break;
72  case T_SubscriptingRef:
73  type = ((const SubscriptingRef *) expr)->refrestype;
74  break;
75  case T_FuncExpr:
76  type = ((const FuncExpr *) expr)->funcresulttype;
77  break;
78  case T_NamedArgExpr:
79  type = exprType((Node *) ((const NamedArgExpr *) expr)->arg);
80  break;
81  case T_OpExpr:
82  type = ((const OpExpr *) expr)->opresulttype;
83  break;
84  case T_DistinctExpr:
85  type = ((const DistinctExpr *) expr)->opresulttype;
86  break;
87  case T_NullIfExpr:
88  type = ((const NullIfExpr *) expr)->opresulttype;
89  break;
90  case T_ScalarArrayOpExpr:
91  type = BOOLOID;
92  break;
93  case T_BoolExpr:
94  type = BOOLOID;
95  break;
96  case T_SubLink:
97  {
98  const SubLink *sublink = (const SubLink *) expr;
99 
100  if (sublink->subLinkType == EXPR_SUBLINK ||
101  sublink->subLinkType == ARRAY_SUBLINK)
102  {
103  /* get the type of the subselect's first target column */
104  Query *qtree = (Query *) sublink->subselect;
105  TargetEntry *tent;
106 
107  if (!qtree || !IsA(qtree, Query))
108  elog(ERROR, "cannot get type for untransformed sublink");
109  tent = linitial_node(TargetEntry, qtree->targetList);
110  Assert(!tent->resjunk);
111  type = exprType((Node *) tent->expr);
112  if (sublink->subLinkType == ARRAY_SUBLINK)
113  {
114  type = get_promoted_array_type(type);
115  if (!OidIsValid(type))
116  ereport(ERROR,
117  (errcode(ERRCODE_UNDEFINED_OBJECT),
118  errmsg("could not find array type for data type %s",
119  format_type_be(exprType((Node *) tent->expr)))));
120  }
121  }
122  else if (sublink->subLinkType == MULTIEXPR_SUBLINK)
123  {
124  /* MULTIEXPR is always considered to return RECORD */
125  type = RECORDOID;
126  }
127  else
128  {
129  /* for all other sublink types, result is boolean */
130  type = BOOLOID;
131  }
132  }
133  break;
134  case T_SubPlan:
135  {
136  const SubPlan *subplan = (const SubPlan *) expr;
137 
138  if (subplan->subLinkType == EXPR_SUBLINK ||
139  subplan->subLinkType == ARRAY_SUBLINK)
140  {
141  /* get the type of the subselect's first target column */
142  type = subplan->firstColType;
143  if (subplan->subLinkType == ARRAY_SUBLINK)
144  {
145  type = get_promoted_array_type(type);
146  if (!OidIsValid(type))
147  ereport(ERROR,
148  (errcode(ERRCODE_UNDEFINED_OBJECT),
149  errmsg("could not find array type for data type %s",
150  format_type_be(subplan->firstColType))));
151  }
152  }
153  else if (subplan->subLinkType == MULTIEXPR_SUBLINK)
154  {
155  /* MULTIEXPR is always considered to return RECORD */
156  type = RECORDOID;
157  }
158  else
159  {
160  /* for all other subplan types, result is boolean */
161  type = BOOLOID;
162  }
163  }
164  break;
165  case T_AlternativeSubPlan:
166  {
167  const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;
168 
169  /* subplans should all return the same thing */
170  type = exprType((Node *) linitial(asplan->subplans));
171  }
172  break;
173  case T_FieldSelect:
174  type = ((const FieldSelect *) expr)->resulttype;
175  break;
176  case T_FieldStore:
177  type = ((const FieldStore *) expr)->resulttype;
178  break;
179  case T_RelabelType:
180  type = ((const RelabelType *) expr)->resulttype;
181  break;
182  case T_CoerceViaIO:
183  type = ((const CoerceViaIO *) expr)->resulttype;
184  break;
185  case T_ArrayCoerceExpr:
186  type = ((const ArrayCoerceExpr *) expr)->resulttype;
187  break;
188  case T_ConvertRowtypeExpr:
189  type = ((const ConvertRowtypeExpr *) expr)->resulttype;
190  break;
191  case T_CollateExpr:
192  type = exprType((Node *) ((const CollateExpr *) expr)->arg);
193  break;
194  case T_CaseExpr:
195  type = ((const CaseExpr *) expr)->casetype;
196  break;
197  case T_CaseTestExpr:
198  type = ((const CaseTestExpr *) expr)->typeId;
199  break;
200  case T_ArrayExpr:
201  type = ((const ArrayExpr *) expr)->array_typeid;
202  break;
203  case T_RowExpr:
204  type = ((const RowExpr *) expr)->row_typeid;
205  break;
206  case T_RowCompareExpr:
207  type = BOOLOID;
208  break;
209  case T_CoalesceExpr:
210  type = ((const CoalesceExpr *) expr)->coalescetype;
211  break;
212  case T_MinMaxExpr:
213  type = ((const MinMaxExpr *) expr)->minmaxtype;
214  break;
215  case T_SQLValueFunction:
216  type = ((const SQLValueFunction *) expr)->type;
217  break;
218  case T_XmlExpr:
219  if (((const XmlExpr *) expr)->op == IS_DOCUMENT)
220  type = BOOLOID;
221  else if (((const XmlExpr *) expr)->op == IS_XMLSERIALIZE)
222  type = TEXTOID;
223  else
224  type = XMLOID;
225  break;
226  case T_JsonValueExpr:
227  {
228  const JsonValueExpr *jve = (const JsonValueExpr *) expr;
229 
230  type = exprType((Node *) jve->formatted_expr);
231  }
232  break;
233  case T_JsonConstructorExpr:
234  type = ((const JsonConstructorExpr *) expr)->returning->typid;
235  break;
236  case T_JsonIsPredicate:
237  type = BOOLOID;
238  break;
239  case T_JsonExpr:
240  {
241  const JsonExpr *jexpr = (const JsonExpr *) expr;
242 
243  type = jexpr->returning->typid;
244  break;
245  }
246  case T_JsonBehavior:
247  {
248  const JsonBehavior *behavior = (const JsonBehavior *) expr;
249 
250  type = exprType(behavior->expr);
251  break;
252  }
253  case T_NullTest:
254  type = BOOLOID;
255  break;
256  case T_BooleanTest:
257  type = BOOLOID;
258  break;
259  case T_CoerceToDomain:
260  type = ((const CoerceToDomain *) expr)->resulttype;
261  break;
262  case T_CoerceToDomainValue:
263  type = ((const CoerceToDomainValue *) expr)->typeId;
264  break;
265  case T_SetToDefault:
266  type = ((const SetToDefault *) expr)->typeId;
267  break;
268  case T_CurrentOfExpr:
269  type = BOOLOID;
270  break;
271  case T_NextValueExpr:
272  type = ((const NextValueExpr *) expr)->typeId;
273  break;
274  case T_InferenceElem:
275  {
276  const InferenceElem *n = (const InferenceElem *) expr;
277 
278  type = exprType((Node *) n->expr);
279  }
280  break;
281  case T_PlaceHolderVar:
282  type = exprType((Node *) ((const PlaceHolderVar *) expr)->phexpr);
283  break;
284  default:
285  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
286  type = InvalidOid; /* keep compiler quiet */
287  break;
288  }
289  return type;
290 }
291 
292 /*
293  * exprTypmod -
294  * returns the type-specific modifier of the expression's result type,
295  * if it can be determined. In many cases, it can't and we return -1.
296  */
297 int32
298 exprTypmod(const Node *expr)
299 {
300  if (!expr)
301  return -1;
302 
303  switch (nodeTag(expr))
304  {
305  case T_Var:
306  return ((const Var *) expr)->vartypmod;
307  case T_Const:
308  return ((const Const *) expr)->consttypmod;
309  case T_Param:
310  return ((const Param *) expr)->paramtypmod;
311  case T_SubscriptingRef:
312  return ((const SubscriptingRef *) expr)->reftypmod;
313  case T_FuncExpr:
314  {
315  int32 coercedTypmod;
316 
317  /* Be smart about length-coercion functions... */
318  if (exprIsLengthCoercion(expr, &coercedTypmod))
319  return coercedTypmod;
320  }
321  break;
322  case T_NamedArgExpr:
323  return exprTypmod((Node *) ((const NamedArgExpr *) expr)->arg);
324  case T_NullIfExpr:
325  {
326  /*
327  * Result is either first argument or NULL, so we can report
328  * first argument's typmod if known.
329  */
330  const NullIfExpr *nexpr = (const NullIfExpr *) expr;
331 
332  return exprTypmod((Node *) linitial(nexpr->args));
333  }
334  break;
335  case T_SubLink:
336  {
337  const SubLink *sublink = (const SubLink *) expr;
338 
339  if (sublink->subLinkType == EXPR_SUBLINK ||
340  sublink->subLinkType == ARRAY_SUBLINK)
341  {
342  /* get the typmod of the subselect's first target column */
343  Query *qtree = (Query *) sublink->subselect;
344  TargetEntry *tent;
345 
346  if (!qtree || !IsA(qtree, Query))
347  elog(ERROR, "cannot get type for untransformed sublink");
348  tent = linitial_node(TargetEntry, qtree->targetList);
349  Assert(!tent->resjunk);
350  return exprTypmod((Node *) tent->expr);
351  /* note we don't need to care if it's an array */
352  }
353  /* otherwise, result is RECORD or BOOLEAN, typmod is -1 */
354  }
355  break;
356  case T_SubPlan:
357  {
358  const SubPlan *subplan = (const SubPlan *) expr;
359 
360  if (subplan->subLinkType == EXPR_SUBLINK ||
361  subplan->subLinkType == ARRAY_SUBLINK)
362  {
363  /* get the typmod of the subselect's first target column */
364  /* note we don't need to care if it's an array */
365  return subplan->firstColTypmod;
366  }
367  /* otherwise, result is RECORD or BOOLEAN, typmod is -1 */
368  }
369  break;
370  case T_AlternativeSubPlan:
371  {
372  const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;
373 
374  /* subplans should all return the same thing */
375  return exprTypmod((Node *) linitial(asplan->subplans));
376  }
377  break;
378  case T_FieldSelect:
379  return ((const FieldSelect *) expr)->resulttypmod;
380  case T_RelabelType:
381  return ((const RelabelType *) expr)->resulttypmod;
382  case T_ArrayCoerceExpr:
383  return ((const ArrayCoerceExpr *) expr)->resulttypmod;
384  case T_CollateExpr:
385  return exprTypmod((Node *) ((const CollateExpr *) expr)->arg);
386  case T_CaseExpr:
387  {
388  /*
389  * If all the alternatives agree on type/typmod, return that
390  * typmod, else use -1
391  */
392  const CaseExpr *cexpr = (const CaseExpr *) expr;
393  Oid casetype = cexpr->casetype;
394  int32 typmod;
395  ListCell *arg;
396 
397  if (!cexpr->defresult)
398  return -1;
399  if (exprType((Node *) cexpr->defresult) != casetype)
400  return -1;
401  typmod = exprTypmod((Node *) cexpr->defresult);
402  if (typmod < 0)
403  return -1; /* no point in trying harder */
404  foreach(arg, cexpr->args)
405  {
406  CaseWhen *w = lfirst_node(CaseWhen, arg);
407 
408  if (exprType((Node *) w->result) != casetype)
409  return -1;
410  if (exprTypmod((Node *) w->result) != typmod)
411  return -1;
412  }
413  return typmod;
414  }
415  break;
416  case T_CaseTestExpr:
417  return ((const CaseTestExpr *) expr)->typeMod;
418  case T_ArrayExpr:
419  {
420  /*
421  * If all the elements agree on type/typmod, return that
422  * typmod, else use -1
423  */
424  const ArrayExpr *arrayexpr = (const ArrayExpr *) expr;
425  Oid commontype;
426  int32 typmod;
427  ListCell *elem;
428 
429  if (arrayexpr->elements == NIL)
430  return -1;
431  typmod = exprTypmod((Node *) linitial(arrayexpr->elements));
432  if (typmod < 0)
433  return -1; /* no point in trying harder */
434  if (arrayexpr->multidims)
435  commontype = arrayexpr->array_typeid;
436  else
437  commontype = arrayexpr->element_typeid;
438  foreach(elem, arrayexpr->elements)
439  {
440  Node *e = (Node *) lfirst(elem);
441 
442  if (exprType(e) != commontype)
443  return -1;
444  if (exprTypmod(e) != typmod)
445  return -1;
446  }
447  return typmod;
448  }
449  break;
450  case T_CoalesceExpr:
451  {
452  /*
453  * If all the alternatives agree on type/typmod, return that
454  * typmod, else use -1
455  */
456  const CoalesceExpr *cexpr = (const CoalesceExpr *) expr;
457  Oid coalescetype = cexpr->coalescetype;
458  int32 typmod;
459  ListCell *arg;
460 
461  if (exprType((Node *) linitial(cexpr->args)) != coalescetype)
462  return -1;
463  typmod = exprTypmod((Node *) linitial(cexpr->args));
464  if (typmod < 0)
465  return -1; /* no point in trying harder */
466  for_each_from(arg, cexpr->args, 1)
467  {
468  Node *e = (Node *) lfirst(arg);
469 
470  if (exprType(e) != coalescetype)
471  return -1;
472  if (exprTypmod(e) != typmod)
473  return -1;
474  }
475  return typmod;
476  }
477  break;
478  case T_MinMaxExpr:
479  {
480  /*
481  * If all the alternatives agree on type/typmod, return that
482  * typmod, else use -1
483  */
484  const MinMaxExpr *mexpr = (const MinMaxExpr *) expr;
485  Oid minmaxtype = mexpr->minmaxtype;
486  int32 typmod;
487  ListCell *arg;
488 
489  if (exprType((Node *) linitial(mexpr->args)) != minmaxtype)
490  return -1;
491  typmod = exprTypmod((Node *) linitial(mexpr->args));
492  if (typmod < 0)
493  return -1; /* no point in trying harder */
494  for_each_from(arg, mexpr->args, 1)
495  {
496  Node *e = (Node *) lfirst(arg);
497 
498  if (exprType(e) != minmaxtype)
499  return -1;
500  if (exprTypmod(e) != typmod)
501  return -1;
502  }
503  return typmod;
504  }
505  break;
506  case T_SQLValueFunction:
507  return ((const SQLValueFunction *) expr)->typmod;
508  case T_JsonValueExpr:
509  return exprTypmod((Node *) ((const JsonValueExpr *) expr)->formatted_expr);
510  case T_JsonConstructorExpr:
511  return ((const JsonConstructorExpr *) expr)->returning->typmod;
512  case T_JsonExpr:
513  {
514  const JsonExpr *jexpr = (const JsonExpr *) expr;
515 
516  return jexpr->returning->typmod;
517  }
518  break;
519  case T_JsonBehavior:
520  {
521  const JsonBehavior *behavior = (const JsonBehavior *) expr;
522 
523  return exprTypmod(behavior->expr);
524  }
525  break;
526  case T_CoerceToDomain:
527  return ((const CoerceToDomain *) expr)->resulttypmod;
528  case T_CoerceToDomainValue:
529  return ((const CoerceToDomainValue *) expr)->typeMod;
530  case T_SetToDefault:
531  return ((const SetToDefault *) expr)->typeMod;
532  case T_PlaceHolderVar:
533  return exprTypmod((Node *) ((const PlaceHolderVar *) expr)->phexpr);
534  default:
535  break;
536  }
537  return -1;
538 }
539 
540 /*
541  * exprIsLengthCoercion
542  * Detect whether an expression tree is an application of a datatype's
543  * typmod-coercion function. Optionally extract the result's typmod.
544  *
545  * If coercedTypmod is not NULL, the typmod is stored there if the expression
546  * is a length-coercion function, else -1 is stored there.
547  *
548  * Note that a combined type-and-length coercion will be treated as a
549  * length coercion by this routine.
550  */
551 bool
552 exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
553 {
554  if (coercedTypmod != NULL)
555  *coercedTypmod = -1; /* default result on failure */
556 
557  /*
558  * Scalar-type length coercions are FuncExprs, array-type length coercions
559  * are ArrayCoerceExprs
560  */
561  if (expr && IsA(expr, FuncExpr))
562  {
563  const FuncExpr *func = (const FuncExpr *) expr;
564  int nargs;
565  Const *second_arg;
566 
567  /*
568  * If it didn't come from a coercion context, reject.
569  */
570  if (func->funcformat != COERCE_EXPLICIT_CAST &&
571  func->funcformat != COERCE_IMPLICIT_CAST)
572  return false;
573 
574  /*
575  * If it's not a two-argument or three-argument function with the
576  * second argument being an int4 constant, it can't have been created
577  * from a length coercion (it must be a type coercion, instead).
578  */
579  nargs = list_length(func->args);
580  if (nargs < 2 || nargs > 3)
581  return false;
582 
583  second_arg = (Const *) lsecond(func->args);
584  if (!IsA(second_arg, Const) ||
585  second_arg->consttype != INT4OID ||
586  second_arg->constisnull)
587  return false;
588 
589  /*
590  * OK, it is indeed a length-coercion function.
591  */
592  if (coercedTypmod != NULL)
593  *coercedTypmod = DatumGetInt32(second_arg->constvalue);
594 
595  return true;
596  }
597 
598  if (expr && IsA(expr, ArrayCoerceExpr))
599  {
600  const ArrayCoerceExpr *acoerce = (const ArrayCoerceExpr *) expr;
601 
602  /* It's not a length coercion unless there's a nondefault typmod */
603  if (acoerce->resulttypmod < 0)
604  return false;
605 
606  /*
607  * OK, it is indeed a length-coercion expression.
608  */
609  if (coercedTypmod != NULL)
610  *coercedTypmod = acoerce->resulttypmod;
611 
612  return true;
613  }
614 
615  return false;
616 }
617 
618 /*
619  * applyRelabelType
620  * Add a RelabelType node if needed to make the expression expose
621  * the specified type, typmod, and collation.
622  *
623  * This is primarily intended to be used during planning. Therefore, it must
624  * maintain the post-eval_const_expressions invariants that there are not
625  * adjacent RelabelTypes, and that the tree is fully const-folded (hence,
626  * we mustn't return a RelabelType atop a Const). If we do find a Const,
627  * we'll modify it in-place if "overwrite_ok" is true; that should only be
628  * passed as true if caller knows the Const is newly generated.
629  */
630 Node *
631 applyRelabelType(Node *arg, Oid rtype, int32 rtypmod, Oid rcollid,
632  CoercionForm rformat, int rlocation, bool overwrite_ok)
633 {
634  /*
635  * If we find stacked RelabelTypes (eg, from foo::int::oid) we can discard
636  * all but the top one, and must do so to ensure that semantically
637  * equivalent expressions are equal().
638  */
639  while (arg && IsA(arg, RelabelType))
640  arg = (Node *) ((RelabelType *) arg)->arg;
641 
642  if (arg && IsA(arg, Const))
643  {
644  /* Modify the Const directly to preserve const-flatness. */
645  Const *con = (Const *) arg;
646 
647  if (!overwrite_ok)
648  con = copyObject(con);
649  con->consttype = rtype;
650  con->consttypmod = rtypmod;
651  con->constcollid = rcollid;
652  /* We keep the Const's original location. */
653  return (Node *) con;
654  }
655  else if (exprType(arg) == rtype &&
656  exprTypmod(arg) == rtypmod &&
657  exprCollation(arg) == rcollid)
658  {
659  /* Sometimes we find a nest of relabels that net out to nothing. */
660  return arg;
661  }
662  else
663  {
664  /* Nope, gotta have a RelabelType. */
665  RelabelType *newrelabel = makeNode(RelabelType);
666 
667  newrelabel->arg = (Expr *) arg;
668  newrelabel->resulttype = rtype;
669  newrelabel->resulttypmod = rtypmod;
670  newrelabel->resultcollid = rcollid;
671  newrelabel->relabelformat = rformat;
672  newrelabel->location = rlocation;
673  return (Node *) newrelabel;
674  }
675 }
676 
677 /*
678  * relabel_to_typmod
679  * Add a RelabelType node that changes just the typmod of the expression.
680  *
681  * Convenience function for a common usage of applyRelabelType.
682  */
683 Node *
684 relabel_to_typmod(Node *expr, int32 typmod)
685 {
686  return applyRelabelType(expr, exprType(expr), typmod, exprCollation(expr),
687  COERCE_EXPLICIT_CAST, -1, false);
688 }
689 
690 /*
691  * strip_implicit_coercions: remove implicit coercions at top level of tree
692  *
693  * This doesn't modify or copy the input expression tree, just return a
694  * pointer to a suitable place within it.
695  *
696  * Note: there isn't any useful thing we can do with a RowExpr here, so
697  * just return it unchanged, even if it's marked as an implicit coercion.
698  */
699 Node *
700 strip_implicit_coercions(Node *node)
701 {
702  if (node == NULL)
703  return NULL;
704  if (IsA(node, FuncExpr))
705  {
706  FuncExpr *f = (FuncExpr *) node;
707 
708  if (f->funcformat == COERCE_IMPLICIT_CAST)
709  return strip_implicit_coercions(linitial(f->args));
710  }
711  else if (IsA(node, RelabelType))
712  {
713  RelabelType *r = (RelabelType *) node;
714 
715  if (r->relabelformat == COERCE_IMPLICIT_CAST)
716  return strip_implicit_coercions((Node *) r->arg);
717  }
718  else if (IsA(node, CoerceViaIO))
719  {
720  CoerceViaIO *c = (CoerceViaIO *) node;
721 
722  if (c->coerceformat == COERCE_IMPLICIT_CAST)
723  return strip_implicit_coercions((Node *) c->arg);
724  }
725  else if (IsA(node, ArrayCoerceExpr))
726  {
727  ArrayCoerceExpr *c = (ArrayCoerceExpr *) node;
728 
729  if (c->coerceformat == COERCE_IMPLICIT_CAST)
730  return strip_implicit_coercions((Node *) c->arg);
731  }
732  else if (IsA(node, ConvertRowtypeExpr))
733  {
734  ConvertRowtypeExpr *c = (ConvertRowtypeExpr *) node;
735 
736  if (c->convertformat == COERCE_IMPLICIT_CAST)
737  return strip_implicit_coercions((Node *) c->arg);
738  }
739  else if (IsA(node, CoerceToDomain))
740  {
741  CoerceToDomain *c = (CoerceToDomain *) node;
742 
743  if (c->coercionformat == COERCE_IMPLICIT_CAST)
744  return strip_implicit_coercions((Node *) c->arg);
745  }
746  return node;
747 }
748 
749 /*
750  * expression_returns_set
751  * Test whether an expression returns a set result.
752  *
753  * Because we use expression_tree_walker(), this can also be applied to
754  * whole targetlists; it'll produce true if any one of the tlist items
755  * returns a set.
756  */
757 bool
758 expression_returns_set(Node *clause)
759 {
760  return expression_returns_set_walker(clause, NULL);
761 }
762 
763 static bool
764 expression_returns_set_walker(Node *node, void *context)
765 {
766  if (node == NULL)
767  return false;
768  if (IsA(node, FuncExpr))
769  {
770  FuncExpr *expr = (FuncExpr *) node;
771 
772  if (expr->funcretset)
773  return true;
774  /* else fall through to check args */
775  }
776  if (IsA(node, OpExpr))
777  {
778  OpExpr *expr = (OpExpr *) node;
779 
780  if (expr->opretset)
781  return true;
782  /* else fall through to check args */
783  }
784 
785  /*
786  * If you add any more cases that return sets, also fix
787  * expression_returns_set_rows() in clauses.c and IS_SRF_CALL() in
788  * tlist.c.
789  */
790 
791  /* Avoid recursion for some cases that parser checks not to return a set */
792  if (IsA(node, Aggref))
793  return false;
794  if (IsA(node, GroupingFunc))
795  return false;
796  if (IsA(node, WindowFunc))
797  return false;
798 
799  return expression_tree_walker(node, expression_returns_set_walker,
800  context);
801 }
802 
803 
804 /*
805  * exprCollation -
806  * returns the Oid of the collation of the expression's result.
807  *
808  * Note: expression nodes that can invoke functions generally have an
809  * "inputcollid" field, which is what the function should use as collation.
810  * That is the resolved common collation of the node's inputs. It is often
811  * but not always the same as the result collation; in particular, if the
812  * function produces a non-collatable result type from collatable inputs
813  * or vice versa, the two are different.
814  */
815 Oid
816 exprCollation(const Node *expr)
817 {
818  Oid coll;
819 
820  if (!expr)
821  return InvalidOid;
822 
823  switch (nodeTag(expr))
824  {
825  case T_Var:
826  coll = ((const Var *) expr)->varcollid;
827  break;
828  case T_Const:
829  coll = ((const Const *) expr)->constcollid;
830  break;
831  case T_Param:
832  coll = ((const Param *) expr)->paramcollid;
833  break;
834  case T_Aggref:
835  coll = ((const Aggref *) expr)->aggcollid;
836  break;
837  case T_GroupingFunc:
838  coll = InvalidOid;
839  break;
840  case T_WindowFunc:
841  coll = ((const WindowFunc *) expr)->wincollid;
842  break;
843  case T_MergeSupportFunc:
844  coll = ((const MergeSupportFunc *) expr)->msfcollid;
845  break;
846  case T_SubscriptingRef:
847  coll = ((const SubscriptingRef *) expr)->refcollid;
848  break;
849  case T_FuncExpr:
850  coll = ((const FuncExpr *) expr)->funccollid;
851  break;
852  case T_NamedArgExpr:
853  coll = exprCollation((Node *) ((const NamedArgExpr *) expr)->arg);
854  break;
855  case T_OpExpr:
856  coll = ((const OpExpr *) expr)->opcollid;
857  break;
858  case T_DistinctExpr:
859  coll = ((const DistinctExpr *) expr)->opcollid;
860  break;
861  case T_NullIfExpr:
862  coll = ((const NullIfExpr *) expr)->opcollid;
863  break;
864  case T_ScalarArrayOpExpr:
865  /* ScalarArrayOpExpr's result is boolean ... */
866  coll = InvalidOid; /* ... so it has no collation */
867  break;
868  case T_BoolExpr:
869  /* BoolExpr's result is boolean ... */
870  coll = InvalidOid; /* ... so it has no collation */
871  break;
872  case T_SubLink:
873  {
874  const SubLink *sublink = (const SubLink *) expr;
875 
876  if (sublink->subLinkType == EXPR_SUBLINK ||
877  sublink->subLinkType == ARRAY_SUBLINK)
878  {
879  /* get the collation of subselect's first target column */
880  Query *qtree = (Query *) sublink->subselect;
881  TargetEntry *tent;
882 
883  if (!qtree || !IsA(qtree, Query))
884  elog(ERROR, "cannot get collation for untransformed sublink");
885  tent = linitial_node(TargetEntry, qtree->targetList);
886  Assert(!tent->resjunk);
887  coll = exprCollation((Node *) tent->expr);
888  /* collation doesn't change if it's converted to array */
889  }
890  else
891  {
892  /* otherwise, SubLink's result is RECORD or BOOLEAN */
893  coll = InvalidOid; /* ... so it has no collation */
894  }
895  }
896  break;
897  case T_SubPlan:
898  {
899  const SubPlan *subplan = (const SubPlan *) expr;
900 
901  if (subplan->subLinkType == EXPR_SUBLINK ||
902  subplan->subLinkType == ARRAY_SUBLINK)
903  {
904  /* get the collation of subselect's first target column */
905  coll = subplan->firstColCollation;
906  /* collation doesn't change if it's converted to array */
907  }
908  else
909  {
910  /* otherwise, SubPlan's result is RECORD or BOOLEAN */
911  coll = InvalidOid; /* ... so it has no collation */
912  }
913  }
914  break;
915  case T_AlternativeSubPlan:
916  {
917  const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;
918 
919  /* subplans should all return the same thing */
920  coll = exprCollation((Node *) linitial(asplan->subplans));
921  }
922  break;
923  case T_FieldSelect:
924  coll = ((const FieldSelect *) expr)->resultcollid;
925  break;
926  case T_FieldStore:
927  /* FieldStore's result is composite ... */
928  coll = InvalidOid; /* ... so it has no collation */
929  break;
930  case T_RelabelType:
931  coll = ((const RelabelType *) expr)->resultcollid;
932  break;
933  case T_CoerceViaIO:
934  coll = ((const CoerceViaIO *) expr)->resultcollid;
935  break;
936  case T_ArrayCoerceExpr:
937  coll = ((const ArrayCoerceExpr *) expr)->resultcollid;
938  break;
939  case T_ConvertRowtypeExpr:
940  /* ConvertRowtypeExpr's result is composite ... */
941  coll = InvalidOid; /* ... so it has no collation */
942  break;
943  case T_CollateExpr:
944  coll = ((const CollateExpr *) expr)->collOid;
945  break;
946  case T_CaseExpr:
947  coll = ((const CaseExpr *) expr)->casecollid;
948  break;
949  case T_CaseTestExpr:
950  coll = ((const CaseTestExpr *) expr)->collation;
951  break;
952  case T_ArrayExpr:
953  coll = ((const ArrayExpr *) expr)->array_collid;
954  break;
955  case T_RowExpr:
956  /* RowExpr's result is composite ... */
957  coll = InvalidOid; /* ... so it has no collation */
958  break;
959  case T_RowCompareExpr:
960  /* RowCompareExpr's result is boolean ... */
961  coll = InvalidOid; /* ... so it has no collation */
962  break;
963  case T_CoalesceExpr:
964  coll = ((const CoalesceExpr *) expr)->coalescecollid;
965  break;
966  case T_MinMaxExpr:
967  coll = ((const MinMaxExpr *) expr)->minmaxcollid;
968  break;
969  case T_SQLValueFunction:
970  /* Returns either NAME or a non-collatable type */
971  if (((const SQLValueFunction *) expr)->type == NAMEOID)
972  coll = C_COLLATION_OID;
973  else
974  coll = InvalidOid;
975  break;
976  case T_XmlExpr:
977 
978  /*
979  * XMLSERIALIZE returns text from non-collatable inputs, so its
980  * collation is always default. The other cases return boolean or
981  * XML, which are non-collatable.
982  */
983  if (((const XmlExpr *) expr)->op == IS_XMLSERIALIZE)
984  coll = DEFAULT_COLLATION_OID;
985  else
986  coll = InvalidOid;
987  break;
988  case T_JsonValueExpr:
989  coll = exprCollation((Node *) ((const JsonValueExpr *) expr)->formatted_expr);
990  break;
991  case T_JsonConstructorExpr:
992  {
993  const JsonConstructorExpr *ctor = (const JsonConstructorExpr *) expr;
994 
995  if (ctor->coercion)
996  coll = exprCollation((Node *) ctor->coercion);
997  else
998  coll = InvalidOid;
999  }
1000  break;
1001  case T_JsonIsPredicate:
1002  /* IS JSON's result is boolean ... */
1003  coll = InvalidOid; /* ... so it has no collation */
1004  break;
1005  case T_JsonExpr:
1006  {
1007  const JsonExpr *jsexpr = (JsonExpr *) expr;
1008 
1009  coll = jsexpr->collation;
1010  }
1011  break;
1012  case T_JsonBehavior:
1013  {
1014  const JsonBehavior *behavior = (JsonBehavior *) expr;
1015 
1016  if (behavior->expr)
1017  coll = exprCollation(behavior->expr);
1018  else
1019  coll = InvalidOid;
1020  }
1021  break;
1022  case T_NullTest:
1023  /* NullTest's result is boolean ... */
1024  coll = InvalidOid; /* ... so it has no collation */
1025  break;
1026  case T_BooleanTest:
1027  /* BooleanTest's result is boolean ... */
1028  coll = InvalidOid; /* ... so it has no collation */
1029  break;
1030  case T_CoerceToDomain:
1031  coll = ((const CoerceToDomain *) expr)->resultcollid;
1032  break;
1033  case T_CoerceToDomainValue:
1034  coll = ((const CoerceToDomainValue *) expr)->collation;
1035  break;
1036  case T_SetToDefault:
1037  coll = ((const SetToDefault *) expr)->collation;
1038  break;
1039  case T_CurrentOfExpr:
1040  /* CurrentOfExpr's result is boolean ... */
1041  coll = InvalidOid; /* ... so it has no collation */
1042  break;
1043  case T_NextValueExpr:
1044  /* NextValueExpr's result is an integer type ... */
1045  coll = InvalidOid; /* ... so it has no collation */
1046  break;
1047  case T_InferenceElem:
1048  coll = exprCollation((Node *) ((const InferenceElem *) expr)->expr);
1049  break;
1050  case T_PlaceHolderVar:
1051  coll = exprCollation((Node *) ((const PlaceHolderVar *) expr)->phexpr);
1052  break;
1053  default:
1054  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
1055  coll = InvalidOid; /* keep compiler quiet */
1056  break;
1057  }
1058  return coll;
1059 }
1060 
1061 /*
1062  * exprInputCollation -
1063  * returns the Oid of the collation a function should use, if available.
1064  *
1065  * Result is InvalidOid if the node type doesn't store this information.
1066  */
1067 Oid
1068 exprInputCollation(const Node *expr)
1069 {
1070  Oid coll;
1071 
1072  if (!expr)
1073  return InvalidOid;
1074 
1075  switch (nodeTag(expr))
1076  {
1077  case T_Aggref:
1078  coll = ((const Aggref *) expr)->inputcollid;
1079  break;
1080  case T_WindowFunc:
1081  coll = ((const WindowFunc *) expr)->inputcollid;
1082  break;
1083  case T_FuncExpr:
1084  coll = ((const FuncExpr *) expr)->inputcollid;
1085  break;
1086  case T_OpExpr:
1087  coll = ((const OpExpr *) expr)->inputcollid;
1088  break;
1089  case T_DistinctExpr:
1090  coll = ((const DistinctExpr *) expr)->inputcollid;
1091  break;
1092  case T_NullIfExpr:
1093  coll = ((const NullIfExpr *) expr)->inputcollid;
1094  break;
1095  case T_ScalarArrayOpExpr:
1096  coll = ((const ScalarArrayOpExpr *) expr)->inputcollid;
1097  break;
1098  case T_MinMaxExpr:
1099  coll = ((const MinMaxExpr *) expr)->inputcollid;
1100  break;
1101  default:
1102  coll = InvalidOid;
1103  break;
1104  }
1105  return coll;
1106 }
1107 
1108 /*
1109  * exprSetCollation -
1110  * Assign collation information to an expression tree node.
1111  *
1112  * Note: since this is only used during parse analysis, we don't need to
1113  * worry about subplans or PlaceHolderVars.
1114  */
1115 void
1116 exprSetCollation(Node *expr, Oid collation)
1117 {
1118  switch (nodeTag(expr))
1119  {
1120  case T_Var:
1121  ((Var *) expr)->varcollid = collation;
1122  break;
1123  case T_Const:
1124  ((Const *) expr)->constcollid = collation;
1125  break;
1126  case T_Param:
1127  ((Param *) expr)->paramcollid = collation;
1128  break;
1129  case T_Aggref:
1130  ((Aggref *) expr)->aggcollid = collation;
1131  break;
1132  case T_GroupingFunc:
1133  Assert(!OidIsValid(collation));
1134  break;
1135  case T_WindowFunc:
1136  ((WindowFunc *) expr)->wincollid = collation;
1137  break;
1138  case T_MergeSupportFunc:
1139  ((MergeSupportFunc *) expr)->msfcollid = collation;
1140  break;
1141  case T_SubscriptingRef:
1142  ((SubscriptingRef *) expr)->refcollid = collation;
1143  break;
1144  case T_FuncExpr:
1145  ((FuncExpr *) expr)->funccollid = collation;
1146  break;
1147  case T_NamedArgExpr:
1148  Assert(collation == exprCollation((Node *) ((NamedArgExpr *) expr)->arg));
1149  break;
1150  case T_OpExpr:
1151  ((OpExpr *) expr)->opcollid = collation;
1152  break;
1153  case T_DistinctExpr:
1154  ((DistinctExpr *) expr)->opcollid = collation;
1155  break;
1156  case T_NullIfExpr:
1157  ((NullIfExpr *) expr)->opcollid = collation;
1158  break;
1159  case T_ScalarArrayOpExpr:
1160  /* ScalarArrayOpExpr's result is boolean ... */
1161  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1162  break;
1163  case T_BoolExpr:
1164  /* BoolExpr's result is boolean ... */
1165  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1166  break;
1167  case T_SubLink:
1168 #ifdef USE_ASSERT_CHECKING
1169  {
1170  SubLink *sublink = (SubLink *) expr;
1171 
1172  if (sublink->subLinkType == EXPR_SUBLINK ||
1173  sublink->subLinkType == ARRAY_SUBLINK)
1174  {
1175  /* get the collation of subselect's first target column */
1176  Query *qtree = (Query *) sublink->subselect;
1177  TargetEntry *tent;
1178 
1179  if (!qtree || !IsA(qtree, Query))
1180  elog(ERROR, "cannot set collation for untransformed sublink");
1181  tent = linitial_node(TargetEntry, qtree->targetList);
1182  Assert(!tent->resjunk);
1183  Assert(collation == exprCollation((Node *) tent->expr));
1184  }
1185  else
1186  {
1187  /* otherwise, result is RECORD or BOOLEAN */
1188  Assert(!OidIsValid(collation));
1189  }
1190  }
1191 #endif /* USE_ASSERT_CHECKING */
1192  break;
1193  case T_FieldSelect:
1194  ((FieldSelect *) expr)->resultcollid = collation;
1195  break;
1196  case T_FieldStore:
1197  /* FieldStore's result is composite ... */
1198  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1199  break;
1200  case T_RelabelType:
1201  ((RelabelType *) expr)->resultcollid = collation;
1202  break;
1203  case T_CoerceViaIO:
1204  ((CoerceViaIO *) expr)->resultcollid = collation;
1205  break;
1206  case T_ArrayCoerceExpr:
1207  ((ArrayCoerceExpr *) expr)->resultcollid = collation;
1208  break;
1209  case T_ConvertRowtypeExpr:
1210  /* ConvertRowtypeExpr's result is composite ... */
1211  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1212  break;
1213  case T_CaseExpr:
1214  ((CaseExpr *) expr)->casecollid = collation;
1215  break;
1216  case T_ArrayExpr:
1217  ((ArrayExpr *) expr)->array_collid = collation;
1218  break;
1219  case T_RowExpr:
1220  /* RowExpr's result is composite ... */
1221  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1222  break;
1223  case T_RowCompareExpr:
1224  /* RowCompareExpr's result is boolean ... */
1225  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1226  break;
1227  case T_CoalesceExpr:
1228  ((CoalesceExpr *) expr)->coalescecollid = collation;
1229  break;
1230  case T_MinMaxExpr:
1231  ((MinMaxExpr *) expr)->minmaxcollid = collation;
1232  break;
1233  case T_SQLValueFunction:
1234  Assert((((SQLValueFunction *) expr)->type == NAMEOID) ?
1235  (collation == C_COLLATION_OID) :
1236  (collation == InvalidOid));
1237  break;
1238  case T_XmlExpr:
1239  Assert((((XmlExpr *) expr)->op == IS_XMLSERIALIZE) ?
1240  (collation == DEFAULT_COLLATION_OID) :
1241  (collation == InvalidOid));
1242  break;
1243  case T_JsonValueExpr:
1244  exprSetCollation((Node *) ((JsonValueExpr *) expr)->formatted_expr,
1245  collation);
1246  break;
1247  case T_JsonConstructorExpr:
1248  {
1249  JsonConstructorExpr *ctor = (JsonConstructorExpr *) expr;
1250 
1251  if (ctor->coercion)
1252  exprSetCollation((Node *) ctor->coercion, collation);
1253  else
1254  Assert(!OidIsValid(collation)); /* result is always a
1255  * json[b] type */
1256  }
1257  break;
1258  case T_JsonIsPredicate:
1259  Assert(!OidIsValid(collation)); /* result is always boolean */
1260  break;
1261  case T_JsonExpr:
1262  {
1263  JsonExpr *jexpr = (JsonExpr *) expr;
1264 
1265  jexpr->collation = collation;
1266  }
1267  break;
1268  case T_JsonBehavior:
1269  {
1270  JsonBehavior *behavior = (JsonBehavior *) expr;
1271 
1272  if (behavior->expr)
1273  exprSetCollation(behavior->expr, collation);
1274  }
1275  break;
1276  case T_NullTest:
1277  /* NullTest's result is boolean ... */
1278  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1279  break;
1280  case T_BooleanTest:
1281  /* BooleanTest's result is boolean ... */
1282  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1283  break;
1284  case T_CoerceToDomain:
1285  ((CoerceToDomain *) expr)->resultcollid = collation;
1286  break;
1287  case T_CoerceToDomainValue:
1288  ((CoerceToDomainValue *) expr)->collation = collation;
1289  break;
1290  case T_SetToDefault:
1291  ((SetToDefault *) expr)->collation = collation;
1292  break;
1293  case T_CurrentOfExpr:
1294  /* CurrentOfExpr's result is boolean ... */
1295  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1296  break;
1297  case T_NextValueExpr:
1298  /* NextValueExpr's result is an integer type ... */
1299  Assert(!OidIsValid(collation)); /* ... so never set a collation */
1300  break;
1301  default:
1302  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
1303  break;
1304  }
1305 }
1306 
1307 /*
1308  * exprSetInputCollation -
1309  * Assign input-collation information to an expression tree node.
1310  *
1311  * This is a no-op for node types that don't store their input collation.
1312  * Note we omit RowCompareExpr, which needs special treatment since it
1313  * contains multiple input collation OIDs.
1314  */
1315 void
1316 exprSetInputCollation(Node *expr, Oid inputcollation)
1317 {
1318  switch (nodeTag(expr))
1319  {
1320  case T_Aggref:
1321  ((Aggref *) expr)->inputcollid = inputcollation;
1322  break;
1323  case T_WindowFunc:
1324  ((WindowFunc *) expr)->inputcollid = inputcollation;
1325  break;
1326  case T_FuncExpr:
1327  ((FuncExpr *) expr)->inputcollid = inputcollation;
1328  break;
1329  case T_OpExpr:
1330  ((OpExpr *) expr)->inputcollid = inputcollation;
1331  break;
1332  case T_DistinctExpr:
1333  ((DistinctExpr *) expr)->inputcollid = inputcollation;
1334  break;
1335  case T_NullIfExpr:
1336  ((NullIfExpr *) expr)->inputcollid = inputcollation;
1337  break;
1338  case T_ScalarArrayOpExpr:
1339  ((ScalarArrayOpExpr *) expr)->inputcollid = inputcollation;
1340  break;
1341  case T_MinMaxExpr:
1342  ((MinMaxExpr *) expr)->inputcollid = inputcollation;
1343  break;
1344  default:
1345  break;
1346  }
1347 }
1348 
1349 
1350 /*
1351  * exprLocation -
1352  * returns the parse location of an expression tree, for error reports
1353  *
1354  * -1 is returned if the location can't be determined.
1355  *
1356  * For expressions larger than a single token, the intent here is to
1357  * return the location of the expression's leftmost token, not necessarily
1358  * the topmost Node's location field. For example, an OpExpr's location
1359  * field will point at the operator name, but if it is not a prefix operator
1360  * then we should return the location of the left-hand operand instead.
1361  * The reason is that we want to reference the entire expression not just
1362  * that operator, and pointing to its start seems to be the most natural way.
1363  *
1364  * The location is not perfect --- for example, since the grammar doesn't
1365  * explicitly represent parentheses in the parsetree, given something that
1366  * had been written "(a + b) * c" we are going to point at "a" not "(".
1367  * But it should be plenty good enough for error reporting purposes.
1368  *
1369  * You might think that this code is overly general, for instance why check
1370  * the operands of a FuncExpr node, when the function name can be expected
1371  * to be to the left of them? There are a couple of reasons. The grammar
1372  * sometimes builds expressions that aren't quite what the user wrote;
1373  * for instance x IS NOT BETWEEN ... becomes a NOT-expression whose keyword
1374  * pointer is to the right of its leftmost argument. Also, nodes that were
1375  * inserted implicitly by parse analysis (such as FuncExprs for implicit
1376  * coercions) will have location -1, and so we can have odd combinations of
1377  * known and unknown locations in a tree.
1378  */
1379 int
1380 exprLocation(const Node *expr)
1381 {
1382  int loc;
1383 
1384  if (expr == NULL)
1385  return -1;
1386  switch (nodeTag(expr))
1387  {
1388  case T_RangeVar:
1389  loc = ((const RangeVar *) expr)->location;
1390  break;
1391  case T_TableFunc:
1392  loc = ((const TableFunc *) expr)->location;
1393  break;
1394  case T_Var:
1395  loc = ((const Var *) expr)->location;
1396  break;
1397  case T_Const:
1398  loc = ((const Const *) expr)->location;
1399  break;
1400  case T_Param:
1401  loc = ((const Param *) expr)->location;
1402  break;
1403  case T_Aggref:
1404  /* function name should always be the first thing */
1405  loc = ((const Aggref *) expr)->location;
1406  break;
1407  case T_GroupingFunc:
1408  loc = ((const GroupingFunc *) expr)->location;
1409  break;
1410  case T_WindowFunc:
1411  /* function name should always be the first thing */
1412  loc = ((const WindowFunc *) expr)->location;
1413  break;
1414  case T_MergeSupportFunc:
1415  loc = ((const MergeSupportFunc *) expr)->location;
1416  break;
1417  case T_SubscriptingRef:
1418  /* just use container argument's location */
1419  loc = exprLocation((Node *) ((const SubscriptingRef *) expr)->refexpr);
1420  break;
1421  case T_FuncExpr:
1422  {
1423  const FuncExpr *fexpr = (const FuncExpr *) expr;
1424 
1425  /* consider both function name and leftmost arg */
1426  loc = leftmostLoc(fexpr->location,
1427  exprLocation((Node *) fexpr->args));
1428  }
1429  break;
1430  case T_NamedArgExpr:
1431  {
1432  const NamedArgExpr *na = (const NamedArgExpr *) expr;
1433 
1434  /* consider both argument name and value */
1435  loc = leftmostLoc(na->location,
1436  exprLocation((Node *) na->arg));
1437  }
1438  break;
1439  case T_OpExpr:
1440  case T_DistinctExpr: /* struct-equivalent to OpExpr */
1441  case T_NullIfExpr: /* struct-equivalent to OpExpr */
1442  {
1443  const OpExpr *opexpr = (const OpExpr *) expr;
1444 
1445  /* consider both operator name and leftmost arg */
1446  loc = leftmostLoc(opexpr->location,
1447  exprLocation((Node *) opexpr->args));
1448  }
1449  break;
1450  case T_ScalarArrayOpExpr:
1451  {
1452  const ScalarArrayOpExpr *saopexpr = (const ScalarArrayOpExpr *) expr;
1453 
1454  /* consider both operator name and leftmost arg */
1455  loc = leftmostLoc(saopexpr->location,
1456  exprLocation((Node *) saopexpr->args));
1457  }
1458  break;
1459  case T_BoolExpr:
1460  {
1461  const BoolExpr *bexpr = (const BoolExpr *) expr;
1462 
1463  /*
1464  * Same as above, to handle either NOT or AND/OR. We can't
1465  * special-case NOT because of the way that it's used for
1466  * things like IS NOT BETWEEN.
1467  */
1468  loc = leftmostLoc(bexpr->location,
1469  exprLocation((Node *) bexpr->args));
1470  }
1471  break;
1472  case T_SubLink:
1473  {
1474  const SubLink *sublink = (const SubLink *) expr;
1475 
1476  /* check the testexpr, if any, and the operator/keyword */
1477  loc = leftmostLoc(exprLocation(sublink->testexpr),
1478  sublink->location);
1479  }
1480  break;
1481  case T_FieldSelect:
1482  /* just use argument's location */
1483  loc = exprLocation((Node *) ((const FieldSelect *) expr)->arg);
1484  break;
1485  case T_FieldStore:
1486  /* just use argument's location */
1487  loc = exprLocation((Node *) ((const FieldStore *) expr)->arg);
1488  break;
1489  case T_RelabelType:
1490  {
1491  const RelabelType *rexpr = (const RelabelType *) expr;
1492 
1493  /* Much as above */
1494  loc = leftmostLoc(rexpr->location,
1495  exprLocation((Node *) rexpr->arg));
1496  }
1497  break;
1498  case T_CoerceViaIO:
1499  {
1500  const CoerceViaIO *cexpr = (const CoerceViaIO *) expr;
1501 
1502  /* Much as above */
1503  loc = leftmostLoc(cexpr->location,
1504  exprLocation((Node *) cexpr->arg));
1505  }
1506  break;
1507  case T_ArrayCoerceExpr:
1508  {
1509  const ArrayCoerceExpr *cexpr = (const ArrayCoerceExpr *) expr;
1510 
1511  /* Much as above */
1512  loc = leftmostLoc(cexpr->location,
1513  exprLocation((Node *) cexpr->arg));
1514  }
1515  break;
1516  case T_ConvertRowtypeExpr:
1517  {
1518  const ConvertRowtypeExpr *cexpr = (const ConvertRowtypeExpr *) expr;
1519 
1520  /* Much as above */
1521  loc = leftmostLoc(cexpr->location,
1522  exprLocation((Node *) cexpr->arg));
1523  }
1524  break;
1525  case T_CollateExpr:
1526  /* just use argument's location */
1527  loc = exprLocation((Node *) ((const CollateExpr *) expr)->arg);
1528  break;
1529  case T_CaseExpr:
1530  /* CASE keyword should always be the first thing */
1531  loc = ((const CaseExpr *) expr)->location;
1532  break;
1533  case T_CaseWhen:
1534  /* WHEN keyword should always be the first thing */
1535  loc = ((const CaseWhen *) expr)->location;
1536  break;
1537  case T_ArrayExpr:
1538  /* the location points at ARRAY or [, which must be leftmost */
1539  loc = ((const ArrayExpr *) expr)->location;
1540  break;
1541  case T_RowExpr:
1542  /* the location points at ROW or (, which must be leftmost */
1543  loc = ((const RowExpr *) expr)->location;
1544  break;
1545  case T_RowCompareExpr:
1546  /* just use leftmost argument's location */
1547  loc = exprLocation((Node *) ((const RowCompareExpr *) expr)->largs);
1548  break;
1549  case T_CoalesceExpr:
1550  /* COALESCE keyword should always be the first thing */
1551  loc = ((const CoalesceExpr *) expr)->location;
1552  break;
1553  case T_MinMaxExpr:
1554  /* GREATEST/LEAST keyword should always be the first thing */
1555  loc = ((const MinMaxExpr *) expr)->location;
1556  break;
1557  case T_SQLValueFunction:
1558  /* function keyword should always be the first thing */
1559  loc = ((const SQLValueFunction *) expr)->location;
1560  break;
1561  case T_XmlExpr:
1562  {
1563  const XmlExpr *xexpr = (const XmlExpr *) expr;
1564 
1565  /* consider both function name and leftmost arg */
1566  loc = leftmostLoc(xexpr->location,
1567  exprLocation((Node *) xexpr->args));
1568  }
1569  break;
1570  case T_JsonFormat:
1571  loc = ((const JsonFormat *) expr)->location;
1572  break;
1573  case T_JsonValueExpr:
1574  loc = exprLocation((Node *) ((const JsonValueExpr *) expr)->raw_expr);
1575  break;
1576  case T_JsonConstructorExpr:
1577  loc = ((const JsonConstructorExpr *) expr)->location;
1578  break;
1579  case T_JsonIsPredicate:
1580  loc = ((const JsonIsPredicate *) expr)->location;
1581  break;
1582  case T_JsonExpr:
1583  {
1584  const JsonExpr *jsexpr = (const JsonExpr *) expr;
1585 
1586  /* consider both function name and leftmost arg */
1587  loc = leftmostLoc(jsexpr->location,
1588  exprLocation(jsexpr->formatted_expr));
1589  }
1590  break;
1591  case T_JsonBehavior:
1592  loc = exprLocation(((JsonBehavior *) expr)->expr);
1593  break;
1594  case T_NullTest:
1595  {
1596  const NullTest *nexpr = (const NullTest *) expr;
1597 
1598  /* Much as above */
1599  loc = leftmostLoc(nexpr->location,
1600  exprLocation((Node *) nexpr->arg));
1601  }
1602  break;
1603  case T_BooleanTest:
1604  {
1605  const BooleanTest *bexpr = (const BooleanTest *) expr;
1606 
1607  /* Much as above */
1608  loc = leftmostLoc(bexpr->location,
1609  exprLocation((Node *) bexpr->arg));
1610  }
1611  break;
1612  case T_CoerceToDomain:
1613  {
1614  const CoerceToDomain *cexpr = (const CoerceToDomain *) expr;
1615 
1616  /* Much as above */
1617  loc = leftmostLoc(cexpr->location,
1618  exprLocation((Node *) cexpr->arg));
1619  }
1620  break;
1621  case T_CoerceToDomainValue:
1622  loc = ((const CoerceToDomainValue *) expr)->location;
1623  break;
1624  case T_SetToDefault:
1625  loc = ((const SetToDefault *) expr)->location;
1626  break;
1627  case T_TargetEntry:
1628  /* just use argument's location */
1629  loc = exprLocation((Node *) ((const TargetEntry *) expr)->expr);
1630  break;
1631  case T_IntoClause:
1632  /* use the contained RangeVar's location --- close enough */
1633  loc = exprLocation((Node *) ((const IntoClause *) expr)->rel);
1634  break;
1635  case T_List:
1636  {
1637  /* report location of first list member that has a location */
1638  ListCell *lc;
1639 
1640  loc = -1; /* just to suppress compiler warning */
1641  foreach(lc, (const List *) expr)
1642  {
1643  loc = exprLocation((Node *) lfirst(lc));
1644  if (loc >= 0)
1645  break;
1646  }
1647  }
1648  break;
1649  case T_A_Expr:
1650  {
1651  const A_Expr *aexpr = (const A_Expr *) expr;
1652 
1653  /* use leftmost of operator or left operand (if any) */
1654  /* we assume right operand can't be to left of operator */
1655  loc = leftmostLoc(aexpr->location,
1656  exprLocation(aexpr->lexpr));
1657  }
1658  break;
1659  case T_ColumnRef:
1660  loc = ((const ColumnRef *) expr)->location;
1661  break;
1662  case T_ParamRef:
1663  loc = ((const ParamRef *) expr)->location;
1664  break;
1665  case T_A_Const:
1666  loc = ((const A_Const *) expr)->location;
1667  break;
1668  case T_FuncCall:
1669  {
1670  const FuncCall *fc = (const FuncCall *) expr;
1671 
1672  /* consider both function name and leftmost arg */
1673  /* (we assume any ORDER BY nodes must be to right of name) */
1674  loc = leftmostLoc(fc->location,
1675  exprLocation((Node *) fc->args));
1676  }
1677  break;
1678  case T_A_ArrayExpr:
1679  /* the location points at ARRAY or [, which must be leftmost */
1680  loc = ((const A_ArrayExpr *) expr)->location;
1681  break;
1682  case T_ResTarget:
1683  /* we need not examine the contained expression (if any) */
1684  loc = ((const ResTarget *) expr)->location;
1685  break;
1686  case T_MultiAssignRef:
1687  loc = exprLocation(((const MultiAssignRef *) expr)->source);
1688  break;
1689  case T_TypeCast:
1690  {
1691  const TypeCast *tc = (const TypeCast *) expr;
1692 
1693  /*
1694  * This could represent CAST(), ::, or TypeName 'literal', so
1695  * any of the components might be leftmost.
1696  */
1697  loc = exprLocation(tc->arg);
1698  loc = leftmostLoc(loc, tc->typeName->location);
1699  loc = leftmostLoc(loc, tc->location);
1700  }
1701  break;
1702  case T_CollateClause:
1703  /* just use argument's location */
1704  loc = exprLocation(((const CollateClause *) expr)->arg);
1705  break;
1706  case T_SortBy:
1707  /* just use argument's location (ignore operator, if any) */
1708  loc = exprLocation(((const SortBy *) expr)->node);
1709  break;
1710  case T_WindowDef:
1711  loc = ((const WindowDef *) expr)->location;
1712  break;
1713  case T_RangeTableSample:
1714  loc = ((const RangeTableSample *) expr)->location;
1715  break;
1716  case T_TypeName:
1717  loc = ((const TypeName *) expr)->location;
1718  break;
1719  case T_ColumnDef:
1720  loc = ((const ColumnDef *) expr)->location;
1721  break;
1722  case T_Constraint:
1723  loc = ((const Constraint *) expr)->location;
1724  break;
1725  case T_FunctionParameter:
1726  /* just use typename's location */
1727  loc = exprLocation((Node *) ((const FunctionParameter *) expr)->argType);
1728  break;
1729  case T_XmlSerialize:
1730  /* XMLSERIALIZE keyword should always be the first thing */
1731  loc = ((const XmlSerialize *) expr)->location;
1732  break;
1733  case T_GroupingSet:
1734  loc = ((const GroupingSet *) expr)->location;
1735  break;
1736  case T_WithClause:
1737  loc = ((const WithClause *) expr)->location;
1738  break;
1739  case T_InferClause:
1740  loc = ((const InferClause *) expr)->location;
1741  break;
1742  case T_OnConflictClause:
1743  loc = ((const OnConflictClause *) expr)->location;
1744  break;
1745  case T_CTESearchClause:
1746  loc = ((const CTESearchClause *) expr)->location;
1747  break;
1748  case T_CTECycleClause:
1749  loc = ((const CTECycleClause *) expr)->location;
1750  break;
1751  case T_CommonTableExpr:
1752  loc = ((const CommonTableExpr *) expr)->location;
1753  break;
1754  case T_JsonKeyValue:
1755  /* just use the key's location */
1756  loc = exprLocation((Node *) ((const JsonKeyValue *) expr)->key);
1757  break;
1758  case T_JsonObjectConstructor:
1759  loc = ((const JsonObjectConstructor *) expr)->location;
1760  break;
1761  case T_JsonArrayConstructor:
1762  loc = ((const JsonArrayConstructor *) expr)->location;
1763  break;
1764  case T_JsonArrayQueryConstructor:
1765  loc = ((const JsonArrayQueryConstructor *) expr)->location;
1766  break;
1767  case T_JsonAggConstructor:
1768  loc = ((const JsonAggConstructor *) expr)->location;
1769  break;
1770  case T_JsonObjectAgg:
1771  loc = exprLocation((Node *) ((const JsonObjectAgg *) expr)->constructor);
1772  break;
1773  case T_JsonArrayAgg:
1774  loc = exprLocation((Node *) ((const JsonArrayAgg *) expr)->constructor);
1775  break;
1776  case T_PlaceHolderVar:
1777  /* just use argument's location */
1778  loc = exprLocation((Node *) ((const PlaceHolderVar *) expr)->phexpr);
1779  break;
1780  case T_InferenceElem:
1781  /* just use nested expr's location */
1782  loc = exprLocation((Node *) ((const InferenceElem *) expr)->expr);
1783  break;
1784  case T_PartitionElem:
1785  loc = ((const PartitionElem *) expr)->location;
1786  break;
1787  case T_PartitionSpec:
1788  loc = ((const PartitionSpec *) expr)->location;
1789  break;
1790  case T_PartitionBoundSpec:
1791  loc = ((const PartitionBoundSpec *) expr)->location;
1792  break;
1793  case T_PartitionRangeDatum:
1794  loc = ((const PartitionRangeDatum *) expr)->location;
1795  break;
1796  default:
1797  /* for any other node type it's just unknown... */
1798  loc = -1;
1799  break;
1800  }
1801  return loc;
1802 }
1803 
1804 /*
1805  * leftmostLoc - support for exprLocation
1806  *
1807  * Take the minimum of two parse location values, but ignore unknowns
1808  */
1809 static int
1810 leftmostLoc(int loc1, int loc2)
1811 {
1812  if (loc1 < 0)
1813  return loc2;
1814  else if (loc2 < 0)
1815  return loc1;
1816  else
1817  return Min(loc1, loc2);
1818 }
1819 
1820 
1821 /*
1822  * fix_opfuncids
1823  * Calculate opfuncid field from opno for each OpExpr node in given tree.
1824  * The given tree can be anything expression_tree_walker handles.
1825  *
1826  * The argument is modified in-place. (This is OK since we'd want the
1827  * same change for any node, even if it gets visited more than once due to
1828  * shared structure.)
1829  */
1830 void
1831 fix_opfuncids(Node *node)
1832 {
1833  /* This tree walk requires no special setup, so away we go... */
1834  fix_opfuncids_walker(node, NULL);
1835 }
1836 
1837 static bool
1838 fix_opfuncids_walker(Node *node, void *context)
1839 {
1840  if (node == NULL)
1841  return false;
1842  if (IsA(node, OpExpr))
1843  set_opfuncid((OpExpr *) node);
1844  else if (IsA(node, DistinctExpr))
1845  set_opfuncid((OpExpr *) node); /* rely on struct equivalence */
1846  else if (IsA(node, NullIfExpr))
1847  set_opfuncid((OpExpr *) node); /* rely on struct equivalence */
1848  else if (IsA(node, ScalarArrayOpExpr))
1849  set_sa_opfuncid((ScalarArrayOpExpr *) node);
1850  return expression_tree_walker(node, fix_opfuncids_walker, context);
1851 }
1852 
1853 /*
1854  * set_opfuncid
1855  * Set the opfuncid (procedure OID) in an OpExpr node,
1856  * if it hasn't been set already.
1857  *
1858  * Because of struct equivalence, this can also be used for
1859  * DistinctExpr and NullIfExpr nodes.
1860  */
1861 void
1862 set_opfuncid(OpExpr *opexpr)
1863 {
1864  if (opexpr->opfuncid == InvalidOid)
1865  opexpr->opfuncid = get_opcode(opexpr->opno);
1866 }
1867 
1868 /*
1869  * set_sa_opfuncid
1870  * As above, for ScalarArrayOpExpr nodes.
1871  */
1872 void
1873 set_sa_opfuncid(ScalarArrayOpExpr *opexpr)
1874 {
1875  if (opexpr->opfuncid == InvalidOid)
1876  opexpr->opfuncid = get_opcode(opexpr->opno);
1877 }
1878 
1879 
1880 /*
1881  * check_functions_in_node -
1882  * apply checker() to each function OID contained in given expression node
1883  *
1884  * Returns true if the checker() function does; for nodes representing more
1885  * than one function call, returns true if the checker() function does so
1886  * for any of those functions. Returns false if node does not invoke any
1887  * SQL-visible function. Caller must not pass node == NULL.
1888  *
1889  * This function examines only the given node; it does not recurse into any
1890  * sub-expressions. Callers typically prefer to keep control of the recursion
1891  * for themselves, in case additional checks should be made, or because they
1892  * have special rules about which parts of the tree need to be visited.
1893  *
1894  * Note: we ignore MinMaxExpr, SQLValueFunction, XmlExpr, CoerceToDomain,
1895  * and NextValueExpr nodes, because they do not contain SQL function OIDs.
1896  * However, they can invoke SQL-visible functions, so callers should take
1897  * thought about how to treat them.
1898  */
1899 bool
1900 check_functions_in_node(Node *node, check_function_callback checker,
1901  void *context)
1902 {
1903  switch (nodeTag(node))
1904  {
1905  case T_Aggref:
1906  {
1907  Aggref *expr = (Aggref *) node;
1908 
1909  if (checker(expr->aggfnoid, context))
1910  return true;
1911  }
1912  break;
1913  case T_WindowFunc:
1914  {
1915  WindowFunc *expr = (WindowFunc *) node;
1916 
1917  if (checker(expr->winfnoid, context))
1918  return true;
1919  }
1920  break;
1921  case T_FuncExpr:
1922  {
1923  FuncExpr *expr = (FuncExpr *) node;
1924 
1925  if (checker(expr->funcid, context))
1926  return true;
1927  }
1928  break;
1929  case T_OpExpr:
1930  case T_DistinctExpr: /* struct-equivalent to OpExpr */
1931  case T_NullIfExpr: /* struct-equivalent to OpExpr */
1932  {
1933  OpExpr *expr = (OpExpr *) node;
1934 
1935  /* Set opfuncid if it wasn't set already */
1936  set_opfuncid(expr);
1937  if (checker(expr->opfuncid, context))
1938  return true;
1939  }
1940  break;
1941  case T_ScalarArrayOpExpr:
1942  {
1943  ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
1944 
1945  set_sa_opfuncid(expr);
1946  if (checker(expr->opfuncid, context))
1947  return true;
1948  }
1949  break;
1950  case T_CoerceViaIO:
1951  {
1952  CoerceViaIO *expr = (CoerceViaIO *) node;
1953  Oid iofunc;
1954  Oid typioparam;
1955  bool typisvarlena;
1956 
1957  /* check the result type's input function */
1958  getTypeInputInfo(expr->resulttype,
1959  &iofunc, &typioparam);
1960  if (checker(iofunc, context))
1961  return true;
1962  /* check the input type's output function */
1963  getTypeOutputInfo(exprType((Node *) expr->arg),
1964  &iofunc, &typisvarlena);
1965  if (checker(iofunc, context))
1966  return true;
1967  }
1968  break;
1969  case T_RowCompareExpr:
1970  {
1971  RowCompareExpr *rcexpr = (RowCompareExpr *) node;
1972  ListCell *opid;
1973 
1974  foreach(opid, rcexpr->opnos)
1975  {
1976  Oid opfuncid = get_opcode(lfirst_oid(opid));
1977 
1978  if (checker(opfuncid, context))
1979  return true;
1980  }
1981  }
1982  break;
1983  default:
1984  break;
1985  }
1986  return false;
1987 }
1988 
1989 
1990 /*
1991  * Standard expression-tree walking support
1992  *
1993  * We used to have near-duplicate code in many different routines that
1994  * understood how to recurse through an expression node tree. That was
1995  * a pain to maintain, and we frequently had bugs due to some particular
1996  * routine neglecting to support a particular node type. In most cases,
1997  * these routines only actually care about certain node types, and don't
1998  * care about other types except insofar as they have to recurse through
1999  * non-primitive node types. Therefore, we now provide generic tree-walking
2000  * logic to consolidate the redundant "boilerplate" code. There are
2001  * two versions: expression_tree_walker() and expression_tree_mutator().
2002  */
2003 
2004 /*
2005  * expression_tree_walker() is designed to support routines that traverse
2006  * a tree in a read-only fashion (although it will also work for routines
2007  * that modify nodes in-place but never add/delete/replace nodes).
2008  * A walker routine should look like this:
2009  *
2010  * bool my_walker (Node *node, my_struct *context)
2011  * {
2012  * if (node == NULL)
2013  * return false;
2014  * // check for nodes that special work is required for, eg:
2015  * if (IsA(node, Var))
2016  * {
2017  * ... do special actions for Var nodes
2018  * }
2019  * else if (IsA(node, ...))
2020  * {
2021  * ... do special actions for other node types
2022  * }
2023  * // for any node type not specially processed, do:
2024  * return expression_tree_walker(node, my_walker, (void *) context);
2025  * }
2026  *
2027  * The "context" argument points to a struct that holds whatever context
2028  * information the walker routine needs --- it can be used to return data
2029  * gathered by the walker, too. This argument is not touched by
2030  * expression_tree_walker, but it is passed down to recursive sub-invocations
2031  * of my_walker. The tree walk is started from a setup routine that
2032  * fills in the appropriate context struct, calls my_walker with the top-level
2033  * node of the tree, and then examines the results.
2034  *
2035  * The walker routine should return "false" to continue the tree walk, or
2036  * "true" to abort the walk and immediately return "true" to the top-level
2037  * caller. This can be used to short-circuit the traversal if the walker
2038  * has found what it came for. "false" is returned to the top-level caller
2039  * iff no invocation of the walker returned "true".
2040  *
2041  * The node types handled by expression_tree_walker include all those
2042  * normally found in target lists and qualifier clauses during the planning
2043  * stage. In particular, it handles List nodes since a cnf-ified qual clause
2044  * will have List structure at the top level, and it handles TargetEntry nodes
2045  * so that a scan of a target list can be handled without additional code.
2046  * Also, RangeTblRef, FromExpr, JoinExpr, and SetOperationStmt nodes are
2047  * handled, so that query jointrees and setOperation trees can be processed
2048  * without additional code.
2049  *
2050  * expression_tree_walker will handle SubLink nodes by recursing normally
2051  * into the "testexpr" subtree (which is an expression belonging to the outer
2052  * plan). It will also call the walker on the sub-Query node; however, when
2053  * expression_tree_walker itself is called on a Query node, it does nothing
2054  * and returns "false". The net effect is that unless the walker does
2055  * something special at a Query node, sub-selects will not be visited during
2056  * an expression tree walk. This is exactly the behavior wanted in many cases
2057  * --- and for those walkers that do want to recurse into sub-selects, special
2058  * behavior is typically needed anyway at the entry to a sub-select (such as
2059  * incrementing a depth counter). A walker that wants to examine sub-selects
2060  * should include code along the lines of:
2061  *
2062  * if (IsA(node, Query))
2063  * {
2064  * adjust context for subquery;
2065  * result = query_tree_walker((Query *) node, my_walker, context,
2066  * 0); // adjust flags as needed
2067  * restore context if needed;
2068  * return result;
2069  * }
2070  *
2071  * query_tree_walker is a convenience routine (see below) that calls the
2072  * walker on all the expression subtrees of the given Query node.
2073  *
2074  * expression_tree_walker will handle SubPlan nodes by recursing normally
2075  * into the "testexpr" and the "args" list (which are expressions belonging to
2076  * the outer plan). It will not touch the completed subplan, however. Since
2077  * there is no link to the original Query, it is not possible to recurse into
2078  * subselects of an already-planned expression tree. This is OK for current
2079  * uses, but may need to be revisited in future.
2080  */
2081 
2082 bool
2083 expression_tree_walker_impl(Node *node,
2084  tree_walker_callback walker,
2085  void *context)
2086 {
2087  ListCell *temp;
2088 
2089  /*
2090  * The walker has already visited the current node, and so we need only
2091  * recurse into any sub-nodes it has.
2092  *
2093  * We assume that the walker is not interested in List nodes per se, so
2094  * when we expect a List we just recurse directly to self without
2095  * bothering to call the walker.
2096  */
2097 #define WALK(n) walker((Node *) (n), context)
2098 
2099 #define LIST_WALK(l) expression_tree_walker_impl((Node *) (l), walker, context)
2100 
2101  if (node == NULL)
2102  return false;
2103 
2104  /* Guard against stack overflow due to overly complex expressions */
2105  check_stack_depth();
2106 
2107  switch (nodeTag(node))
2108  {
2109  case T_Var:
2110  case T_Const:
2111  case T_Param:
2112  case T_CaseTestExpr:
2113  case T_SQLValueFunction:
2114  case T_CoerceToDomainValue:
2115  case T_SetToDefault:
2116  case T_CurrentOfExpr:
2117  case T_NextValueExpr:
2118  case T_RangeTblRef:
2119  case T_SortGroupClause:
2120  case T_CTESearchClause:
2121  case T_MergeSupportFunc:
2122  /* primitive node types with no expression subnodes */
2123  break;
2124  case T_WithCheckOption:
2125  return WALK(((WithCheckOption *) node)->qual);
2126  case T_Aggref:
2127  {
2128  Aggref *expr = (Aggref *) node;
2129 
2130  /* recurse directly on Lists */
2131  if (LIST_WALK(expr->aggdirectargs))
2132  return true;
2133  if (LIST_WALK(expr->args))
2134  return true;
2135  if (LIST_WALK(expr->aggorder))
2136  return true;
2137  if (LIST_WALK(expr->aggdistinct))
2138  return true;
2139  if (WALK(expr->aggfilter))
2140  return true;
2141  }
2142  break;
2143  case T_GroupingFunc:
2144  {
2145  GroupingFunc *grouping = (GroupingFunc *) node;
2146 
2147  if (LIST_WALK(grouping->args))
2148  return true;
2149  }
2150  break;
2151  case T_WindowFunc:
2152  {
2153  WindowFunc *expr = (WindowFunc *) node;
2154 
2155  /* recurse directly on List */
2156  if (LIST_WALK(expr->args))
2157  return true;
2158  if (WALK(expr->aggfilter))
2159  return true;
2160  if (WALK(expr->runCondition))
2161  return true;
2162  }
2163  break;
2164  case T_WindowFuncRunCondition:
2165  {
2166  WindowFuncRunCondition *expr = (WindowFuncRunCondition *) node;
2167 
2168  if (WALK(expr->arg))
2169  return true;
2170  }
2171  break;
2172  case T_SubscriptingRef:
2173  {
2174  SubscriptingRef *sbsref = (SubscriptingRef *) node;
2175 
2176  /* recurse directly for upper/lower container index lists */
2177  if (LIST_WALK(sbsref->refupperindexpr))
2178  return true;
2179  if (LIST_WALK(sbsref->reflowerindexpr))
2180  return true;
2181  /* walker must see the refexpr and refassgnexpr, however */
2182  if (WALK(sbsref->refexpr))
2183  return true;
2184 
2185  if (WALK(sbsref->refassgnexpr))
2186  return true;
2187  }
2188  break;
2189  case T_FuncExpr:
2190  {
2191  FuncExpr *expr = (FuncExpr *) node;
2192 
2193  if (LIST_WALK(expr->args))
2194  return true;
2195  }
2196  break;
2197  case T_NamedArgExpr:
2198  return WALK(((NamedArgExpr *) node)->arg);
2199  case T_OpExpr:
2200  case T_DistinctExpr: /* struct-equivalent to OpExpr */
2201  case T_NullIfExpr: /* struct-equivalent to OpExpr */
2202  {
2203  OpExpr *expr = (OpExpr *) node;
2204 
2205  if (LIST_WALK(expr->args))
2206  return true;
2207  }
2208  break;
2209  case T_ScalarArrayOpExpr:
2210  {
2211  ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
2212 
2213  if (LIST_WALK(expr->args))
2214  return true;
2215  }
2216  break;
2217  case T_BoolExpr:
2218  {
2219  BoolExpr *expr = (BoolExpr *) node;
2220 
2221  if (LIST_WALK(expr->args))
2222  return true;
2223  }
2224  break;
2225  case T_SubLink:
2226  {
2227  SubLink *sublink = (SubLink *) node;
2228 
2229  if (WALK(sublink->testexpr))
2230  return true;
2231 
2232  /*
2233  * Also invoke the walker on the sublink's Query node, so it
2234  * can recurse into the sub-query if it wants to.
2235  */
2236  return WALK(sublink->subselect);
2237  }
2238  break;
2239  case T_SubPlan:
2240  {
2241  SubPlan *subplan = (SubPlan *) node;
2242 
2243  /* recurse into the testexpr, but not into the Plan */
2244  if (WALK(subplan->testexpr))
2245  return true;
2246  /* also examine args list */
2247  if (LIST_WALK(subplan->args))
2248  return true;
2249  }
2250  break;
2251  case T_AlternativeSubPlan:
2252  return LIST_WALK(((AlternativeSubPlan *) node)->subplans);
2253  case T_FieldSelect:
2254  return WALK(((FieldSelect *) node)->arg);
2255  case T_FieldStore:
2256  {
2257  FieldStore *fstore = (FieldStore *) node;
2258 
2259  if (WALK(fstore->arg))
2260  return true;
2261  if (WALK(fstore->newvals))
2262  return true;
2263  }
2264  break;
2265  case T_RelabelType:
2266  return WALK(((RelabelType *) node)->arg);
2267  case T_CoerceViaIO:
2268  return WALK(((CoerceViaIO *) node)->arg);
2269  case T_ArrayCoerceExpr:
2270  {
2271  ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
2272 
2273  if (WALK(acoerce->arg))
2274  return true;
2275  if (WALK(acoerce->elemexpr))
2276  return true;
2277  }
2278  break;
2279  case T_ConvertRowtypeExpr:
2280  return WALK(((ConvertRowtypeExpr *) node)->arg);
2281  case T_CollateExpr:
2282  return WALK(((CollateExpr *) node)->arg);
2283  case T_CaseExpr:
2284  {
2285  CaseExpr *caseexpr = (CaseExpr *) node;
2286 
2287  if (WALK(caseexpr->arg))
2288  return true;
2289  /* we assume walker doesn't care about CaseWhens, either */
2290  foreach(temp, caseexpr->args)
2291  {
2292  CaseWhen *when = lfirst_node(CaseWhen, temp);
2293 
2294  if (WALK(when->expr))
2295  return true;
2296  if (WALK(when->result))
2297  return true;
2298  }
2299  if (WALK(caseexpr->defresult))
2300  return true;
2301  }
2302  break;
2303  case T_ArrayExpr:
2304  return WALK(((ArrayExpr *) node)->elements);
2305  case T_RowExpr:
2306  /* Assume colnames isn't interesting */
2307  return WALK(((RowExpr *) node)->args);
2308  case T_RowCompareExpr:
2309  {
2310  RowCompareExpr *rcexpr = (RowCompareExpr *) node;
2311 
2312  if (WALK(rcexpr->largs))
2313  return true;
2314  if (WALK(rcexpr->rargs))
2315  return true;
2316  }
2317  break;
2318  case T_CoalesceExpr:
2319  return WALK(((CoalesceExpr *) node)->args);
2320  case T_MinMaxExpr:
2321  return WALK(((MinMaxExpr *) node)->args);
2322  case T_XmlExpr:
2323  {
2324  XmlExpr *xexpr = (XmlExpr *) node;
2325 
2326  if (WALK(xexpr->named_args))
2327  return true;
2328  /* we assume walker doesn't care about arg_names */
2329  if (WALK(xexpr->args))
2330  return true;
2331  }
2332  break;
2333  case T_JsonValueExpr:
2334  {
2335  JsonValueExpr *jve = (JsonValueExpr *) node;
2336 
2337  if (WALK(jve->raw_expr))
2338  return true;
2339  if (WALK(jve->formatted_expr))
2340  return true;
2341  }
2342  break;
2343  case T_JsonConstructorExpr:
2344  {
2345  JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;
2346 
2347  if (WALK(ctor->args))
2348  return true;
2349  if (WALK(ctor->func))
2350  return true;
2351  if (WALK(ctor->coercion))
2352  return true;
2353  }
2354  break;
2355  case T_JsonIsPredicate:
2356  return WALK(((JsonIsPredicate *) node)->expr);
2357  case T_JsonExpr:
2358  {
2359  JsonExpr *jexpr = (JsonExpr *) node;
2360 
2361  if (WALK(jexpr->formatted_expr))
2362  return true;
2363  if (WALK(jexpr->path_spec))
2364  return true;
2365  if (WALK(jexpr->passing_values))
2366  return true;
2367  /* we assume walker doesn't care about passing_names */
2368  if (WALK(jexpr->on_empty))
2369  return true;
2370  if (WALK(jexpr->on_error))
2371  return true;
2372  }
2373  break;
2374  case T_JsonBehavior:
2375  {
2376  JsonBehavior *behavior = (JsonBehavior *) node;
2377 
2378  if (WALK(behavior->expr))
2379  return true;
2380  }
2381  break;
2382  case T_NullTest:
2383  return WALK(((NullTest *) node)->arg);
2384  case T_BooleanTest:
2385  return WALK(((BooleanTest *) node)->arg);
2386  case T_CoerceToDomain:
2387  return WALK(((CoerceToDomain *) node)->arg);
2388  case T_TargetEntry:
2389  return WALK(((TargetEntry *) node)->expr);
2390  case T_Query:
2391  /* Do nothing with a sub-Query, per discussion above */
2392  break;
2393  case T_WindowClause:
2394  {
2395  WindowClause *wc = (WindowClause *) node;
2396 
2397  if (WALK(wc->partitionClause))
2398  return true;
2399  if (WALK(wc->orderClause))
2400  return true;
2401  if (WALK(wc->startOffset))
2402  return true;
2403  if (WALK(wc->endOffset))
2404  return true;
2405  }
2406  break;
2407  case T_CTECycleClause:
2408  {
2409  CTECycleClause *cc = (CTECycleClause *) node;
2410 
2411  if (WALK(cc->cycle_mark_value))
2412  return true;
2413  if (WALK(cc->cycle_mark_default))
2414  return true;
2415  }
2416  break;
2417  case T_CommonTableExpr:
2418  {
2419  CommonTableExpr *cte = (CommonTableExpr *) node;
2420 
2421  /*
2422  * Invoke the walker on the CTE's Query node, so it can
2423  * recurse into the sub-query if it wants to.
2424  */
2425  if (WALK(cte->ctequery))
2426  return true;
2427 
2428  if (WALK(cte->search_clause))
2429  return true;
2430  if (WALK(cte->cycle_clause))
2431  return true;
2432  }
2433  break;
2434  case T_JsonKeyValue:
2435  {
2436  JsonKeyValue *kv = (JsonKeyValue *) node;
2437 
2438  if (WALK(kv->key))
2439  return true;
2440  if (WALK(kv->value))
2441  return true;
2442  }
2443  break;
2444  case T_JsonObjectConstructor:
2445  {
2446  JsonObjectConstructor *ctor = (JsonObjectConstructor *) node;
2447 
2448  if (LIST_WALK(ctor->exprs))
2449  return true;
2450  }
2451  break;
2452  case T_JsonArrayConstructor:
2453  {
2454  JsonArrayConstructor *ctor = (JsonArrayConstructor *) node;
2455 
2456  if (LIST_WALK(ctor->exprs))
2457  return true;
2458  }
2459  break;
2460  case T_JsonArrayQueryConstructor:
2461  {
2462  JsonArrayQueryConstructor *ctor = (JsonArrayQueryConstructor *) node;
2463 
2464  if (WALK(ctor->query))
2465  return true;
2466  }
2467  break;
2468  case T_JsonAggConstructor:
2469  {
2470  JsonAggConstructor *ctor = (JsonAggConstructor *) node;
2471 
2472  if (WALK(ctor->agg_filter))
2473  return true;
2474  if (WALK(ctor->agg_order))
2475  return true;
2476  if (WALK(ctor->over))
2477  return true;
2478  }
2479  break;
2480  case T_JsonObjectAgg:
2481  {
2482  JsonObjectAgg *ctor = (JsonObjectAgg *) node;
2483 
2484  if (WALK(ctor->constructor))
2485  return true;
2486  if (WALK(ctor->arg))
2487  return true;
2488  }
2489  break;
2490  case T_JsonArrayAgg:
2491  {
2492  JsonArrayAgg *ctor = (JsonArrayAgg *) node;
2493 
2494  if (WALK(ctor->constructor))
2495  return true;
2496  if (WALK(ctor->arg))
2497  return true;
2498  }
2499  break;
2500 
2501  case T_PartitionBoundSpec:
2502  {
2503  PartitionBoundSpec *pbs = (PartitionBoundSpec *) node;
2504 
2505  if (WALK(pbs->listdatums))
2506  return true;
2507  if (WALK(pbs->lowerdatums))
2508  return true;
2509  if (WALK(pbs->upperdatums))
2510  return true;
2511  }
2512  break;
2513  case T_PartitionRangeDatum:
2514  {
2515  PartitionRangeDatum *prd = (PartitionRangeDatum *) node;
2516 
2517  if (WALK(prd->value))
2518  return true;
2519  }
2520  break;
2521  case T_List:
2522  foreach(temp, (List *) node)
2523  {
2524  if (WALK(lfirst(temp)))
2525  return true;
2526  }
2527  break;
2528  case T_FromExpr:
2529  {
2530  FromExpr *from = (FromExpr *) node;
2531 
2532  if (LIST_WALK(from->fromlist))
2533  return true;
2534  if (WALK(from->quals))
2535  return true;
2536  }
2537  break;
2538  case T_OnConflictExpr:
2539  {
2540  OnConflictExpr *onconflict = (OnConflictExpr *) node;
2541 
2542  if (WALK(onconflict->arbiterElems))
2543  return true;
2544  if (WALK(onconflict->arbiterWhere))
2545  return true;
2546  if (WALK(onconflict->onConflictSet))
2547  return true;
2548  if (WALK(onconflict->onConflictWhere))
2549  return true;
2550  if (WALK(onconflict->exclRelTlist))
2551  return true;
2552  }
2553  break;
2554  case T_MergeAction:
2555  {
2556  MergeAction *action = (MergeAction *) node;
2557 
2558  if (WALK(action->qual))
2559  return true;
2560  if (WALK(action->targetList))
2561  return true;
2562  }
2563  break;
2564  case T_PartitionPruneStepOp:
2565  {
2566  PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;
2567 
2568  if (WALK(opstep->exprs))
2569  return true;
2570  }
2571  break;
2572  case T_PartitionPruneStepCombine:
2573  /* no expression subnodes */
2574  break;
2575  case T_JoinExpr:
2576  {
2577  JoinExpr *join = (JoinExpr *) node;
2578 
2579  if (WALK(join->larg))
2580  return true;
2581  if (WALK(join->rarg))
2582  return true;
2583  if (WALK(join->quals))
2584  return true;
2585 
2586  /*
2587  * alias clause, using list are deemed uninteresting.
2588  */
2589  }
2590  break;
2591  case T_SetOperationStmt:
2592  {
2593  SetOperationStmt *setop = (SetOperationStmt *) node;
2594 
2595  if (WALK(setop->larg))
2596  return true;
2597  if (WALK(setop->rarg))
2598  return true;
2599 
2600  /* groupClauses are deemed uninteresting */
2601  }
2602  break;
2603  case T_IndexClause:
2604  {
2605  IndexClause *iclause = (IndexClause *) node;
2606 
2607  if (WALK(iclause->rinfo))
2608  return true;
2609  if (LIST_WALK(iclause->indexquals))
2610  return true;
2611  }
2612  break;
2613  case T_PlaceHolderVar:
2614  return WALK(((PlaceHolderVar *) node)->phexpr);
2615  case T_InferenceElem:
2616  return WALK(((InferenceElem *) node)->expr);
2617  case T_AppendRelInfo:
2618  {
2619  AppendRelInfo *appinfo = (AppendRelInfo *) node;
2620 
2621  if (LIST_WALK(appinfo->translated_vars))
2622  return true;
2623  }
2624  break;
2625  case T_PlaceHolderInfo:
2626  return WALK(((PlaceHolderInfo *) node)->ph_var);
2627  case T_RangeTblFunction:
2628  return WALK(((RangeTblFunction *) node)->funcexpr);
2629  case T_TableSampleClause:
2630  {
2631  TableSampleClause *tsc = (TableSampleClause *) node;
2632 
2633  if (LIST_WALK(tsc->args))
2634  return true;
2635  if (WALK(tsc->repeatable))
2636  return true;
2637  }
2638  break;
2639  case T_TableFunc:
2640  {
2641  TableFunc *tf = (TableFunc *) node;
2642 
2643  if (WALK(tf->ns_uris))
2644  return true;
2645  if (WALK(tf->docexpr))
2646  return true;
2647  if (WALK(tf->rowexpr))
2648  return true;
2649  if (WALK(tf->colexprs))
2650  return true;
2651  if (WALK(tf->coldefexprs))
2652  return true;
2653  if (WALK(tf->colvalexprs))
2654  return true;
2655  if (WALK(tf->passingvalexprs))
2656  return true;
2657  }
2658  break;
2659  default:
2660  elog(ERROR, "unrecognized node type: %d",
2661  (int) nodeTag(node));
2662  break;
2663  }
2664  return false;
2665 
2666  /* The WALK() macro can be re-used below, but LIST_WALK() not so much */
2667 #undef LIST_WALK
2668 }
2669 
2670 /*
2671  * query_tree_walker --- initiate a walk of a Query's expressions
2672  *
2673  * This routine exists just to reduce the number of places that need to know
2674  * where all the expression subtrees of a Query are. Note it can be used
2675  * for starting a walk at top level of a Query regardless of whether the
2676  * walker intends to descend into subqueries. It is also useful for
2677  * descending into subqueries within a walker.
2678  *
2679  * Some callers want to suppress visitation of certain items in the sub-Query,
2680  * typically because they need to process them specially, or don't actually
2681  * want to recurse into subqueries. This is supported by the flags argument,
2682  * which is the bitwise OR of flag values to add or suppress visitation of
2683  * indicated items. (More flag bits may be added as needed.)
2684  */
2685 bool
2686 query_tree_walker_impl(Query *query,
2687  tree_walker_callback walker,
2688  void *context,
2689  int flags)
2690 {
2691  Assert(query != NULL && IsA(query, Query));
2692 
2693  /*
2694  * We don't walk any utilityStmt here. However, we can't easily assert
2695  * that it is absent, since there are at least two code paths by which
2696  * action statements from CREATE RULE end up here, and NOTIFY is allowed
2697  * in a rule action.
2698  */
2699 
2700  if (WALK(query->targetList))
2701  return true;
2702  if (WALK(query->withCheckOptions))
2703  return true;
2704  if (WALK(query->onConflict))
2705  return true;
2706  if (WALK(query->mergeActionList))
2707  return true;
2708  if (WALK(query->mergeJoinCondition))
2709  return true;
2710  if (WALK(query->returningList))
2711  return true;
2712  if (WALK(query->jointree))
2713  return true;
2714  if (WALK(query->setOperations))
2715  return true;
2716  if (WALK(query->havingQual))
2717  return true;
2718  if (WALK(query->limitOffset))
2719  return true;
2720  if (WALK(query->limitCount))
2721  return true;
2722 
2723  /*
2724  * Most callers aren't interested in SortGroupClause nodes since those
2725  * don't contain actual expressions. However they do contain OIDs which
2726  * may be needed by dependency walkers etc.
2727  */
2728  if ((flags & QTW_EXAMINE_SORTGROUP))
2729  {
2730  if (WALK(query->groupClause))
2731  return true;
2732  if (WALK(query->windowClause))
2733  return true;
2734  if (WALK(query->sortClause))
2735  return true;
2736  if (WALK(query->distinctClause))
2737  return true;
2738  }
2739  else
2740  {
2741  /*
2742  * But we need to walk the expressions under WindowClause nodes even
2743  * if we're not interested in SortGroupClause nodes.
2744  */
2745  ListCell *lc;
2746 
2747  foreach(lc, query->windowClause)
2748  {
2749  WindowClause *wc = lfirst_node(WindowClause, lc);
2750 
2751  if (WALK(wc->startOffset))
2752  return true;
2753  if (WALK(wc->endOffset))
2754  return true;
2755  }
2756  }
2757 
2758  /*
2759  * groupingSets and rowMarks are not walked:
2760  *
2761  * groupingSets contain only ressortgrouprefs (integers) which are
2762  * meaningless without the corresponding groupClause or tlist.
2763  * Accordingly, any walker that needs to care about them needs to handle
2764  * them itself in its Query processing.
2765  *
2766  * rowMarks is not walked because it contains only rangetable indexes (and
2767  * flags etc.) and therefore should be handled at Query level similarly.
2768  */
2769 
2770  if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
2771  {
2772  if (WALK(query->cteList))
2773  return true;
2774  }
2775  if (!(flags & QTW_IGNORE_RANGE_TABLE))
2776  {
2777  if (range_table_walker(query->rtable, walker, context, flags))
2778  return true;
2779  }
2780  return false;
2781 }
2782 
2783 /*
2784  * range_table_walker is just the part of query_tree_walker that scans
2785  * a query's rangetable. This is split out since it can be useful on
2786  * its own.
2787  */
2788 bool
2789 range_table_walker_impl(List *rtable,
2790  tree_walker_callback walker,
2791  void *context,
2792  int flags)
2793 {
2794  ListCell *rt;
2795 
2796  foreach(rt, rtable)
2797  {
2798  RangeTblEntry *rte = lfirst_node(RangeTblEntry, rt);
2799 
2800  if (range_table_entry_walker(rte, walker, context, flags))
2801  return true;
2802  }
2803  return false;
2804 }
2805 
2806 /*
2807  * Some callers even want to scan the expressions in individual RTEs.
2808  */
2809 bool
2810 range_table_entry_walker_impl(RangeTblEntry *rte,
2811  tree_walker_callback walker,
2812  void *context,
2813  int flags)
2814 {
2815  /*
2816  * Walkers might need to examine the RTE node itself either before or
2817  * after visiting its contents (or, conceivably, both). Note that if you
2818  * specify neither flag, the walker won't be called on the RTE at all.
2819  */
2820  if (flags & QTW_EXAMINE_RTES_BEFORE)
2821  if (WALK(rte))
2822  return true;
2823 
2824  switch (rte->rtekind)
2825  {
2826  case RTE_RELATION:
2827  if (WALK(rte->tablesample))
2828  return true;
2829  break;
2830  case RTE_SUBQUERY:
2831  if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
2832  if (WALK(rte->subquery))
2833  return true;
2834  break;
2835  case RTE_JOIN:
2836  if (!(flags & QTW_IGNORE_JOINALIASES))
2837  if (WALK(rte->joinaliasvars))
2838  return true;
2839  break;
2840  case RTE_FUNCTION:
2841  if (WALK(rte->functions))
2842  return true;
2843  break;
2844  case RTE_TABLEFUNC:
2845  if (WALK(rte->tablefunc))
2846  return true;
2847  break;
2848  case RTE_VALUES:
2849  if (WALK(rte->values_lists))
2850  return true;
2851  break;
2852  case RTE_CTE:
2853  case RTE_NAMEDTUPLESTORE:
2854  case RTE_RESULT:
2855  /* nothing to do */
2856  break;
2857  case RTE_GROUP:
2858  if (!(flags & QTW_IGNORE_GROUPEXPRS))
2859  if (WALK(rte->groupexprs))
2860  return true;
2861  break;
2862  }
2863 
2864  if (WALK(rte->securityQuals))
2865  return true;
2866 
2867  if (flags & QTW_EXAMINE_RTES_AFTER)
2868  if (WALK(rte))
2869  return true;
2870 
2871  return false;
2872 }
2873 
2874 
2875 /*
2876  * expression_tree_mutator() is designed to support routines that make a
2877  * modified copy of an expression tree, with some nodes being added,
2878  * removed, or replaced by new subtrees. The original tree is (normally)
2879  * not changed. Each recursion level is responsible for returning a copy of
2880  * (or appropriately modified substitute for) the subtree it is handed.
2881  * A mutator routine should look like this:
2882  *
2883  * Node * my_mutator (Node *node, my_struct *context)
2884  * {
2885  * if (node == NULL)
2886  * return NULL;
2887  * // check for nodes that special work is required for, eg:
2888  * if (IsA(node, Var))
2889  * {
2890  * ... create and return modified copy of Var node
2891  * }
2892  * else if (IsA(node, ...))
2893  * {
2894  * ... do special transformations of other node types
2895  * }
2896  * // for any node type not specially processed, do:
2897  * return expression_tree_mutator(node, my_mutator, (void *) context);
2898  * }
2899  *
2900  * The "context" argument points to a struct that holds whatever context
2901  * information the mutator routine needs --- it can be used to return extra
2902  * data gathered by the mutator, too. This argument is not touched by
2903  * expression_tree_mutator, but it is passed down to recursive sub-invocations
2904  * of my_mutator. The tree walk is started from a setup routine that
2905  * fills in the appropriate context struct, calls my_mutator with the
2906  * top-level node of the tree, and does any required post-processing.
2907  *
2908  * Each level of recursion must return an appropriately modified Node.
2909  * If expression_tree_mutator() is called, it will make an exact copy
2910  * of the given Node, but invoke my_mutator() to copy the sub-node(s)
2911  * of that Node. In this way, my_mutator() has full control over the
2912  * copying process but need not directly deal with expression trees
2913  * that it has no interest in.
2914  *
2915  * Just as for expression_tree_walker, the node types handled by
2916  * expression_tree_mutator include all those normally found in target lists
2917  * and qualifier clauses during the planning stage.
2918  *
2919  * expression_tree_mutator will handle SubLink nodes by recursing normally
2920  * into the "testexpr" subtree (which is an expression belonging to the outer
2921  * plan). It will also call the mutator on the sub-Query node; however, when
2922  * expression_tree_mutator itself is called on a Query node, it does nothing
2923  * and returns the unmodified Query node. The net effect is that unless the
2924  * mutator does something special at a Query node, sub-selects will not be
2925  * visited or modified; the original sub-select will be linked to by the new
2926  * SubLink node. Mutators that want to descend into sub-selects will usually
2927  * do so by recognizing Query nodes and calling query_tree_mutator (below).
2928  *
2929  * expression_tree_mutator will handle a SubPlan node by recursing into the
2930  * "testexpr" and the "args" list (which belong to the outer plan), but it
2931  * will simply copy the link to the inner plan, since that's typically what
2932  * expression tree mutators want. A mutator that wants to modify the subplan
2933  * can force appropriate behavior by recognizing SubPlan expression nodes
2934  * and doing the right thing.
2935  */
2936 
2937 Node *
2938 expression_tree_mutator_impl(Node *node,
2939  tree_mutator_callback mutator,
2940  void *context)
2941 {
2942  /*
2943  * The mutator has already decided not to modify the current node, but we
2944  * must call the mutator for any sub-nodes.
2945  */
2946 
2947 #define FLATCOPY(newnode, node, nodetype) \
2948  ( (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
2949  memcpy((newnode), (node), sizeof(nodetype)) )
2950 
2951 #define MUTATE(newfield, oldfield, fieldtype) \
2952  ( (newfield) = (fieldtype) mutator((Node *) (oldfield), context) )
2953 
2954  if (node == NULL)
2955  return NULL;
2956 
2957  /* Guard against stack overflow due to overly complex expressions */
2958  check_stack_depth();
2959 
2960  switch (nodeTag(node))
2961  {
2962  /*
2963  * Primitive node types with no expression subnodes. Var and
2964  * Const are frequent enough to deserve special cases, the others
2965  * we just use copyObject for.
2966  */
2967  case T_Var:
2968  {
2969  Var *var = (Var *) node;
2970  Var *newnode;
2971 
2972  FLATCOPY(newnode, var, Var);
2973  /* Assume we need not copy the varnullingrels bitmapset */
2974  return (Node *) newnode;
2975  }
2976  break;
2977  case T_Const:
2978  {
2979  Const *oldnode = (Const *) node;
2980  Const *newnode;
2981 
2982  FLATCOPY(newnode, oldnode, Const);
2983  /* XXX we don't bother with datumCopy; should we? */
2984  return (Node *) newnode;
2985  }
2986  break;
2987  case T_Param:
2988  case T_CaseTestExpr:
2989  case T_SQLValueFunction:
2990  case T_JsonFormat:
2991  case T_CoerceToDomainValue:
2992  case T_SetToDefault:
2993  case T_CurrentOfExpr:
2994  case T_NextValueExpr:
2995  case T_RangeTblRef:
2996  case T_SortGroupClause:
2997  case T_CTESearchClause:
2998  case T_MergeSupportFunc:
2999  return (Node *) copyObject(node);
3000  case T_WithCheckOption:
3001  {
3002  WithCheckOption *wco = (WithCheckOption *) node;
3003  WithCheckOption *newnode;
3004 
3005  FLATCOPY(newnode, wco, WithCheckOption);
3006  MUTATE(newnode->qual, wco->qual, Node *);
3007  return (Node *) newnode;
3008  }
3009  case T_Aggref:
3010  {
3011  Aggref *aggref = (Aggref *) node;
3012  Aggref *newnode;
3013 
3014  FLATCOPY(newnode, aggref, Aggref);
3015  /* assume mutation doesn't change types of arguments */
3016  newnode->aggargtypes = list_copy(aggref->aggargtypes);
3017  MUTATE(newnode->aggdirectargs, aggref->aggdirectargs, List *);
3018  MUTATE(newnode->args, aggref->args, List *);
3019  MUTATE(newnode->aggorder, aggref->aggorder, List *);
3020  MUTATE(newnode->aggdistinct, aggref->aggdistinct, List *);
3021  MUTATE(newnode->aggfilter, aggref->aggfilter, Expr *);
3022  return (Node *) newnode;
3023  }
3024  break;
3025  case T_GroupingFunc:
3026  {
3027  GroupingFunc *grouping = (GroupingFunc *) node;
3028  GroupingFunc *newnode;
3029 
3030  FLATCOPY(newnode, grouping, GroupingFunc);
3031  MUTATE(newnode->args, grouping->args, List *);
3032 
3033  /*
3034  * We assume here that mutating the arguments does not change
3035  * the semantics, i.e. that the arguments are not mutated in a
3036  * way that makes them semantically different from their
3037  * previously matching expressions in the GROUP BY clause.
3038  *
3039  * If a mutator somehow wanted to do this, it would have to
3040  * handle the refs and cols lists itself as appropriate.
3041  */
3042  newnode->refs = list_copy(grouping->refs);
3043  newnode->cols = list_copy(grouping->cols);
3044 
3045  return (Node *) newnode;
3046  }
3047  break;
3048  case T_WindowFunc:
3049  {
3050  WindowFunc *wfunc = (WindowFunc *) node;
3051  WindowFunc *newnode;
3052 
3053  FLATCOPY(newnode, wfunc, WindowFunc);
3054  MUTATE(newnode->args, wfunc->args, List *);
3055  MUTATE(newnode->aggfilter, wfunc->aggfilter, Expr *);
3056  return (Node *) newnode;
3057  }
3058  break;
3059  case T_WindowFuncRunCondition:
3060  {
3061  WindowFuncRunCondition *wfuncrc = (WindowFuncRunCondition *) node;
3062  WindowFuncRunCondition *newnode;
3063 
3064  FLATCOPY(newnode, wfuncrc, WindowFuncRunCondition);
3065  MUTATE(newnode->arg, wfuncrc->arg, Expr *);
3066  return (Node *) newnode;
3067  }
3068  break;
3069  case T_SubscriptingRef:
3070  {
3071  SubscriptingRef *sbsref = (SubscriptingRef *) node;
3072  SubscriptingRef *newnode;
3073 
3074  FLATCOPY(newnode, sbsref, SubscriptingRef);
3075  MUTATE(newnode->refupperindexpr, sbsref->refupperindexpr,
3076  List *);
3077  MUTATE(newnode->reflowerindexpr, sbsref->reflowerindexpr,
3078  List *);
3079  MUTATE(newnode->refexpr, sbsref->refexpr,
3080  Expr *);
3081  MUTATE(newnode->refassgnexpr, sbsref->refassgnexpr,
3082  Expr *);
3083 
3084  return (Node *) newnode;
3085  }
3086  break;
3087  case T_FuncExpr:
3088  {
3089  FuncExpr *expr = (FuncExpr *) node;
3090  FuncExpr *newnode;
3091 
3092  FLATCOPY(newnode, expr, FuncExpr);
3093  MUTATE(newnode->args, expr->args, List *);
3094  return (Node *) newnode;
3095  }
3096  break;
3097  case T_NamedArgExpr:
3098  {
3099  NamedArgExpr *nexpr = (NamedArgExpr *) node;
3100  NamedArgExpr *newnode;
3101 
3102  FLATCOPY(newnode, nexpr, NamedArgExpr);
3103  MUTATE(newnode->arg, nexpr->arg, Expr *);
3104  return (Node *) newnode;
3105  }
3106  break;
3107  case T_OpExpr:
3108  {
3109  OpExpr *expr = (OpExpr *) node;
3110  OpExpr *newnode;
3111 
3112  FLATCOPY(newnode, expr, OpExpr);
3113  MUTATE(newnode->args, expr->args, List *);
3114  return (Node *) newnode;
3115  }
3116  break;
3117  case T_DistinctExpr:
3118  {
3119  DistinctExpr *expr = (DistinctExpr *) node;
3120  DistinctExpr *newnode;
3121 
3122  FLATCOPY(newnode, expr, DistinctExpr);
3123  MUTATE(newnode->args, expr->args, List *);
3124  return (Node *) newnode;
3125  }
3126  break;
3127  case T_NullIfExpr:
3128  {
3129  NullIfExpr *expr = (NullIfExpr *) node;
3130  NullIfExpr *newnode;
3131 
3132  FLATCOPY(newnode, expr, NullIfExpr);
3133  MUTATE(newnode->args, expr->args, List *);
3134  return (Node *) newnode;
3135  }
3136  break;
3137  case T_ScalarArrayOpExpr:
3138  {
3139  ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
3140  ScalarArrayOpExpr *newnode;
3141 
3142  FLATCOPY(newnode, expr, ScalarArrayOpExpr);
3143  MUTATE(newnode->args, expr->args, List *);
3144  return (Node *) newnode;
3145  }
3146  break;
3147  case T_BoolExpr:
3148  {
3149  BoolExpr *expr = (BoolExpr *) node;
3150  BoolExpr *newnode;
3151 
3152  FLATCOPY(newnode, expr, BoolExpr);
3153  MUTATE(newnode->args, expr->args, List *);
3154  return (Node *) newnode;
3155  }
3156  break;
3157  case T_SubLink:
3158  {
3159  SubLink *sublink = (SubLink *) node;
3160  SubLink *newnode;
3161 
3162  FLATCOPY(newnode, sublink, SubLink);
3163  MUTATE(newnode->testexpr, sublink->testexpr, Node *);
3164 
3165  /*
3166  * Also invoke the mutator on the sublink's Query node, so it
3167  * can recurse into the sub-query if it wants to.
3168  */
3169  MUTATE(newnode->subselect, sublink->subselect, Node *);
3170  return (Node *) newnode;
3171  }
3172  break;
3173  case T_SubPlan:
3174  {
3175  SubPlan *subplan = (SubPlan *) node;
3176  SubPlan *newnode;
3177 
3178  FLATCOPY(newnode, subplan, SubPlan);
3179  /* transform testexpr */
3180  MUTATE(newnode->testexpr, subplan->testexpr, Node *);
3181  /* transform args list (params to be passed to subplan) */
3182  MUTATE(newnode->args, subplan->args, List *);
3183  /* but not the sub-Plan itself, which is referenced as-is */
3184  return (Node *) newnode;
3185  }
3186  break;
3187  case T_AlternativeSubPlan:
3188  {
3189  AlternativeSubPlan *asplan = (AlternativeSubPlan *) node;
3190  AlternativeSubPlan *newnode;
3191 
3192  FLATCOPY(newnode, asplan, AlternativeSubPlan);
3193  MUTATE(newnode->subplans, asplan->subplans, List *);
3194  return (Node *) newnode;
3195  }
3196  break;
3197  case T_FieldSelect:
3198  {
3199  FieldSelect *fselect = (FieldSelect *) node;
3200  FieldSelect *newnode;
3201 
3202  FLATCOPY(newnode, fselect, FieldSelect);
3203  MUTATE(newnode->arg, fselect->arg, Expr *);
3204  return (Node *) newnode;
3205  }
3206  break;
3207  case T_FieldStore:
3208  {
3209  FieldStore *fstore = (FieldStore *) node;
3210  FieldStore *newnode;
3211 
3212  FLATCOPY(newnode, fstore, FieldStore);
3213  MUTATE(newnode->arg, fstore->arg, Expr *);
3214  MUTATE(newnode->newvals, fstore->newvals, List *);
3215  newnode->fieldnums = list_copy(fstore->fieldnums);
3216  return (Node *) newnode;
3217  }
3218  break;
3219  case T_RelabelType:
3220  {
3221  RelabelType *relabel = (RelabelType *) node;
3222  RelabelType *newnode;
3223 
3224  FLATCOPY(newnode, relabel, RelabelType);
3225  MUTATE(newnode->arg, relabel->arg, Expr *);
3226  return (Node *) newnode;
3227  }
3228  break;
3229  case T_CoerceViaIO:
3230  {
3231  CoerceViaIO *iocoerce = (CoerceViaIO *) node;
3232  CoerceViaIO *newnode;
3233 
3234  FLATCOPY(newnode, iocoerce, CoerceViaIO);
3235  MUTATE(newnode->arg, iocoerce->arg, Expr *);
3236  return (Node *) newnode;
3237  }
3238  break;
3239  case T_ArrayCoerceExpr:
3240  {
3241  ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
3242  ArrayCoerceExpr *newnode;
3243 
3244  FLATCOPY(newnode, acoerce, ArrayCoerceExpr);
3245  MUTATE(newnode->arg, acoerce->arg, Expr *);
3246  MUTATE(newnode->elemexpr, acoerce->elemexpr, Expr *);
3247  return (Node *) newnode;
3248  }
3249  break;
3250  case T_ConvertRowtypeExpr:
3251  {
3252  ConvertRowtypeExpr *convexpr = (ConvertRowtypeExpr *) node;
3253  ConvertRowtypeExpr *newnode;
3254 
3255  FLATCOPY(newnode, convexpr, ConvertRowtypeExpr);
3256  MUTATE(newnode->arg, convexpr->arg, Expr *);
3257  return (Node *) newnode;
3258  }
3259  break;
3260  case T_CollateExpr:
3261  {
3262  CollateExpr *collate = (CollateExpr *) node;
3263  CollateExpr *newnode;
3264 
3265  FLATCOPY(newnode, collate, CollateExpr);
3266  MUTATE(newnode->arg, collate->arg, Expr *);
3267  return (Node *) newnode;
3268  }
3269  break;
3270  case T_CaseExpr:
3271  {
3272  CaseExpr *caseexpr = (CaseExpr *) node;
3273  CaseExpr *newnode;
3274 
3275  FLATCOPY(newnode, caseexpr, CaseExpr);
3276  MUTATE(newnode->arg, caseexpr->arg, Expr *);
3277  MUTATE(newnode->args, caseexpr->args, List *);
3278  MUTATE(newnode->defresult, caseexpr->defresult, Expr *);
3279  return (Node *) newnode;
3280  }
3281  break;
3282  case T_CaseWhen:
3283  {
3284  CaseWhen *casewhen = (CaseWhen *) node;
3285  CaseWhen *newnode;
3286 
3287  FLATCOPY(newnode, casewhen, CaseWhen);
3288  MUTATE(newnode->expr, casewhen->expr, Expr *);
3289  MUTATE(newnode->result, casewhen->result, Expr *);
3290  return (Node *) newnode;
3291  }
3292  break;
3293  case T_ArrayExpr:
3294  {
3295  ArrayExpr *arrayexpr = (ArrayExpr *) node;
3296  ArrayExpr *newnode;
3297 
3298  FLATCOPY(newnode, arrayexpr, ArrayExpr);
3299  MUTATE(newnode->elements, arrayexpr->elements, List *);
3300  return (Node *) newnode;
3301  }
3302  break;
3303  case T_RowExpr:
3304  {
3305  RowExpr *rowexpr = (RowExpr *) node;
3306  RowExpr *newnode;
3307 
3308  FLATCOPY(newnode, rowexpr, RowExpr);
3309  MUTATE(newnode->args, rowexpr->args, List *);
3310  /* Assume colnames needn't be duplicated */
3311  return (Node *) newnode;
3312  }
3313  break;
3314  case T_RowCompareExpr:
3315  {
3316  RowCompareExpr *rcexpr = (RowCompareExpr *) node;
3317  RowCompareExpr *newnode;
3318 
3319  FLATCOPY(newnode, rcexpr, RowCompareExpr);
3320  MUTATE(newnode->largs, rcexpr->largs, List *);
3321  MUTATE(newnode->rargs, rcexpr->rargs, List *);
3322  return (Node *) newnode;
3323  }
3324  break;
3325  case T_CoalesceExpr:
3326  {
3327  CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
3328  CoalesceExpr *newnode;
3329 
3330  FLATCOPY(newnode, coalesceexpr, CoalesceExpr);
3331  MUTATE(newnode->args, coalesceexpr->args, List *);
3332  return (Node *) newnode;
3333  }
3334  break;
3335  case T_MinMaxExpr:
3336  {
3337  MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
3338  MinMaxExpr *newnode;
3339 
3340  FLATCOPY(newnode, minmaxexpr, MinMaxExpr);
3341  MUTATE(newnode->args, minmaxexpr->args, List *);
3342  return (Node *) newnode;
3343  }
3344  break;
3345  case T_XmlExpr:
3346  {
3347  XmlExpr *xexpr = (XmlExpr *) node;
3348  XmlExpr *newnode;
3349 
3350  FLATCOPY(newnode, xexpr, XmlExpr);
3351  MUTATE(newnode->named_args, xexpr->named_args, List *);
3352  /* assume mutator does not care about arg_names */
3353  MUTATE(newnode->args, xexpr->args, List *);
3354  return (Node *) newnode;
3355  }
3356  break;
3357  case T_JsonReturning:
3358  {
3359  JsonReturning *jr = (JsonReturning *) node;
3360  JsonReturning *newnode;
3361 
3362  FLATCOPY(newnode, jr, JsonReturning);
3363  MUTATE(newnode->format, jr->format, JsonFormat *);
3364 
3365  return (Node *) newnode;
3366  }
3367  case T_JsonValueExpr:
3368  {
3369  JsonValueExpr *jve = (JsonValueExpr *) node;
3370  JsonValueExpr *newnode;
3371 
3372  FLATCOPY(newnode, jve, JsonValueExpr);
3373  MUTATE(newnode->raw_expr, jve->raw_expr, Expr *);
3374  MUTATE(newnode->formatted_expr, jve->formatted_expr, Expr *);
3375  MUTATE(newnode->format, jve->format, JsonFormat *);
3376 
3377  return (Node *) newnode;
3378  }
3379  case T_JsonConstructorExpr:
3380  {
3381  JsonConstructorExpr *jce = (JsonConstructorExpr *) node;
3382  JsonConstructorExpr *newnode;
3383 
3384  FLATCOPY(newnode, jce, JsonConstructorExpr);
3385  MUTATE(newnode->args, jce->args, List *);
3386  MUTATE(newnode->func, jce->func, Expr *);
3387  MUTATE(newnode->coercion, jce->coercion, Expr *);
3388  MUTATE(newnode->returning, jce->returning, JsonReturning *);
3389 
3390  return (Node *) newnode;
3391  }
3392  case T_JsonIsPredicate:
3393  {
3394  JsonIsPredicate *pred = (JsonIsPredicate *) node;
3395  JsonIsPredicate *newnode;
3396 
3397  FLATCOPY(newnode, pred, JsonIsPredicate);
3398  MUTATE(newnode->expr, pred->expr, Node *);
3399  MUTATE(newnode->format, pred->format, JsonFormat *);
3400 
3401  return (Node *) newnode;
3402  }
3403  case T_JsonExpr:
3404  {
3405  JsonExpr *jexpr = (JsonExpr *) node;
3406  JsonExpr *newnode;
3407 
3408  FLATCOPY(newnode, jexpr, JsonExpr);
3409  MUTATE(newnode->formatted_expr, jexpr->formatted_expr, Node *);
3410  MUTATE(newnode->path_spec, jexpr->path_spec, Node *);
3411  MUTATE(newnode->passing_values, jexpr->passing_values, List *);
3412  /* assume mutator does not care about passing_names */
3413  MUTATE(newnode->on_empty, jexpr->on_empty, JsonBehavior *);
3414  MUTATE(newnode->on_error, jexpr->on_error, JsonBehavior *);
3415  return (Node *) newnode;
3416  }
3417  break;
3418  case T_JsonBehavior:
3419  {
3420  JsonBehavior *behavior = (JsonBehavior *) node;
3421  JsonBehavior *newnode;
3422 
3423  FLATCOPY(newnode, behavior, JsonBehavior);
3424  MUTATE(newnode->expr, behavior->expr, Node *);
3425  return (Node *) newnode;
3426  }
3427  break;
3428  case T_NullTest:
3429  {
3430  NullTest *ntest = (NullTest *) node;
3431  NullTest *newnode;
3432 
3433  FLATCOPY(newnode, ntest, NullTest);
3434  MUTATE(newnode->arg, ntest->arg, Expr *);
3435  return (Node *) newnode;
3436  }
3437  break;
3438  case T_BooleanTest:
3439  {
3440  BooleanTest *btest = (BooleanTest *) node;
3441  BooleanTest *newnode;
3442 
3443  FLATCOPY(newnode, btest, BooleanTest);
3444  MUTATE(newnode->arg, btest->arg, Expr *);
3445  return (Node *) newnode;
3446  }
3447  break;
3448  case T_CoerceToDomain:
3449  {
3450  CoerceToDomain *ctest = (CoerceToDomain *) node;
3451  CoerceToDomain *newnode;
3452 
3453  FLATCOPY(newnode, ctest, CoerceToDomain);
3454  MUTATE(newnode->arg, ctest->arg, Expr *);
3455  return (Node *) newnode;
3456  }
3457  break;
3458  case T_TargetEntry:
3459  {
3460  TargetEntry *targetentry = (TargetEntry *) node;
3461  TargetEntry *newnode;
3462 
3463  FLATCOPY(newnode, targetentry, TargetEntry);
3464  MUTATE(newnode->expr, targetentry->expr, Expr *);
3465  return (Node *) newnode;
3466  }
3467  break;
3468  case T_Query:
3469  /* Do nothing with a sub-Query, per discussion above */
3470  return node;
3471  case T_WindowClause:
3472  {
3473  WindowClause *wc = (WindowClause *) node;
3474  WindowClause *newnode;
3475 
3476  FLATCOPY(newnode, wc, WindowClause);
3477  MUTATE(newnode->partitionClause, wc->partitionClause, List *);
3478  MUTATE(newnode->orderClause, wc->orderClause, List *);
3479  MUTATE(newnode->startOffset, wc->startOffset, Node *);
3480  MUTATE(newnode->endOffset, wc->endOffset, Node *);
3481  return (Node *) newnode;
3482  }
3483  break;
3484  case T_CTECycleClause:
3485  {
3486  CTECycleClause *cc = (CTECycleClause *) node;
3487  CTECycleClause *newnode;
3488 
3489  FLATCOPY(newnode, cc, CTECycleClause);
3490  MUTATE(newnode->cycle_mark_value, cc->cycle_mark_value, Node *);
3491  MUTATE(newnode->cycle_mark_default, cc->cycle_mark_default, Node *);
3492  return (Node *) newnode;
3493  }
3494  break;
3495  case T_CommonTableExpr:
3496  {
3497  CommonTableExpr *cte = (CommonTableExpr *) node;
3498  CommonTableExpr *newnode;
3499 
3500  FLATCOPY(newnode, cte, CommonTableExpr);
3501 
3502  /*
3503  * Also invoke the mutator on the CTE's Query node, so it can
3504  * recurse into the sub-query if it wants to.
3505  */
3506  MUTATE(newnode->ctequery, cte->ctequery, Node *);
3507 
3508  MUTATE(newnode->search_clause, cte->search_clause, CTESearchClause *);
3509  MUTATE(newnode->cycle_clause, cte->cycle_clause, CTECycleClause *);
3510 
3511  return (Node *) newnode;
3512  }
3513  break;
3514  case T_PartitionBoundSpec:
3515  {
3516  PartitionBoundSpec *pbs = (PartitionBoundSpec *) node;
3517  PartitionBoundSpec *newnode;
3518 
3519  FLATCOPY(newnode, pbs, PartitionBoundSpec);
3520  MUTATE(newnode->listdatums, pbs->listdatums, List *);
3521  MUTATE(newnode->lowerdatums, pbs->lowerdatums, List *);
3522  MUTATE(newnode->upperdatums, pbs->upperdatums, List *);
3523  return (Node *) newnode;
3524  }
3525  break;
3526  case T_PartitionRangeDatum:
3527  {
3528  PartitionRangeDatum *prd = (PartitionRangeDatum *) node;
3529  PartitionRangeDatum *newnode;
3530 
3531  FLATCOPY(newnode, prd, PartitionRangeDatum);
3532  MUTATE(newnode->value, prd->value, Node *);
3533  return (Node *) newnode;
3534  }
3535  break;
3536  case T_List:
3537  {
3538  /*
3539  * We assume the mutator isn't interested in the list nodes
3540  * per se, so just invoke it on each list element. NOTE: this
3541  * would fail badly on a list with integer elements!
3542  */
3543  List *resultlist;
3544  ListCell *temp;
3545 
3546  resultlist = NIL;
3547  foreach(temp, (List *) node)
3548  {
3549  resultlist = lappend(resultlist,
3550  mutator((Node *) lfirst(temp),
3551  context));
3552  }
3553  return (Node *) resultlist;
3554  }
3555  break;
3556  case T_FromExpr:
3557  {
3558  FromExpr *from = (FromExpr *) node;
3559  FromExpr *newnode;
3560 
3561  FLATCOPY(newnode, from, FromExpr);
3562  MUTATE(newnode->fromlist, from->fromlist, List *);
3563  MUTATE(newnode->quals, from->quals, Node *);
3564  return (Node *) newnode;
3565  }
3566  break;
3567  case T_OnConflictExpr:
3568  {
3569  OnConflictExpr *oc = (OnConflictExpr *) node;
3570  OnConflictExpr *newnode;
3571 
3572  FLATCOPY(newnode, oc, OnConflictExpr);
3573  MUTATE(newnode->arbiterElems, oc->arbiterElems, List *);
3574  MUTATE(newnode->arbiterWhere, oc->arbiterWhere, Node *);
3575  MUTATE(newnode->onConflictSet, oc->onConflictSet, List *);
3576  MUTATE(newnode->onConflictWhere, oc->onConflictWhere, Node *);
3577  MUTATE(newnode->exclRelTlist, oc->exclRelTlist, List *);
3578 
3579  return (Node *) newnode;
3580  }
3581  break;
3582  case T_MergeAction:
3583  {
3584  MergeAction *action = (MergeAction *) node;
3585  MergeAction *newnode;
3586 
3587  FLATCOPY(newnode, action, MergeAction);
3588  MUTATE(newnode->qual, action->qual, Node *);
3589  MUTATE(newnode->targetList, action->targetList, List *);
3590 
3591  return (Node *) newnode;
3592  }
3593  break;
3594  case T_PartitionPruneStepOp:
3595  {
3596  PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;
3597  PartitionPruneStepOp *newnode;
3598 
3599  FLATCOPY(newnode, opstep, PartitionPruneStepOp);
3600  MUTATE(newnode->exprs, opstep->exprs, List *);
3601 
3602  return (Node *) newnode;
3603  }
3604  break;
3605  case T_PartitionPruneStepCombine:
3606  /* no expression sub-nodes */
3607  return (Node *) copyObject(node);
3608  case T_JoinExpr:
3609  {
3610  JoinExpr *join = (JoinExpr *) node;
3611  JoinExpr *newnode;
3612 
3613  FLATCOPY(newnode, join, JoinExpr);
3614  MUTATE(newnode->larg, join->larg, Node *);
3615  MUTATE(newnode->rarg, join->rarg, Node *);
3616  MUTATE(newnode->quals, join->quals, Node *);
3617  /* We do not mutate alias or using by default */
3618  return (Node *) newnode;
3619  }
3620  break;
3621  case T_SetOperationStmt:
3622  {
3623  SetOperationStmt *setop = (SetOperationStmt *) node;
3624  SetOperationStmt *newnode;
3625 
3626  FLATCOPY(newnode, setop, SetOperationStmt);
3627  MUTATE(newnode->larg, setop->larg, Node *);
3628  MUTATE(newnode->rarg, setop->rarg, Node *);
3629  /* We do not mutate groupClauses by default */
3630  return (Node *) newnode;
3631  }
3632  break;
3633  case T_IndexClause:
3634  {
3635  IndexClause *iclause = (IndexClause *) node;
3636  IndexClause *newnode;
3637 
3638  FLATCOPY(newnode, iclause, IndexClause);
3639  MUTATE(newnode->rinfo, iclause->rinfo, RestrictInfo *);
3640  MUTATE(newnode->indexquals, iclause->indexquals, List *);
3641  return (Node *) newnode;
3642  }
3643  break;
3644  case T_PlaceHolderVar:
3645  {
3646  PlaceHolderVar *phv = (PlaceHolderVar *) node;
3647  PlaceHolderVar *newnode;
3648 
3649  FLATCOPY(newnode, phv, PlaceHolderVar);
3650  MUTATE(newnode->phexpr, phv->phexpr, Expr *);
3651  /* Assume we need not copy the relids bitmapsets */
3652  return (Node *) newnode;
3653  }
3654  break;
3655  case T_InferenceElem:
3656  {
3657  InferenceElem *inferenceelemdexpr = (InferenceElem *) node;
3658  InferenceElem *newnode;
3659 
3660  FLATCOPY(newnode, inferenceelemdexpr, InferenceElem);
3661  MUTATE(newnode->expr, newnode->expr, Node *);
3662  return (Node *) newnode;
3663  }
3664  break;
3665  case T_AppendRelInfo:
3666  {
3667  AppendRelInfo *appinfo = (AppendRelInfo *) node;
3668  AppendRelInfo *newnode;
3669 
3670  FLATCOPY(newnode, appinfo, AppendRelInfo);
3671  MUTATE(newnode->translated_vars, appinfo->translated_vars, List *);
3672  /* Assume nothing need be done with parent_colnos[] */
3673  return (Node *) newnode;
3674  }
3675  break;
3676  case T_PlaceHolderInfo:
3677  {
3678  PlaceHolderInfo *phinfo = (PlaceHolderInfo *) node;
3679  PlaceHolderInfo *newnode;
3680 
3681  FLATCOPY(newnode, phinfo, PlaceHolderInfo);
3682  MUTATE(newnode->ph_var, phinfo->ph_var, PlaceHolderVar *);
3683  /* Assume we need not copy the relids bitmapsets */
3684  return (Node *) newnode;
3685  }
3686  break;
3687  case T_RangeTblFunction:
3688  {
3689  RangeTblFunction *rtfunc = (RangeTblFunction *) node;
3690  RangeTblFunction *newnode;
3691 
3692  FLATCOPY(newnode, rtfunc, RangeTblFunction);
3693  MUTATE(newnode->funcexpr, rtfunc->funcexpr, Node *);
3694  /* Assume we need not copy the coldef info lists */
3695  return (Node *) newnode;
3696  }
3697  break;
3698  case T_TableSampleClause:
3699  {
3700  TableSampleClause *tsc = (TableSampleClause *) node;
3701  TableSampleClause *newnode;
3702 
3703  FLATCOPY(newnode, tsc, TableSampleClause);
3704  MUTATE(newnode->args, tsc->args, List *);
3705  MUTATE(newnode->repeatable, tsc->repeatable, Expr *);
3706  return (Node *) newnode;
3707  }
3708  break;
3709  case T_TableFunc:
3710  {
3711  TableFunc *tf = (TableFunc *) node;
3712  TableFunc *newnode;
3713 
3714  FLATCOPY(newnode, tf, TableFunc);
3715  MUTATE(newnode->ns_uris, tf->ns_uris, List *);
3716  MUTATE(newnode->docexpr, tf->docexpr, Node *);
3717  MUTATE(newnode->rowexpr, tf->rowexpr, Node *);
3718  MUTATE(newnode->colexprs, tf->colexprs, List *);
3719  MUTATE(newnode->coldefexprs, tf->coldefexprs, List *);
3720  MUTATE(newnode->colvalexprs, tf->colvalexprs, List *);
3721  MUTATE(newnode->passingvalexprs, tf->passingvalexprs, List *);
3722  return (Node *) newnode;
3723  }
3724  break;
3725  default:
3726  elog(ERROR, "unrecognized node type: %d",
3727  (int) nodeTag(node));
3728  break;
3729  }
3730  /* can't get here, but keep compiler happy */
3731  return NULL;
3732 }
3733 
3734 
3735 /*
3736  * query_tree_mutator --- initiate modification of a Query's expressions
3737  *
3738  * This routine exists just to reduce the number of places that need to know
3739  * where all the expression subtrees of a Query are. Note it can be used
3740  * for starting a walk at top level of a Query regardless of whether the
3741  * mutator intends to descend into subqueries. It is also useful for
3742  * descending into subqueries within a mutator.
3743  *
3744  * Some callers want to suppress mutating of certain items in the Query,
3745  * typically because they need to process them specially, or don't actually
3746  * want to recurse into subqueries. This is supported by the flags argument,
3747  * which is the bitwise OR of flag values to suppress mutating of
3748  * indicated items. (More flag bits may be added as needed.)
3749  *
3750  * Normally the top-level Query node itself is copied, but some callers want
3751  * it to be modified in-place; they must pass QTW_DONT_COPY_QUERY in flags.
3752  * All modified substructure is safely copied in any case.
3753  */
3754 Query *
3755 query_tree_mutator_impl(Query *query,
3756  tree_mutator_callback mutator,
3757  void *context,
3758  int flags)
3759 {
3760  Assert(query != NULL && IsA(query, Query));
3761 
3762  if (!(flags & QTW_DONT_COPY_QUERY))
3763  {
3764  Query *newquery;
3765 
3766  FLATCOPY(newquery, query, Query);
3767  query = newquery;
3768  }
3769 
3770  MUTATE(query->targetList, query->targetList, List *);
3771  MUTATE(query->withCheckOptions, query->withCheckOptions, List *);
3772  MUTATE(query->onConflict, query->onConflict, OnConflictExpr *);
3773  MUTATE(query->mergeActionList, query->mergeActionList, List *);
3774  MUTATE(query->mergeJoinCondition, query->mergeJoinCondition, Node *);
3775  MUTATE(query->returningList, query->returningList, List *);
3776  MUTATE(query->jointree, query->jointree, FromExpr *);
3777  MUTATE(query->setOperations, query->setOperations, Node *);
3778  MUTATE(query->havingQual, query->havingQual, Node *);
3779  MUTATE(query->limitOffset, query->limitOffset, Node *);
3780  MUTATE(query->limitCount, query->limitCount, Node *);
3781 
3782  /*
3783  * Most callers aren't interested in SortGroupClause nodes since those
3784  * don't contain actual expressions. However they do contain OIDs, which
3785  * may be of interest to some mutators.
3786  */
3787 
3788  if ((flags & QTW_EXAMINE_SORTGROUP))
3789  {
3790  MUTATE(query->groupClause, query->groupClause, List *);
3791  MUTATE(query->windowClause, query->windowClause, List *);
3792  MUTATE(query->sortClause, query->sortClause, List *);
3793  MUTATE(query->distinctClause, query->distinctClause, List *);
3794  }
3795  else
3796  {
3797  /*
3798  * But we need to mutate the expressions under WindowClause nodes even
3799  * if we're not interested in SortGroupClause nodes.
3800  */
3801  List *resultlist;
3802  ListCell *temp;
3803 
3804  resultlist = NIL;
3805  foreach(temp, query->windowClause)
3806  {
3807  WindowClause *wc = lfirst_node(WindowClause, temp);
3808  WindowClause *newnode;
3809 
3810  FLATCOPY(newnode, wc, WindowClause);
3811  MUTATE(newnode->startOffset, wc->startOffset, Node *);
3812  MUTATE(newnode->endOffset, wc->endOffset, Node *);
3813 
3814  resultlist = lappend(resultlist, (Node *) newnode);
3815  }
3816  query->windowClause = resultlist;
3817  }
3818 
3819  /*
3820  * groupingSets and rowMarks are not mutated:
3821  *
3822  * groupingSets contain only ressortgroup refs (integers) which are
3823  * meaningless without the groupClause or tlist. Accordingly, any mutator
3824  * that needs to care about them needs to handle them itself in its Query
3825  * processing.
3826  *
3827  * rowMarks contains only rangetable indexes (and flags etc.) and
3828  * therefore should be handled at Query level similarly.
3829  */
3830 
3831  if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
3832  MUTATE(query->cteList, query->cteList, List *);
3833  else /* else copy CTE list as-is */
3834  query->cteList = copyObject(query->cteList);
3835  query->rtable = range_table_mutator(query->rtable,
3836  mutator, context, flags);
3837  return query;
3838 }
3839 
3840 /*
3841  * range_table_mutator is just the part of query_tree_mutator that processes
3842  * a query's rangetable. This is split out since it can be useful on
3843  * its own.
3844  */
3845 List *
3846 range_table_mutator_impl(List *rtable,
3847  tree_mutator_callback mutator,
3848  void *context,
3849  int flags)
3850 {
3851  List *newrt = NIL;
3852  ListCell *rt;
3853 
3854  foreach(rt, rtable)
3855  {
3856  RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
3857  RangeTblEntry *newrte;
3858 
3859  FLATCOPY(newrte, rte, RangeTblEntry);
3860  switch (rte->rtekind)
3861  {
3862  case RTE_RELATION:
3863  MUTATE(newrte->tablesample, rte->tablesample,
3864  TableSampleClause *);
3865  /* we don't bother to copy eref, aliases, etc; OK? */
3866  break;
3867  case RTE_SUBQUERY:
3868  if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
3869  MUTATE(newrte->subquery, rte->subquery, Query *);
3870  else
3871  {
3872  /* else, copy RT subqueries as-is */
3873  newrte->subquery = copyObject(rte->subquery);
3874  }
3875  break;
3876  case RTE_JOIN:
3877  if (!(flags & QTW_IGNORE_JOINALIASES))
3878  MUTATE(newrte->joinaliasvars, rte->joinaliasvars, List *);
3879  else
3880  {
3881  /* else, copy join aliases as-is */
3882  newrte->joinaliasvars = copyObject(rte->joinaliasvars);
3883  }
3884  break;
3885  case RTE_FUNCTION:
3886  MUTATE(newrte->functions, rte->functions, List *);
3887  break;
3888  case RTE_TABLEFUNC:
3889  MUTATE(newrte->tablefunc, rte->tablefunc, TableFunc *);
3890  break;
3891  case RTE_VALUES:
3892  MUTATE(newrte->values_lists, rte->values_lists, List *);
3893  break;
3894  case RTE_CTE:
3895  case RTE_NAMEDTUPLESTORE:
3896  case RTE_RESULT:
3897  /* nothing to do */
3898  break;
3899  case RTE_GROUP:
3900  if (!(flags & QTW_IGNORE_GROUPEXPRS))
3901  MUTATE(newrte->groupexprs, rte->groupexprs, List *);
3902  else
3903  {
3904  /* else, copy grouping exprs as-is */
3905  newrte->groupexprs = copyObject(rte->groupexprs);
3906  }
3907  break;
3908  }
3909  MUTATE(newrte->securityQuals, rte->securityQuals, List *);
3910  newrt = lappend(newrt, newrte);
3911  }
3912  return newrt;
3913 }
3914 
3915 /*
3916  * query_or_expression_tree_walker --- hybrid form
3917  *
3918  * This routine will invoke query_tree_walker if called on a Query node,
3919  * else will invoke the walker directly. This is a useful way of starting
3920  * the recursion when the walker's normal change of state is not appropriate
3921  * for the outermost Query node.
3922  */
3923 bool
3924 query_or_expression_tree_walker_impl(Node *node,
3925  tree_walker_callback walker,
3926  void *context,
3927  int flags)
3928 {
3929  if (node && IsA(node, Query))
3930  return query_tree_walker((Query *) node,
3931  walker,
3932  context,
3933  flags);
3934  else
3935  return WALK(node);
3936 }
3937 
3938 /*
3939  * query_or_expression_tree_mutator --- hybrid form
3940  *
3941  * This routine will invoke query_tree_mutator if called on a Query node,
3942  * else will invoke the mutator directly. This is a useful way of starting
3943  * the recursion when the mutator's normal change of state is not appropriate
3944  * for the outermost Query node.
3945  */
3946 Node *
3947 query_or_expression_tree_mutator_impl(Node *node,
3948  tree_mutator_callback mutator,
3949  void *context,
3950  int flags)
3951 {
3952  if (node && IsA(node, Query))
3953  return (Node *) query_tree_mutator((Query *) node,
3954  mutator,
3955  context,
3956  flags);
3957  else
3958  return mutator(node, context);
3959 }
3960 
3961 
3962 /*
3963  * raw_expression_tree_walker --- walk raw parse trees
3964  *
3965  * This has exactly the same API as expression_tree_walker, but instead of
3966  * walking post-analysis parse trees, it knows how to walk the node types
3967  * found in raw grammar output. (There is not currently any need for a
3968  * combined walker, so we keep them separate in the name of efficiency.)
3969  * Unlike expression_tree_walker, there is no special rule about query
3970  * boundaries: we descend to everything that's possibly interesting.
3971  *
3972  * Currently, the node type coverage here extends only to DML statements
3973  * (SELECT/INSERT/UPDATE/DELETE/MERGE) and nodes that can appear in them,
3974  * because this is used mainly during analysis of CTEs, and only DML
3975  * statements can appear in CTEs.
3976  */
3977 bool
3978 raw_expression_tree_walker_impl(Node *node,
3979  tree_walker_callback walker,
3980  void *context)
3981 {
3982  ListCell *temp;
3983 
3984  /*
3985  * The walker has already visited the current node, and so we need only
3986  * recurse into any sub-nodes it has.
3987  */
3988  if (node == NULL)
3989  return false;
3990 
3991  /* Guard against stack overflow due to overly complex expressions */
3992  check_stack_depth();
3993 
3994  switch (nodeTag(node))
3995  {
3996  case T_JsonFormat:
3997  case T_SetToDefault:
3998  case T_CurrentOfExpr:
3999  case T_SQLValueFunction:
4000  case T_Integer:
4001  case T_Float:
4002  case T_Boolean:
4003  case T_String:
4004  case T_BitString:
4005  case T_ParamRef:
4006  case T_A_Const:
4007  case T_A_Star:
4008  case T_MergeSupportFunc:
4009  /* primitive node types with no subnodes */
4010  break;
4011  case T_Alias:
4012  /* we assume the colnames list isn't interesting */
4013  break;
4014  case T_RangeVar:
4015  return WALK(((RangeVar *) node)->alias);
4016  case T_GroupingFunc:
4017  return WALK(((GroupingFunc *) node)->args);
4018  case T_SubLink:
4019  {
4020  SubLink *sublink = (SubLink *) node;
4021 
4022  if (WALK(sublink->testexpr))
4023  return true;
4024  /* we assume the operName is not interesting */
4025  if (WALK(sublink->subselect))
4026  return true;
4027  }
4028  break;
4029  case T_CaseExpr:
4030  {
4031  CaseExpr *caseexpr = (CaseExpr *) node;
4032 
4033  if (WALK(caseexpr->arg))
4034  return true;
4035  /* we assume walker doesn't care about CaseWhens, either */
4036  foreach(temp, caseexpr->args)
4037  {
4038  CaseWhen *when = lfirst_node(CaseWhen, temp);
4039 
4040  if (WALK(when->expr))
4041  return true;
4042  if (WALK(when->result))
4043  return true;
4044  }
4045  if (WALK(caseexpr->defresult))
4046  return true;
4047  }
4048  break;
4049  case T_RowExpr:
4050  /* Assume colnames isn't interesting */
4051  return WALK(((RowExpr *) node)->args);
4052  case T_CoalesceExpr:
4053  return WALK(((CoalesceExpr *) node)->args);
4054  case T_MinMaxExpr:
4055  return WALK(((MinMaxExpr *) node)->args);
4056  case T_XmlExpr:
4057  {
4058  XmlExpr *xexpr = (XmlExpr *) node;
4059 
4060  if (WALK(xexpr->named_args))
4061  return true;
4062  /* we assume walker doesn't care about arg_names */
4063  if (WALK(xexpr->args))
4064  return true;
4065  }
4066  break;
4067  case T_JsonReturning:
4068  return WALK(((JsonReturning *) node)->format);
4069  case T_JsonValueExpr:
4070  {
4071  JsonValueExpr *jve = (JsonValueExpr *) node;
4072 
4073  if (WALK(jve->raw_expr))
4074  return true;
4075  if (WALK(jve->formatted_expr))
4076  return true;
4077  if (WALK(jve->format))
4078  return true;
4079  }
4080  break;
4081  case T_JsonParseExpr:
4082  {
4083  JsonParseExpr *jpe = (JsonParseExpr *) node;
4084 
4085  if (WALK(jpe->expr))
4086  return true;
4087  if (WALK(jpe->output))
4088  return true;
4089  }
4090  break;
4091  case T_JsonScalarExpr:
4092  {
4093  JsonScalarExpr *jse = (JsonScalarExpr *) node;
4094 
4095  if (WALK(jse->expr))
4096  return true;
4097  if (WALK(jse->output))
4098  return true;
4099  }
4100  break;
4101  case T_JsonSerializeExpr:
4102  {
4103  JsonSerializeExpr *jse = (JsonSerializeExpr *) node;
4104 
4105  if (WALK(jse->expr))
4106  return true;
4107  if (WALK(jse->output))
4108  return true;
4109  }
4110  break;
4111  case T_JsonConstructorExpr:
4112  {
4113  JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;
4114 
4115  if (WALK(ctor->args))
4116  return true;
4117  if (WALK(ctor->func))
4118  return true;
4119  if (WALK(ctor->coercion))
4120  return true;
4121  if (WALK(ctor->returning))
4122  return true;
4123  }
4124  break;
4125  case T_JsonIsPredicate:
4126  return WALK(((JsonIsPredicate *) node)->expr);
4127  case T_JsonArgument:
4128  return WALK(((JsonArgument *) node)->val);
4129  case T_JsonFuncExpr:
4130  {
4131  JsonFuncExpr *jfe = (JsonFuncExpr *) node;
4132 
4133  if (WALK(jfe->context_item))
4134  return true;
4135  if (WALK(jfe->pathspec))
4136  return true;
4137  if (WALK(jfe->passing))
4138  return true;
4139  if (WALK(jfe->output))
4140  return true;
4141  if (WALK(jfe->on_empty))
4142  return true;
4143  if (WALK(jfe->on_error))
4144  return true;
4145  }
4146  break;
4147  case T_JsonBehavior:
4148  {
4149  JsonBehavior *jb = (JsonBehavior *) node;
4150 
4151  if (WALK(jb->expr))
4152  return true;
4153  }
4154  break;
4155  case T_JsonTable:
4156  {
4157  JsonTable *jt = (JsonTable *) node;
4158 
4159  if (WALK(jt->context_item))
4160  return true;
4161  if (WALK(jt->pathspec))
4162  return true;
4163  if (WALK(jt->passing))
4164  return true;
4165  if (WALK(jt->columns))
4166  return true;
4167  if (WALK(jt->on_error))
4168  return true;
4169  }
4170  break;
4171  case T_JsonTableColumn:
4172  {
4173  JsonTableColumn *jtc = (JsonTableColumn *) node;
4174 
4175  if (WALK(jtc->typeName))
4176  return true;
4177  if (WALK(jtc->on_empty))
4178  return true;
4179  if (WALK(jtc->on_error))
4180  return true;
4181  if (WALK(jtc->columns))
4182  return true;
4183  }
4184  break;
4185  case T_JsonTablePathSpec:
4186  return WALK(((JsonTablePathSpec *) node)->string);
4187  case T_NullTest:
4188  return WALK(((NullTest *) node)->arg);
4189  case T_BooleanTest:
4190  return WALK(((BooleanTest *) node)->arg);
4191  case T_JoinExpr:
4192  {
4193  JoinExpr *join = (JoinExpr *) node;
4194 
4195  if (WALK(join->larg))
4196  return true;
4197  if (WALK(join->rarg))
4198  return true;
4199  if (WALK(join->quals))
4200  return true;
4201  if (WALK(join->alias))
4202  return true;
4203  /* using list is deemed uninteresting */
4204  }
4205  break;
4206  case T_IntoClause:
4207  {
4208  IntoClause *into = (IntoClause *) node;
4209 
4210  if (WALK(into->rel))
4211  return true;
4212  /* colNames, options are deemed uninteresting */
4213  /* viewQuery should be null in raw parsetree, but check it */
4214  if (WALK(into->viewQuery))
4215  return true;
4216  }
4217  break;
4218  case T_List:
4219  foreach(temp, (List *) node)
4220  {
4221  if (WALK((Node *) lfirst(temp)))
4222  return true;
4223  }
4224  break;
4225  case T_InsertStmt:
4226  {
4227  InsertStmt *stmt = (InsertStmt *) node;
4228 
4229  if (WALK(stmt->relation))
4230  return true;
4231  if (WALK(stmt->cols))
4232  return true;
4233  if (WALK(stmt->selectStmt))
4234  return true;
4235  if (WALK(stmt->onConflictClause))
4236  return true;
4237  if (WALK(stmt->returningList))
4238  return true;
4239  if (WALK(stmt->withClause))
4240  return true;
4241  }
4242  break;
4243  case T_DeleteStmt:
4244  {
4245  DeleteStmt *stmt = (DeleteStmt *) node;
4246 
4247  if (WALK(stmt->relation))
4248  return true;
4249  if (WALK(stmt->usingClause))
4250  return true;
4251  if (WALK(stmt->whereClause))
4252  return true;
4253  if (WALK(stmt->returningList))
4254  return true;
4255  if (WALK(stmt->withClause))
4256  return true;
4257  }
4258  break;
4259  case T_UpdateStmt:
4260  {
4261  UpdateStmt *stmt = (UpdateStmt *) node;
4262 
4263  if (WALK(stmt->relation))
4264  return true;
4265  if (WALK(stmt->targetList))
4266  return true;
4267  if (WALK(stmt->whereClause))
4268  return true;
4269  if (WALK(stmt->fromClause))
4270  return true;
4271  if (WALK(stmt->returningList))
4272  return true;
4273  if (WALK(stmt->withClause))
4274  return true;
4275  }
4276  break;
4277  case T_MergeStmt:
4278  {
4279  MergeStmt *stmt = (MergeStmt *) node;
4280 
4281  if (WALK(stmt->relation))
4282  return true;
4283  if (WALK(stmt->sourceRelation))
4284  return true;
4285  if (WALK(stmt->joinCondition))
4286  return true;
4287  if (WALK(stmt->mergeWhenClauses))
4288  return true;
4289  if (WALK(stmt->returningList))
4290  return true;
4291  if (WALK(stmt->withClause))
4292  return true;
4293  }
4294  break;
4295  case T_MergeWhenClause:
4296  {
4297  MergeWhenClause *mergeWhenClause = (MergeWhenClause *) node;
4298 
4299  if (WALK(mergeWhenClause->condition))
4300  return true;
4301  if (WALK(mergeWhenClause->targetList))
4302  return true;
4303  if (WALK(mergeWhenClause->values))
4304  return true;
4305  }
4306  break;
4307  case T_SelectStmt:
4308  {
4309  SelectStmt *stmt = (SelectStmt *) node;
4310 
4311  if (WALK(stmt->distinctClause))
4312  return true;
4313  if (WALK(stmt->intoClause))
4314  return true;
4315  if (WALK(stmt->targetList))
4316  return true;
4317  if (WALK(stmt->fromClause))
4318  return true;
4319  if (WALK(stmt->whereClause))
4320  return true;
4321  if (WALK(stmt->groupClause))
4322  return true;
4323  if (WALK(stmt->havingClause))
4324  return true;
4325  if (WALK(stmt->windowClause))
4326  return true;
4327  if (WALK(stmt->valuesLists))
4328  return true;
4329  if (WALK(stmt->sortClause))
4330  return true;
4331  if (WALK(stmt->limitOffset))
4332  return true;
4333  if (WALK(stmt->limitCount))
4334  return true;
4335  if (WALK(stmt->lockingClause))
4336  return true;
4337  if (WALK(stmt->withClause))
4338  return true;
4339  if (WALK(stmt->larg))
4340  return true;
4341  if (WALK(stmt->rarg))
4342  return true;
4343  }
4344  break;
4345  case T_PLAssignStmt:
4346  {
4347  PLAssignStmt *stmt = (PLAssignStmt *) node;
4348 
4349  if (WALK(stmt->indirection))
4350  return true;
4351  if (WALK(stmt->val))
4352  return true;
4353  }
4354  break;
4355  case T_A_Expr:
4356  {
4357  A_Expr *expr = (A_Expr *) node;
4358 
4359  if (WALK(expr->lexpr))
4360  return true;
4361  if (WALK(expr->rexpr))
4362  return true;
4363  /* operator name is deemed uninteresting */
4364  }
4365  break;
4366  case T_BoolExpr:
4367  {
4368  BoolExpr *expr = (BoolExpr *) node;
4369 
4370  if (WALK(expr->args))
4371  return true;
4372  }
4373  break;
4374  case T_ColumnRef:
4375  /* we assume the fields contain nothing interesting */
4376  break;
4377  case T_FuncCall:
4378  {
4379  FuncCall *fcall = (FuncCall *) node;
4380 
4381  if (WALK(fcall->args))
4382  return true;
4383  if (WALK(fcall->agg_order))
4384  return true;
4385  if (WALK(fcall->agg_filter))
4386  return true;
4387  if (WALK(fcall->over))
4388  return true;
4389  /* function name is deemed uninteresting */
4390  }
4391  break;
4392  case T_NamedArgExpr:
4393  return WALK(((NamedArgExpr *) node)->arg);
4394  case T_A_Indices:
4395  {
4396  A_Indices *indices = (A_Indices *) node;
4397 
4398  if (WALK(indices->lidx))
4399  return true;
4400  if (WALK(indices->uidx))
4401  return true;
4402  }
4403  break;
4404  case T_A_Indirection:
4405  {
4406  A_Indirection *indir = (A_Indirection *) node;
4407 
4408  if (WALK(indir->arg))
4409  return true;
4410  if (WALK(indir->indirection))
4411  return true;
4412  }
4413  break;
4414  case T_A_ArrayExpr:
4415  return WALK(((A_ArrayExpr *) node)->elements);
4416  case T_ResTarget:
4417  {
4418  ResTarget *rt = (ResTarget *) node;
4419 
4420  if (WALK(rt->indirection))
4421  return true;
4422  if (WALK(rt->val))
4423  return true;
4424  }
4425  break;
4426  case T_MultiAssignRef:
4427  return WALK(((MultiAssignRef *) node)->source);
4428  case T_TypeCast:
4429  {
4430  TypeCast *tc = (TypeCast *) node;
4431 
4432  if (WALK(tc->arg))
4433  return true;
4434  if (WALK(tc->typeName))
4435  return true;
4436  }
4437  break;
4438  case T_CollateClause:
4439  return WALK(((CollateClause *) node)->arg);
4440  case T_SortBy:
4441  return WALK(((SortBy *) node)->node);
4442  case T_WindowDef:
4443  {
4444  WindowDef *wd = (WindowDef *) node;
4445 
4446  if (WALK(wd->partitionClause))
4447  return true;
4448  if (WALK(wd->orderClause))
4449  return true;
4450  if (WALK(wd->startOffset))
4451  return true;
4452  if (WALK(wd->endOffset))
4453  return true;
4454  }
4455  break;
4456  case T_RangeSubselect:
4457  {
4458  RangeSubselect *rs = (RangeSubselect *) node;
4459 
4460  if (WALK(rs->subquery))
4461  return true;
4462  if (WALK(rs->alias))
4463  return true;
4464  }
4465  break;
4466  case T_RangeFunction:
4467  {
4468  RangeFunction *rf = (RangeFunction *) node;
4469 
4470  if (WALK(rf->functions))
4471  return true;
4472  if (WALK(rf->alias))
4473  return true;
4474  if (WALK(rf->coldeflist))
4475  return true;
4476  }
4477  break;
4478  case T_RangeTableSample:
4479  {
4480  RangeTableSample *rts = (RangeTableSample *) node;
4481 
4482  if (WALK(rts->relation))
4483  return true;
4484  /* method name is deemed uninteresting */
4485  if (WALK(rts->args))
4486  return true;
4487  if (WALK(rts->repeatable))
4488  return true;
4489  }
4490  break;
4491  case T_RangeTableFunc:
4492  {
4493  RangeTableFunc *rtf = (RangeTableFunc *) node;
4494 
4495  if (WALK(rtf->docexpr))
4496  return true;
4497  if (WALK(rtf->rowexpr))
4498  return true;
4499  if (WALK(rtf->namespaces))
4500  return true;
4501  if (WALK(rtf->columns))
4502  return true;
4503  if (WALK(rtf->alias))
4504  return true;
4505  }
4506  break;
4507  case T_RangeTableFuncCol:
4508  {
4509  RangeTableFuncCol *rtfc = (RangeTableFuncCol *) node;
4510 
4511  if (WALK(rtfc->colexpr))
4512  return true;
4513  if (WALK(rtfc->coldefexpr))
4514  return true;
4515  }
4516  break;
4517  case T_TypeName:
4518  {
4519  TypeName *tn = (TypeName *) node;
4520 
4521  if (WALK(tn->typmods))
4522  return true;
4523  if (WALK(tn->arrayBounds))
4524  return true;
4525  /* type name itself is deemed uninteresting */
4526  }
4527  break;
4528  case T_ColumnDef:
4529  {
4530  ColumnDef *coldef = (ColumnDef *) node;
4531 
4532  if (WALK(coldef->typeName))
4533  return true;
4534  if (WALK(coldef->raw_default))
4535  return true;
4536  if (WALK(coldef->collClause))
4537  return true;
4538  /* for now, constraints are ignored */
4539  }
4540  break;
4541  case T_IndexElem:
4542  {
4543  IndexElem *indelem = (IndexElem *) node;
4544 
4545  if (WALK(indelem->expr))
4546  return true;
4547  /* collation and opclass names are deemed uninteresting */
4548  }
4549  break;
4550  case T_GroupingSet:
4551  return WALK(((GroupingSet *) node)->content);
4552  case T_LockingClause:
4553  return WALK(((LockingClause *) node)->lockedRels);
4554  case T_XmlSerialize:
4555  {
4556  XmlSerialize *xs = (XmlSerialize *) node;
4557 
4558  if (WALK(xs->expr))
4559  return true;
4560  if (WALK(xs->typeName))
4561  return true;
4562  }
4563  break;
4564  case T_WithClause:
4565  return WALK(((WithClause *) node)->ctes);
4566  case T_InferClause:
4567  {
4568  InferClause *stmt = (InferClause *) node;
4569 
4570  if (WALK(stmt->indexElems))
4571  return true;
4572  if (WALK(stmt->whereClause))
4573  return true;
4574  }
4575  break;
4576  case T_OnConflictClause:
4577  {
4578  OnConflictClause *stmt = (OnConflictClause *) node;
4579 
4580  if (WALK(stmt->infer))
4581  return true;
4582  if (WALK(stmt->targetList))
4583  return true;
4584  if (WALK(stmt->whereClause))
4585  return true;
4586  }
4587  break;
4588  case T_CommonTableExpr:
4589  /* search_clause and cycle_clause are not interesting here */
4590  return WALK(((CommonTableExpr *) node)->ctequery);
4591  case T_JsonOutput:
4592  {
4593  JsonOutput *out = (JsonOutput *) node;
4594 
4595  if (WALK(out->typeName))
4596  return true;
4597  if (WALK(out->returning))
4598  return true;
4599  }
4600  break;
4601  case T_JsonKeyValue:
4602  {
4603  JsonKeyValue *jkv = (JsonKeyValue *) node;
4604 
4605  if (WALK(jkv->key))
4606  return true;
4607  if (WALK(jkv->value))
4608  return true;
4609  }
4610  break;
4611  case T_JsonObjectConstructor:
4612  {
4613  JsonObjectConstructor *joc = (JsonObjectConstructor *) node;
4614 
4615  if (WALK(joc->output))
4616  return true;
4617  if (WALK(joc->exprs))
4618  return true;
4619  }
4620  break;
4621  case T_JsonArrayConstructor:
4622  {
4623  JsonArrayConstructor *jac = (JsonArrayConstructor *) node;
4624 
4625  if (WALK(jac->output))
4626  return true;
4627  if (WALK(jac->exprs))
4628  return true;
4629  }
4630  break;
4631  case T_JsonAggConstructor:
4632  {
4633  JsonAggConstructor *ctor = (JsonAggConstructor *) node;
4634 
4635  if (WALK(ctor->output))
4636  return true;
4637  if (WALK(ctor->agg_order))
4638  return true;
4639  if (WALK(ctor->agg_filter))
4640  return true;
4641  if (WALK(ctor->over))
4642  return true;
4643  }
4644  break;
4645  case T_JsonObjectAgg:
4646  {
4647  JsonObjectAgg *joa = (JsonObjectAgg *) node;
4648 
4649  if (WALK(joa->constructor))
4650  return true;
4651  if (WALK(joa->arg))
4652  return true;
4653  }
4654  break;
4655  case T_JsonArrayAgg:
4656  {
4657  JsonArrayAgg *jaa = (JsonArrayAgg *) node;
4658 
4659  if (WALK(jaa->constructor))
4660  return true;
4661  if (WALK(jaa->arg))
4662  return true;
4663  }
4664  break;
4665  case T_JsonArrayQueryConstructor:
4666  {
4667  JsonArrayQueryConstructor *jaqc = (JsonArrayQueryConstructor *) node;
4668 
4669  if (WALK(jaqc->output))
4670  return true;
4671  if (WALK(jaqc->query))
4672  return true;
4673  }
4674  break;
4675  default:
4676  elog(ERROR, "unrecognized node type: %d",
4677  (int) nodeTag(node));
4678  break;
4679  }
4680  return false;
4681 }
4682 
4683 /*
4684  * planstate_tree_walker --- walk plan state trees
4685  *
4686  * The walker has already visited the current node, and so we need only
4687  * recurse into any sub-nodes it has.
4688  */
4689 bool
4690 planstate_tree_walker_impl(PlanState *planstate,
4691  planstate_tree_walker_callback walker,
4692  void *context)
4693 {
4694  Plan *plan = planstate->plan;
4695  ListCell *lc;
4696 
4697  /* We don't need implicit coercions to Node here */
4698 #define PSWALK(n) walker(n, context)
4699 
4700  /* Guard against stack overflow due to overly complex plan trees */
4701  check_stack_depth();
4702 
4703  /* initPlan-s */
4704  if (planstate_walk_subplans(planstate->initPlan, walker, context))
4705  return true;
4706 
4707  /* lefttree */
4708  if (outerPlanState(planstate))
4709  {
4710  if (PSWALK(outerPlanState(planstate)))
4711  return true;
4712  }
4713 
4714  /* righttree */
4715  if (innerPlanState(planstate))
4716  {
4717  if (PSWALK(innerPlanState(planstate)))
4718  return true;
4719  }
4720 
4721  /* special child plans */
4722  switch (nodeTag(plan))
4723  {
4724  case T_Append:
4725  if (planstate_walk_members(((AppendState *) planstate)->appendplans,
4726  ((AppendState *) planstate)->as_nplans,
4727  walker, context))
4728  return true;
4729  break;
4730  case T_MergeAppend:
4731  if (planstate_walk_members(((MergeAppendState *) planstate)->mergeplans,
4732  ((MergeAppendState *) planstate)->ms_nplans,
4733  walker, context))
4734  return true;
4735  break;
4736  case T_BitmapAnd:
4737  if (planstate_walk_members(((BitmapAndState *) planstate)->bitmapplans,
4738  ((BitmapAndState *) planstate)->nplans,
4739  walker, context))
4740  return true;
4741  break;
4742  case T_BitmapOr:
4743  if (planstate_walk_members(((BitmapOrState *) planstate)->bitmapplans,
4744  ((BitmapOrState *) planstate)->nplans,
4745  walker, context))
4746  return true;
4747  break;
4748  case T_SubqueryScan:
4749  if (PSWALK(((SubqueryScanState *) planstate)->subplan))
4750  return true;
4751  break;
4752  case T_CustomScan:
4753  foreach(lc, ((CustomScanState *) planstate)->custom_ps)
4754  {
4755  if (PSWALK(lfirst(lc)))
4756  return true;
4757  }
4758  break;
4759  default:
4760  break;
4761  }
4762 
4763  /* subPlan-s */
4764  if (planstate_walk_subplans(planstate->subPlan, walker, context))
4765  return true;
4766 
4767  return false;
4768 }
4769 
4770 /*
4771  * Walk a list of SubPlans (or initPlans, which also use SubPlan nodes).
4772  */
4773 static bool
4774 planstate_walk_subplans(List *plans,
4775  planstate_tree_walker_callback walker,
4776  void *context)
4777 {
4778  ListCell *lc;
4779 
4780  foreach(lc, plans)
4781  {
4782  SubPlanState *sps = lfirst_node(SubPlanState, lc);
4783 
4784  if (PSWALK(sps->planstate))
4785  return true;
4786  }
4787 
4788  return false;
4789 }
4790 
4791 /*
4792  * Walk the constituent plans of a ModifyTable, Append, MergeAppend,
4793  * BitmapAnd, or BitmapOr node.
4794  */
4795 static bool
4796 planstate_walk_members(PlanState **planstates, int nplans,
4797  planstate_tree_walker_callback walker,
4798  void *context)
4799 {
4800  int j;
4801 
4802  for (j = 0; j < nplans; j++)
4803  {
4804  if (PSWALK(planstates[j]))
4805  return true;
4806  }
4807 
4808  return false;
4809 }
Min
#define Min(x, y)
Definition: c.h:1007
int32
signed int int32
Definition: c.h:497
Assert
#define Assert(condition)
Definition: c.h:861
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:778
errcode
int errcode(int sqlerrcode)
Definition: elog.c:853
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:1070
ERROR
#define ERROR
Definition: elog.h:39
elog
#define elog(elevel,...)
Definition: elog.h:225
ereport
#define ereport(elevel,...)
Definition: elog.h:149
outerPlanState
#define outerPlanState(node)
Definition: execnodes.h:1224
innerPlanState
#define innerPlanState(node)
Definition: execnodes.h:1223
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
stmt
#define stmt
Definition: indent_codes.h:59
val
long val
Definition: informix.c:689
j
int j
Definition: isn.c:74
if
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
lappend
List * lappend(List *list, void *datum)
Definition: list.c:339
list_copy
List * list_copy(const List *oldlist)
Definition: list.c:1573
getTypeOutputInfo
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:2907
get_opcode
RegProcedure get_opcode(Oid opno)
Definition: lsyscache.c:1285
getTypeInputInfo
void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
Definition: lsyscache.c:2874
get_promoted_array_type
Oid get_promoted_array_type(Oid typid)
Definition: lsyscache.c:2811
generate_unaccent_rules.args
args
Definition: generate_unaccent_rules.py:288
generate_unaccent_rules.action
action
Definition: generate_unaccent_rules.py:287
query_tree_walker_impl
bool query_tree_walker_impl(Query *query, tree_walker_callback walker, void *context, int flags)
Definition: nodeFuncs.c:2686
FLATCOPY
#define FLATCOPY(newnode, node, nodetype)
LIST_WALK
#define LIST_WALK(l)
raw_expression_tree_walker_impl
bool raw_expression_tree_walker_impl(Node *node, tree_walker_callback walker, void *context)
Definition: nodeFuncs.c:3978
query_or_expression_tree_mutator_impl
Node * query_or_expression_tree_mutator_impl(Node *node, tree_mutator_callback mutator, void *context, int flags)
Definition: nodeFuncs.c:3947
exprType
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
range_table_entry_walker_impl
bool range_table_entry_walker_impl(RangeTblEntry *rte, tree_walker_callback walker, void *context, int flags)
Definition: nodeFuncs.c:2810
query_tree_mutator_impl
Query * query_tree_mutator_impl(Query *query, tree_mutator_callback mutator, void *context, int flags)
Definition: nodeFuncs.c:3755
exprIsLengthCoercion
bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
Definition: nodeFuncs.c:552
exprSetCollation
void exprSetCollation(Node *expr, Oid collation)
Definition: nodeFuncs.c:1116
exprInputCollation
Oid exprInputCollation(const Node *expr)
Definition: nodeFuncs.c:1068
WALK
#define WALK(n)
expression_tree_mutator_impl
Node * expression_tree_mutator_impl(Node *node, tree_mutator_callback mutator, void *context)
Definition: nodeFuncs.c:2938
exprTypmod
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:298
planstate_walk_subplans
static bool planstate_walk_subplans(List *plans, planstate_tree_walker_callback walker, void *context)
Definition: nodeFuncs.c:4774
check_functions_in_node
bool check_functions_in_node(Node *node, check_function_callback checker, void *context)
Definition: nodeFuncs.c:1900
exprCollation
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:816
fix_opfuncids_walker
static bool fix_opfuncids_walker(Node *node, void *context)
Definition: nodeFuncs.c:1838
exprSetInputCollation
void exprSetInputCollation(Node *expr, Oid inputcollation)
Definition: nodeFuncs.c:1316
query_or_expression_tree_walker_impl
bool query_or_expression_tree_walker_impl(Node *node, tree_walker_callback walker, void *context, int flags)
Definition: nodeFuncs.c:3924
range_table_mutator_impl
List * range_table_mutator_impl(List *rtable, tree_mutator_callback mutator, void *context, int flags)
Definition: nodeFuncs.c:3846
applyRelabelType
Node * applyRelabelType(Node *arg, Oid rtype, int32 rtypmod, Oid rcollid, CoercionForm rformat, int rlocation, bool overwrite_ok)
Definition: nodeFuncs.c:631
expression_tree_walker_impl
bool expression_tree_walker_impl(Node *node, tree_walker_callback walker, void *context)
Definition: nodeFuncs.c:2083
range_table_walker_impl
bool range_table_walker_impl(List *rtable, tree_walker_callback walker, void *context, int flags)
Definition: nodeFuncs.c:2789
MUTATE
#define MUTATE(newfield, oldfield, fieldtype)
PSWALK
#define PSWALK(n)
leftmostLoc
static int leftmostLoc(int loc1, int loc2)
Definition: nodeFuncs.c:1810
relabel_to_typmod
Node * relabel_to_typmod(Node *expr, int32 typmod)
Definition: nodeFuncs.c:684
exprLocation
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1380
strip_implicit_coercions
Node * strip_implicit_coercions(Node *node)
Definition: nodeFuncs.c:700
expression_returns_set
bool expression_returns_set(Node *clause)
Definition: nodeFuncs.c:758
planstate_tree_walker_impl
bool planstate_tree_walker_impl(PlanState *planstate, planstate_tree_walker_callback walker, void *context)
Definition: nodeFuncs.c:4690
fix_opfuncids
void fix_opfuncids(Node *node)
Definition: nodeFuncs.c:1831
expression_returns_set_walker
static bool expression_returns_set_walker(Node *node, void *context)
Definition: nodeFuncs.c:764
set_sa_opfuncid
void set_sa_opfuncid(ScalarArrayOpExpr *opexpr)
Definition: nodeFuncs.c:1873
planstate_walk_members
static bool planstate_walk_members(PlanState **planstates, int nplans, planstate_tree_walker_callback walker, void *context)
Definition: nodeFuncs.c:4796
set_opfuncid
void set_opfuncid(OpExpr *opexpr)
Definition: nodeFuncs.c:1862
QTW_DONT_COPY_QUERY
#define QTW_DONT_COPY_QUERY
Definition: nodeFuncs.h:29
QTW_IGNORE_CTE_SUBQUERIES
#define QTW_IGNORE_CTE_SUBQUERIES
Definition: nodeFuncs.h:23
QTW_IGNORE_RT_SUBQUERIES
#define QTW_IGNORE_RT_SUBQUERIES
Definition: nodeFuncs.h:22
range_table_walker
#define range_table_walker(rt, w, c, f)
Definition: nodeFuncs.h:163
planstate_tree_walker_callback
bool(* planstate_tree_walker_callback)(struct PlanState *planstate, void *context)
Definition: nodeFuncs.h:39
query_tree_walker
#define query_tree_walker(q, w, c, f)
Definition: nodeFuncs.h:158
range_table_entry_walker
#define range_table_entry_walker(r, w, c, f)
Definition: nodeFuncs.h:168
QTW_EXAMINE_RTES_AFTER
#define QTW_EXAMINE_RTES_AFTER
Definition: nodeFuncs.h:28
QTW_EXAMINE_SORTGROUP
#define QTW_EXAMINE_SORTGROUP
Definition: nodeFuncs.h:30
tree_walker_callback
bool(* tree_walker_callback)(Node *node, void *context)
Definition: nodeFuncs.h:38
tree_mutator_callback
Node *(* tree_mutator_callback)(Node *node, void *context)
Definition: nodeFuncs.h:43
QTW_IGNORE_GROUPEXPRS
#define QTW_IGNORE_GROUPEXPRS
Definition: nodeFuncs.h:32
expression_tree_walker
#define expression_tree_walker(n, w, c)
Definition: nodeFuncs.h:153
query_tree_mutator
#define query_tree_mutator(q, m, c, f)
Definition: nodeFuncs.h:160
check_function_callback
bool(* check_function_callback)(Oid func_id, void *context)
Definition: nodeFuncs.h:35
QTW_EXAMINE_RTES_BEFORE
#define QTW_EXAMINE_RTES_BEFORE
Definition: nodeFuncs.h:27
range_table_mutator
#define range_table_mutator(rt, m, c, f)
Definition: nodeFuncs.h:165
QTW_IGNORE_RANGE_TABLE
#define QTW_IGNORE_RANGE_TABLE
Definition: nodeFuncs.h:26
QTW_IGNORE_JOINALIASES
#define QTW_IGNORE_JOINALIASES
Definition: nodeFuncs.h:25
IsA
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
copyObject
#define copyObject(obj)
Definition: nodes.h:224
nodeTag
#define nodeTag(nodeptr)
Definition: nodes.h:133
makeNode
#define makeNode(_type_)
Definition: nodes.h:155
RTE_JOIN
@ RTE_JOIN
Definition: parsenodes.h:1019
RTE_CTE
@ RTE_CTE
Definition: parsenodes.h:1023
RTE_NAMEDTUPLESTORE
@ RTE_NAMEDTUPLESTORE
Definition: parsenodes.h:1024
RTE_VALUES
@ RTE_VALUES
Definition: parsenodes.h:1022
RTE_SUBQUERY
@ RTE_SUBQUERY
Definition: parsenodes.h:1018
RTE_RESULT
@ RTE_RESULT
Definition: parsenodes.h:1025
RTE_FUNCTION
@ RTE_FUNCTION
Definition: parsenodes.h:1020
RTE_TABLEFUNC
@ RTE_TABLEFUNC
Definition: parsenodes.h:1021
RTE_GROUP
@ RTE_GROUP
Definition: parsenodes.h:1028
RTE_RELATION
@ RTE_RELATION
Definition: parsenodes.h:1017
arg
void * arg
Definition: pg_backup_utils.c:27
format
static char format
Definition: pg_basebackup.c:133
pg_collation.h
lfirst
#define lfirst(lc)
Definition: pg_list.h:172
lfirst_node
#define lfirst_node(type, lc)
Definition: pg_list.h:176
list_length
static int list_length(const List *l)
Definition: pg_list.h:152
linitial_node
#define linitial_node(type, l)
Definition: pg_list.h:181
NIL
#define NIL
Definition: pg_list.h:68
for_each_from
#define for_each_from(cell, lst, N)
Definition: pg_list.h:414
linitial
#define linitial(l)
Definition: pg_list.h:178
lsecond
#define lsecond(l)
Definition: pg_list.h:183
lfirst_oid
#define lfirst_oid(lc)
Definition: pg_list.h:174
plan
#define plan(x)
Definition: pg_regress.c:162
source
static rewind_source * source
Definition: pg_rewind.c:89
pg_type.h
check_stack_depth
void check_stack_depth(void)
Definition: postgres.c:3564
DatumGetInt32
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:202
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:36
Oid
unsigned int Oid
Definition: postgres_ext.h:31
c
char * c
Definition: preproc-cursor.c:31
e
e
Definition: preproc-init.c:82
fc
static int fc(const char *x)
Definition: preproc-init.c:99
ARRAY_SUBLINK
@ ARRAY_SUBLINK
Definition: primnodes.h:1003
MULTIEXPR_SUBLINK
@ MULTIEXPR_SUBLINK
Definition: primnodes.h:1002
EXPR_SUBLINK
@ EXPR_SUBLINK
Definition: primnodes.h:1001
IS_DOCUMENT
@ IS_DOCUMENT
Definition: primnodes.h:1587
IS_XMLSERIALIZE
@ IS_XMLSERIALIZE
Definition: primnodes.h:1586
CoercionForm
CoercionForm
Definition: primnodes.h:733
COERCE_IMPLICIT_CAST
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:736
COERCE_EXPLICIT_CAST
@ COERCE_EXPLICIT_CAST
Definition: primnodes.h:735
context
tree context
Definition: radixtree.h:1835
A_ArrayExpr
Definition: parsenodes.h:492
A_Const
Definition: parsenodes.h:360
A_Expr
Definition: parsenodes.h:332
A_Expr::location
ParseLoc location
Definition: parsenodes.h:340
A_Expr::lexpr
Node * lexpr
Definition: parsenodes.h:338
A_Expr::rexpr
Node * rexpr
Definition: parsenodes.h:339
A_Indices
Definition: parsenodes.h:459
A_Indices::uidx
Node * uidx
Definition: parsenodes.h:463
A_Indices::lidx
Node * lidx
Definition: parsenodes.h:462
A_Indirection
Definition: parsenodes.h:482
A_Indirection::arg
Node * arg
Definition: parsenodes.h:484
A_Indirection::indirection
List * indirection
Definition: parsenodes.h:485
Aggref::aggfnoid
Oid aggfnoid
Definition: primnodes.h:444
Aggref::aggdistinct
List * aggdistinct
Definition: primnodes.h:474
Aggref::aggdirectargs
List * aggdirectargs
Definition: primnodes.h:465
Aggref::args
List * args
Definition: primnodes.h:468
Aggref::aggfilter
Expr * aggfilter
Definition: primnodes.h:477
Aggref::aggorder
List * aggorder
Definition: primnodes.h:471
AppendRelInfo::translated_vars
List * translated_vars
Definition: pathnodes.h:3004
ArrayCoerceExpr::location
ParseLoc location
Definition: primnodes.h:1242
ArrayExpr::elements
List * elements
Definition: primnodes.h:1380
BoolExpr::args
List * args
Definition: primnodes.h:940
BoolExpr::location
ParseLoc location
Definition: primnodes.h:941
BooleanTest::location
ParseLoc location
Definition: primnodes.h:1980
BooleanTest::arg
Expr * arg
Definition: primnodes.h:1978
CTECycleClause::cycle_mark_default
Node * cycle_mark_default
Definition: parsenodes.h:1657
CTECycleClause::cycle_mark_value
Node * cycle_mark_value
Definition: parsenodes.h:1656
CaseExpr::arg
Expr * arg
Definition: primnodes.h:1313
CaseExpr::defresult
Expr * defresult
Definition: primnodes.h:1315
CaseExpr::args
List * args
Definition: primnodes.h:1314
CaseWhen::result
Expr * result
Definition: primnodes.h:1326
CaseWhen::expr
Expr * expr
Definition: primnodes.h:1325
CoalesceExpr::args
List * args
Definition: primnodes.h:1492
CoerceToDomain::location
ParseLoc location
Definition: primnodes.h:2032
CoerceViaIO::arg
Expr * arg
Definition: primnodes.h:1207
CoerceViaIO::location
ParseLoc location
Definition: primnodes.h:1214
CoerceViaIO::resulttype
Oid resulttype
Definition: primnodes.h:1208
CollateExpr::arg
Expr * arg
Definition: primnodes.h:1279
ColumnDef::collClause
CollateClause * collClause
Definition: parsenodes.h:743
ColumnDef::typeName
TypeName * typeName
Definition: parsenodes.h:729
ColumnDef::raw_default
Node * raw_default
Definition: parsenodes.h:737
Const::consttype
Oid consttype
Definition: primnodes.h:312
FieldSelect::arg
Expr * arg
Definition: primnodes.h:1128
FieldStore::newvals
List * newvals
Definition: primnodes.h:1160
FieldStore::arg
Expr * arg
Definition: primnodes.h:1159
FromExpr::quals
Node * quals
Definition: primnodes.h:2305
FromExpr::fromlist
List * fromlist
Definition: primnodes.h:2304
FuncCall::agg_filter
Node * agg_filter
Definition: parsenodes.h:431
FuncCall::agg_order
List * agg_order
Definition: parsenodes.h:430
FuncCall::args
List * args
Definition: parsenodes.h:429
FuncCall::over
struct WindowDef * over
Definition: parsenodes.h:432
FuncExpr::location
ParseLoc location
Definition: primnodes.h:770
FuncExpr::funcid
Oid funcid
Definition: primnodes.h:750
FuncExpr::args
List * args
Definition: primnodes.h:768
IndexClause::indexquals
List * indexquals
Definition: pathnodes.h:1766
IndexClause::rinfo
struct RestrictInfo * rinfo
Definition: pathnodes.h:1765
IndexElem::expr
Node * expr
Definition: parsenodes.h:786
IntoClause::rel
RangeVar * rel
Definition: primnodes.h:162
JoinExpr::quals
Node * quals
Definition: primnodes.h:2285
JoinExpr::larg
Node * larg
Definition: primnodes.h:2278
JoinExpr::rarg
Node * rarg
Definition: primnodes.h:2279
JsonAggConstructor::over
struct WindowDef * over
Definition: parsenodes.h:1967
JsonAggConstructor::output
JsonOutput * output
Definition: parsenodes.h:1964
JsonArrayAgg::arg
JsonValueExpr * arg
Definition: parsenodes.h:1992
JsonArrayAgg::constructor
JsonAggConstructor * constructor
Definition: parsenodes.h:1991
JsonArrayConstructor::output
JsonOutput * output
Definition: parsenodes.h:1937
JsonBehavior::expr
Node * expr
Definition: primnodes.h:1787
JsonConstructorExpr::returning
JsonReturning * returning
Definition: primnodes.h:1706
JsonExpr::formatted_expr
Node * formatted_expr
Definition: primnodes.h:1819
JsonExpr::location
ParseLoc location
Definition: primnodes.h:1855
JsonExpr::passing_values
List * passing_values
Definition: primnodes.h:1832
JsonExpr::on_empty
JsonBehavior * on_empty
Definition: primnodes.h:1835
JsonExpr::path_spec
Node * path_spec
Definition: primnodes.h:1825
JsonExpr::collation
Oid collation
Definition: primnodes.h:1852
JsonExpr::returning
JsonReturning * returning
Definition: primnodes.h:1828
JsonExpr::on_error
JsonBehavior * on_error
Definition: primnodes.h:1836
JsonFuncExpr::output
JsonOutput * output
Definition: parsenodes.h:1793
JsonFuncExpr::passing
List * passing
Definition: parsenodes.h:1792
JsonFuncExpr::on_empty
JsonBehavior * on_empty
Definition: parsenodes.h:1794
JsonFuncExpr::pathspec
Node * pathspec
Definition: parsenodes.h:1791
JsonFuncExpr::on_error
JsonBehavior * on_error
Definition: parsenodes.h:1795
JsonFuncExpr::context_item
JsonValueExpr * context_item
Definition: parsenodes.h:1790
JsonIsPredicate::format
JsonFormat * format
Definition: primnodes.h:1732
JsonKeyValue::value
JsonValueExpr * value
Definition: parsenodes.h:1875
JsonObjectAgg::constructor
JsonAggConstructor * constructor
Definition: parsenodes.h:1978
JsonObjectAgg::arg
JsonKeyValue * arg
Definition: parsenodes.h:1979
JsonObjectConstructor::output
JsonOutput * output
Definition: parsenodes.h:1923
JsonOutput::returning
JsonReturning * returning
Definition: parsenodes.h:1754
JsonOutput::typeName
TypeName * typeName
Definition: parsenodes.h:1753
JsonParseExpr::expr
JsonValueExpr * expr
Definition: parsenodes.h:1885
JsonParseExpr::output
JsonOutput * output
Definition: parsenodes.h:1886
JsonReturning::format
JsonFormat * format
Definition: primnodes.h:1663
JsonScalarExpr::output
JsonOutput * output
Definition: parsenodes.h:1899
JsonSerializeExpr::output
JsonOutput * output
Definition: parsenodes.h:1911
JsonSerializeExpr::expr
JsonValueExpr * expr
Definition: parsenodes.h:1910
JsonTableColumn::on_empty
JsonBehavior * on_empty
Definition: parsenodes.h:1861
JsonTableColumn::on_error
JsonBehavior * on_error
Definition: parsenodes.h:1862
JsonTableColumn::typeName
TypeName * typeName
Definition: parsenodes.h:1855
JsonTable::on_error
JsonBehavior * on_error
Definition: parsenodes.h:1827
JsonTable::columns
List * columns
Definition: parsenodes.h:1826
JsonTable::pathspec
JsonTablePathSpec * pathspec
Definition: parsenodes.h:1824
JsonTable::passing
List * passing
Definition: parsenodes.h:1825
JsonTable::context_item
JsonValueExpr * context_item
Definition: parsenodes.h:1823
JsonValueExpr::formatted_expr
Expr * formatted_expr
Definition: primnodes.h:1680
JsonValueExpr::format
JsonFormat * format
Definition: primnodes.h:1681
JsonValueExpr::raw_expr
Expr * raw_expr
Definition: primnodes.h:1679
List
Definition: pg_list.h:54
MergeAction::qual
Node * qual
Definition: primnodes.h:2006
MergeAction::targetList
List * targetList
Definition: primnodes.h:2007
MinMaxExpr::args
List * args
Definition: primnodes.h:1518
NamedArgExpr::arg
Expr * arg
Definition: primnodes.h:791
NamedArgExpr::location
ParseLoc location
Definition: primnodes.h:797
Node
Definition: nodes.h:129
NullTest::location
ParseLoc location
Definition: primnodes.h:1958
NullTest::arg
Expr * arg
Definition: primnodes.h:1954
OnConflictExpr::arbiterElems
List * arbiterElems
Definition: primnodes.h:2323
OnConflictExpr::onConflictSet
List * onConflictSet
Definition: primnodes.h:2329
OnConflictExpr::exclRelTlist
List * exclRelTlist
Definition: primnodes.h:2332
OnConflictExpr::onConflictWhere
Node * onConflictWhere
Definition: primnodes.h:2330
OnConflictExpr::arbiterWhere
Node * arbiterWhere
Definition: primnodes.h:2325
OpExpr::opno
Oid opno
Definition: primnodes.h:818
OpExpr::args
List * args
Definition: primnodes.h:836
OpExpr::location
ParseLoc location
Definition: primnodes.h:839
PlaceHolderInfo::ph_var
PlaceHolderVar * ph_var
Definition: pathnodes.h:3092
PlanState::plan
Plan * plan
Definition: execnodes.h:1128
PlanState::subPlan
List * subPlan
Definition: execnodes.h:1155
PlanState::initPlan
List * initPlan
Definition: execnodes.h:1153
Query::mergeJoinCondition
Node * mergeJoinCondition
Definition: parsenodes.h:191
Query::limitCount
Node * limitCount
Definition: parsenodes.h:216
Query::jointree
FromExpr * jointree
Definition: parsenodes.h:177
Query::returningList
List * returningList
Definition: parsenodes.h:200
Query::setOperations
Node * setOperations
Definition: parsenodes.h:221
Query::cteList
List * cteList
Definition: parsenodes.h:168
Query::onConflict
OnConflictExpr * onConflict
Definition: parsenodes.h:198
Query::groupClause
List * groupClause
Definition: parsenodes.h:202
Query::havingQual
Node * havingQual
Definition: parsenodes.h:207
Query::rtable
List * rtable
Definition: parsenodes.h:170
Query::limitOffset
Node * limitOffset
Definition: parsenodes.h:215
Query::mergeActionList
List * mergeActionList
Definition: parsenodes.h:180
Query::windowClause
List * windowClause
Definition: parsenodes.h:209
Query::targetList
List * targetList
Definition: parsenodes.h:193
Query::distinctClause
List * distinctClause
Definition: parsenodes.h:211
Query::sortClause
List * sortClause
Definition: parsenodes.h:213
RangeFunction::alias
Alias * alias
Definition: parsenodes.h:646
RangeFunction::coldeflist
List * coldeflist
Definition: parsenodes.h:647
RangeFunction::functions
List * functions
Definition: parsenodes.h:645
RangeSubselect::subquery
Node * subquery
Definition: parsenodes.h:621
RangeSubselect::alias
Alias * alias
Definition: parsenodes.h:622
RangeTableFunc::namespaces
List * namespaces
Definition: parsenodes.h:663
RangeTableFunc::docexpr
Node * docexpr
Definition: parsenodes.h:661
RangeTableFunc::rowexpr
Node * rowexpr
Definition: parsenodes.h:662
RangeTableFunc::columns
List * columns
Definition: parsenodes.h:664
RangeTableFunc::alias
Alias * alias
Definition: parsenodes.h:665
RangeTblEntry::tablefunc
TableFunc * tablefunc
Definition: parsenodes.h:1184
RangeTblEntry::tablesample
struct TableSampleClause * tablesample
Definition: parsenodes.h:1098
RangeTblEntry::subquery
Query * subquery
Definition: parsenodes.h:1104
RangeTblEntry::values_lists
List * values_lists
Definition: parsenodes.h:1190
RangeTblEntry::functions
List * functions
Definition: parsenodes.h:1177
RangeTblEntry::rtekind
RTEKind rtekind
Definition: parsenodes.h:1047
RelabelType::resulttype
Oid resulttype
Definition: primnodes.h:1185
RelabelType::location
ParseLoc location
Definition: primnodes.h:1192
RelabelType::arg
Expr * arg
Definition: primnodes.h:1184
ResTarget::val
Node * val
Definition: parsenodes.h:521
ResTarget::indirection
List * indirection
Definition: parsenodes.h:520
RowExpr::args
List * args
Definition: primnodes.h:1411