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