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