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