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 31964770 : exprType(const Node *expr)
43 : {
44 : Oid type;
45 :
46 31964770 : if (!expr)
47 462 : return InvalidOid;
48 :
49 31964308 : switch (nodeTag(expr))
50 : {
51 17357668 : case T_Var:
52 17357668 : type = ((const Var *) expr)->vartype;
53 17357668 : break;
54 4671340 : case T_Const:
55 4671340 : type = ((const Const *) expr)->consttype;
56 4671340 : break;
57 3018256 : case T_Param:
58 3018256 : type = ((const Param *) expr)->paramtype;
59 3018256 : break;
60 325348 : case T_Aggref:
61 325348 : type = ((const Aggref *) expr)->aggtype;
62 325348 : break;
63 2366 : case T_GroupingFunc:
64 2366 : type = INT4OID;
65 2366 : break;
66 20926 : case T_WindowFunc:
67 20926 : type = ((const WindowFunc *) expr)->wintype;
68 20926 : break;
69 1060 : case T_MergeSupportFunc:
70 1060 : type = ((const MergeSupportFunc *) expr)->msftype;
71 1060 : break;
72 137644 : case T_SubscriptingRef:
73 137644 : type = ((const SubscriptingRef *) expr)->refrestype;
74 137644 : break;
75 2139860 : case T_FuncExpr:
76 2139860 : type = ((const FuncExpr *) expr)->funcresulttype;
77 2139860 : break;
78 94214 : case T_NamedArgExpr:
79 94214 : type = exprType((Node *) ((const NamedArgExpr *) expr)->arg);
80 94214 : break;
81 1524058 : case T_OpExpr:
82 1524058 : type = ((const OpExpr *) expr)->opresulttype;
83 1524058 : break;
84 2366 : case T_DistinctExpr:
85 2366 : type = ((const DistinctExpr *) expr)->opresulttype;
86 2366 : break;
87 1856 : case T_NullIfExpr:
88 1856 : type = ((const NullIfExpr *) expr)->opresulttype;
89 1856 : break;
90 114192 : case T_ScalarArrayOpExpr:
91 114192 : type = BOOLOID;
92 114192 : break;
93 329732 : case T_BoolExpr:
94 329732 : type = BOOLOID;
95 329732 : break;
96 111798 : case T_SubLink:
97 : {
98 111798 : const SubLink *sublink = (const SubLink *) expr;
99 :
100 111798 : if (sublink->subLinkType == EXPR_SUBLINK ||
101 43012 : sublink->subLinkType == ARRAY_SUBLINK)
102 86936 : {
103 : /* get the type of the subselect's first target column */
104 86936 : Query *qtree = (Query *) sublink->subselect;
105 : TargetEntry *tent;
106 :
107 86936 : if (!qtree || !IsA(qtree, Query))
108 0 : elog(ERROR, "cannot get type for untransformed sublink");
109 86936 : tent = linitial_node(TargetEntry, qtree->targetList);
110 : Assert(!tent->resjunk);
111 86936 : type = exprType((Node *) tent->expr);
112 86936 : if (sublink->subLinkType == ARRAY_SUBLINK)
113 : {
114 18150 : type = get_promoted_array_type(type);
115 18150 : 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 24862 : else if (sublink->subLinkType == MULTIEXPR_SUBLINK)
123 : {
124 : /* MULTIEXPR is always considered to return RECORD */
125 138 : type = RECORDOID;
126 : }
127 : else
128 : {
129 : /* for all other sublink types, result is boolean */
130 24724 : type = BOOLOID;
131 : }
132 : }
133 111798 : break;
134 53562 : case T_SubPlan:
135 : {
136 53562 : const SubPlan *subplan = (const SubPlan *) expr;
137 :
138 53562 : if (subplan->subLinkType == EXPR_SUBLINK ||
139 4340 : subplan->subLinkType == ARRAY_SUBLINK)
140 : {
141 : /* get the type of the subselect's first target column */
142 49558 : type = subplan->firstColType;
143 49558 : if (subplan->subLinkType == ARRAY_SUBLINK)
144 : {
145 336 : type = get_promoted_array_type(type);
146 336 : 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 4004 : else if (subplan->subLinkType == MULTIEXPR_SUBLINK)
154 : {
155 : /* MULTIEXPR is always considered to return RECORD */
156 180 : type = RECORDOID;
157 : }
158 : else
159 : {
160 : /* for all other subplan types, result is boolean */
161 3824 : type = BOOLOID;
162 : }
163 : }
164 53562 : break;
165 1540 : case T_AlternativeSubPlan:
166 : {
167 1540 : const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;
168 :
169 : /* subplans should all return the same thing */
170 1540 : type = exprType((Node *) linitial(asplan->subplans));
171 : }
172 1540 : break;
173 42096 : case T_FieldSelect:
174 42096 : type = ((const FieldSelect *) expr)->resulttype;
175 42096 : break;
176 1126 : case T_FieldStore:
177 1126 : type = ((const FieldStore *) expr)->resulttype;
178 1126 : break;
179 664346 : case T_RelabelType:
180 664346 : type = ((const RelabelType *) expr)->resulttype;
181 664346 : break;
182 157576 : case T_CoerceViaIO:
183 157576 : type = ((const CoerceViaIO *) expr)->resulttype;
184 157576 : break;
185 17768 : case T_ArrayCoerceExpr:
186 17768 : type = ((const ArrayCoerceExpr *) expr)->resulttype;
187 17768 : break;
188 2452 : case T_ConvertRowtypeExpr:
189 2452 : type = ((const ConvertRowtypeExpr *) expr)->resulttype;
190 2452 : break;
191 11036 : case T_CollateExpr:
192 11036 : type = exprType((Node *) ((const CollateExpr *) expr)->arg);
193 11036 : break;
194 406530 : case T_CaseExpr:
195 406530 : type = ((const CaseExpr *) expr)->casetype;
196 406530 : break;
197 41432 : case T_CaseTestExpr:
198 41432 : type = ((const CaseTestExpr *) expr)->typeId;
199 41432 : break;
200 108466 : case T_ArrayExpr:
201 108466 : type = ((const ArrayExpr *) expr)->array_typeid;
202 108466 : break;
203 15406 : case T_RowExpr:
204 15406 : type = ((const RowExpr *) expr)->row_typeid;
205 15406 : break;
206 444 : case T_RowCompareExpr:
207 444 : type = BOOLOID;
208 444 : break;
209 25746 : case T_CoalesceExpr:
210 25746 : type = ((const CoalesceExpr *) expr)->coalescetype;
211 25746 : break;
212 6366 : case T_MinMaxExpr:
213 6366 : type = ((const MinMaxExpr *) expr)->minmaxtype;
214 6366 : break;
215 11446 : case T_SQLValueFunction:
216 11446 : type = ((const SQLValueFunction *) expr)->type;
217 11446 : break;
218 26016 : case T_XmlExpr:
219 26016 : if (((const XmlExpr *) expr)->op == IS_DOCUMENT)
220 102 : type = BOOLOID;
221 25914 : else if (((const XmlExpr *) expr)->op == IS_XMLSERIALIZE)
222 918 : type = TEXTOID;
223 : else
224 24996 : type = XMLOID;
225 26016 : break;
226 1542 : case T_JsonValueExpr:
227 : {
228 1542 : const JsonValueExpr *jve = (const JsonValueExpr *) expr;
229 :
230 1542 : type = exprType((Node *) jve->formatted_expr);
231 : }
232 1542 : break;
233 6918 : case T_JsonConstructorExpr:
234 6918 : type = ((const JsonConstructorExpr *) expr)->returning->typid;
235 6918 : break;
236 1546 : case T_JsonIsPredicate:
237 1546 : type = BOOLOID;
238 1546 : break;
239 9962 : case T_JsonExpr:
240 : {
241 9962 : const JsonExpr *jexpr = (const JsonExpr *) expr;
242 :
243 9962 : type = jexpr->returning->typid;
244 9962 : break;
245 : }
246 4714 : case T_JsonBehavior:
247 : {
248 4714 : const JsonBehavior *behavior = (const JsonBehavior *) expr;
249 :
250 4714 : type = exprType(behavior->expr);
251 4714 : break;
252 : }
253 45986 : case T_NullTest:
254 45986 : type = BOOLOID;
255 45986 : break;
256 3240 : case T_BooleanTest:
257 3240 : type = BOOLOID;
258 3240 : break;
259 298478 : case T_CoerceToDomain:
260 298478 : type = ((const CoerceToDomain *) expr)->resulttype;
261 298478 : break;
262 2210 : case T_CoerceToDomainValue:
263 2210 : type = ((const CoerceToDomainValue *) expr)->typeId;
264 2210 : break;
265 120528 : case T_SetToDefault:
266 120528 : type = ((const SetToDefault *) expr)->typeId;
267 120528 : break;
268 254 : case T_CurrentOfExpr:
269 254 : type = BOOLOID;
270 254 : break;
271 1626 : case T_NextValueExpr:
272 1626 : type = ((const NextValueExpr *) expr)->typeId;
273 1626 : 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 864 : case T_ReturningExpr:
282 864 : type = exprType((Node *) ((const ReturningExpr *) expr)->retexpr);
283 864 : break;
284 20402 : case T_PlaceHolderVar:
285 20402 : type = exprType((Node *) ((const PlaceHolderVar *) expr)->phexpr);
286 20402 : 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 31964308 : 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 11321980 : exprTypmod(const Node *expr)
302 : {
303 11321980 : if (!expr)
304 0 : return -1;
305 :
306 11321980 : switch (nodeTag(expr))
307 : {
308 6801980 : case T_Var:
309 6801980 : return ((const Var *) expr)->vartypmod;
310 1713670 : case T_Const:
311 1713670 : return ((const Const *) expr)->consttypmod;
312 150140 : case T_Param:
313 150140 : return ((const Param *) expr)->paramtypmod;
314 41090 : case T_SubscriptingRef:
315 41090 : return ((const SubscriptingRef *) expr)->reftypmod;
316 1315226 : case T_FuncExpr:
317 : {
318 : int32 coercedTypmod;
319 :
320 : /* Be smart about length-coercion functions... */
321 1315226 : if (exprIsLengthCoercion(expr, &coercedTypmod))
322 25608 : return coercedTypmod;
323 : }
324 1289618 : break;
325 0 : case T_NamedArgExpr:
326 0 : return exprTypmod((Node *) ((const NamedArgExpr *) expr)->arg);
327 390 : 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 390 : const NullIfExpr *nexpr = (const NullIfExpr *) expr;
334 :
335 390 : return exprTypmod((Node *) linitial(nexpr->args));
336 : }
337 : break;
338 7256 : case T_SubLink:
339 : {
340 7256 : const SubLink *sublink = (const SubLink *) expr;
341 :
342 7256 : if (sublink->subLinkType == EXPR_SUBLINK ||
343 754 : sublink->subLinkType == ARRAY_SUBLINK)
344 : {
345 : /* get the typmod of the subselect's first target column */
346 7166 : Query *qtree = (Query *) sublink->subselect;
347 : TargetEntry *tent;
348 :
349 7166 : if (!qtree || !IsA(qtree, Query))
350 0 : elog(ERROR, "cannot get type for untransformed sublink");
351 7166 : tent = linitial_node(TargetEntry, qtree->targetList);
352 : Assert(!tent->resjunk);
353 7166 : 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 90 : break;
359 37468 : case T_SubPlan:
360 : {
361 37468 : const SubPlan *subplan = (const SubPlan *) expr;
362 :
363 37468 : if (subplan->subLinkType == EXPR_SUBLINK ||
364 2328 : 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 35374 : return subplan->firstColTypmod;
369 : }
370 : /* otherwise, result is RECORD or BOOLEAN, typmod is -1 */
371 : }
372 2094 : break;
373 776 : case T_AlternativeSubPlan:
374 : {
375 776 : const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;
376 :
377 : /* subplans should all return the same thing */
378 776 : return exprTypmod((Node *) linitial(asplan->subplans));
379 : }
380 : break;
381 17738 : case T_FieldSelect:
382 17738 : return ((const FieldSelect *) expr)->resulttypmod;
383 233242 : case T_RelabelType:
384 233242 : return ((const RelabelType *) expr)->resulttypmod;
385 8370 : case T_ArrayCoerceExpr:
386 8370 : return ((const ArrayCoerceExpr *) expr)->resulttypmod;
387 200 : case T_CollateExpr:
388 200 : return exprTypmod((Node *) ((const CollateExpr *) expr)->arg);
389 191846 : case T_CaseExpr:
390 : {
391 : /*
392 : * If all the alternatives agree on type/typmod, return that
393 : * typmod, else use -1
394 : */
395 191846 : const CaseExpr *cexpr = (const CaseExpr *) expr;
396 191846 : Oid casetype = cexpr->casetype;
397 : int32 typmod;
398 : ListCell *arg;
399 :
400 191846 : if (!cexpr->defresult)
401 0 : return -1;
402 191846 : if (exprType((Node *) cexpr->defresult) != casetype)
403 0 : return -1;
404 191846 : typmod = exprTypmod((Node *) cexpr->defresult);
405 191846 : if (typmod < 0)
406 191846 : 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 13866 : case T_CaseTestExpr:
420 13866 : return ((const CaseTestExpr *) expr)->typeMod;
421 40174 : case T_ArrayExpr:
422 : {
423 : /*
424 : * If all the elements agree on type/typmod, return that
425 : * typmod, else use -1
426 : */
427 40174 : const ArrayExpr *arrayexpr = (const ArrayExpr *) expr;
428 : Oid commontype;
429 : int32 typmod;
430 : ListCell *elem;
431 :
432 40174 : if (arrayexpr->elements == NIL)
433 202 : return -1;
434 39972 : typmod = exprTypmod((Node *) linitial(arrayexpr->elements));
435 39972 : if (typmod < 0)
436 39936 : return -1; /* no point in trying harder */
437 36 : if (arrayexpr->multidims)
438 0 : commontype = arrayexpr->array_typeid;
439 : else
440 36 : commontype = arrayexpr->element_typeid;
441 126 : foreach(elem, arrayexpr->elements)
442 : {
443 90 : Node *e = (Node *) lfirst(elem);
444 :
445 90 : if (exprType(e) != commontype)
446 0 : return -1;
447 90 : if (exprTypmod(e) != typmod)
448 0 : return -1;
449 : }
450 36 : return typmod;
451 : }
452 : break;
453 7002 : case T_CoalesceExpr:
454 : {
455 : /*
456 : * If all the alternatives agree on type/typmod, return that
457 : * typmod, else use -1
458 : */
459 7002 : const CoalesceExpr *cexpr = (const CoalesceExpr *) expr;
460 7002 : Oid coalescetype = cexpr->coalescetype;
461 : int32 typmod;
462 : ListCell *arg;
463 :
464 7002 : if (exprType((Node *) linitial(cexpr->args)) != coalescetype)
465 0 : return -1;
466 7002 : typmod = exprTypmod((Node *) linitial(cexpr->args));
467 7002 : if (typmod < 0)
468 7002 : 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 3218 : case T_MinMaxExpr:
482 : {
483 : /*
484 : * If all the alternatives agree on type/typmod, return that
485 : * typmod, else use -1
486 : */
487 3218 : const MinMaxExpr *mexpr = (const MinMaxExpr *) expr;
488 3218 : Oid minmaxtype = mexpr->minmaxtype;
489 : int32 typmod;
490 : ListCell *arg;
491 :
492 3218 : if (exprType((Node *) linitial(mexpr->args)) != minmaxtype)
493 0 : return -1;
494 3218 : typmod = exprTypmod((Node *) linitial(mexpr->args));
495 3218 : if (typmod < 0)
496 3218 : 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 2280 : case T_SQLValueFunction:
510 2280 : return ((const SQLValueFunction *) expr)->typmod;
511 66 : case T_JsonValueExpr:
512 66 : return exprTypmod((Node *) ((const JsonValueExpr *) expr)->formatted_expr);
513 2496 : case T_JsonConstructorExpr:
514 2496 : return ((const JsonConstructorExpr *) expr)->returning->typmod;
515 3644 : case T_JsonExpr:
516 : {
517 3644 : const JsonExpr *jexpr = (const JsonExpr *) expr;
518 :
519 3644 : 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 228260 : case T_CoerceToDomain:
530 228260 : return ((const CoerceToDomain *) expr)->resulttypmod;
531 82 : case T_CoerceToDomainValue:
532 82 : return ((const CoerceToDomainValue *) expr)->typeMod;
533 31524 : case T_SetToDefault:
534 31524 : return ((const SetToDefault *) expr)->typeMod;
535 480 : case T_ReturningExpr:
536 480 : return exprTypmod((Node *) ((const ReturningExpr *) expr)->retexpr);
537 11438 : case T_PlaceHolderVar:
538 11438 : return exprTypmod((Node *) ((const PlaceHolderVar *) expr)->phexpr);
539 458058 : default:
540 458058 : break;
541 : }
542 1749860 : 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 1317010 : exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
558 : {
559 1317010 : if (coercedTypmod != NULL)
560 1317010 : *coercedTypmod = -1; /* default result on failure */
561 :
562 : /*
563 : * Scalar-type length coercions are FuncExprs, array-type length coercions
564 : * are ArrayCoerceExprs
565 : */
566 1317010 : if (expr && IsA(expr, FuncExpr))
567 : {
568 1317010 : 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 1317010 : if (func->funcformat != COERCE_EXPLICIT_CAST &&
576 1279800 : func->funcformat != COERCE_IMPLICIT_CAST)
577 1031184 : 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 285826 : nargs = list_length(func->args);
585 285826 : if (nargs < 2 || nargs > 3)
586 260130 : return false;
587 :
588 25696 : second_arg = (Const *) lsecond(func->args);
589 25696 : if (!IsA(second_arg, Const) ||
590 25696 : second_arg->consttype != INT4OID ||
591 25696 : second_arg->constisnull)
592 0 : return false;
593 :
594 : /*
595 : * OK, it is indeed a length-coercion function.
596 : */
597 25696 : if (coercedTypmod != NULL)
598 25696 : *coercedTypmod = DatumGetInt32(second_arg->constvalue);
599 :
600 25696 : 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 292604 : 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 295678 : while (arg && IsA(arg, RelabelType))
645 3074 : arg = (Node *) ((RelabelType *) arg)->arg;
646 :
647 292604 : if (arg && IsA(arg, Const))
648 : {
649 : /* Modify the Const directly to preserve const-flatness. */
650 116694 : Const *con = (Const *) arg;
651 :
652 116694 : if (!overwrite_ok)
653 14476 : con = copyObject(con);
654 116694 : con->consttype = rtype;
655 116694 : con->consttypmod = rtypmod;
656 116694 : con->constcollid = rcollid;
657 : /* We keep the Const's original location. */
658 116694 : return (Node *) con;
659 : }
660 182570 : else if (exprType(arg) == rtype &&
661 13236 : exprTypmod(arg) == rtypmod &&
662 6576 : exprCollation(arg) == rcollid)
663 : {
664 : /* Sometimes we find a nest of relabels that net out to nothing. */
665 3024 : return arg;
666 : }
667 : else
668 : {
669 : /* Nope, gotta have a RelabelType. */
670 172886 : RelabelType *newrelabel = makeNode(RelabelType);
671 :
672 172886 : newrelabel->arg = (Expr *) arg;
673 172886 : newrelabel->resulttype = rtype;
674 172886 : newrelabel->resulttypmod = rtypmod;
675 172886 : newrelabel->resultcollid = rcollid;
676 172886 : newrelabel->relabelformat = rformat;
677 172886 : newrelabel->location = rlocation;
678 172886 : 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 36 : relabel_to_typmod(Node *expr, int32 typmod)
690 : {
691 36 : 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 1086660 : strip_implicit_coercions(Node *node)
706 : {
707 1086660 : if (node == NULL)
708 0 : return NULL;
709 1086660 : if (IsA(node, FuncExpr))
710 : {
711 14470 : FuncExpr *f = (FuncExpr *) node;
712 :
713 14470 : if (f->funcformat == COERCE_IMPLICIT_CAST)
714 50 : return strip_implicit_coercions(linitial(f->args));
715 : }
716 1072190 : else if (IsA(node, RelabelType))
717 : {
718 12240 : RelabelType *r = (RelabelType *) node;
719 :
720 12240 : if (r->relabelformat == COERCE_IMPLICIT_CAST)
721 14 : return strip_implicit_coercions((Node *) r->arg);
722 : }
723 1059950 : else if (IsA(node, CoerceViaIO))
724 : {
725 612 : CoerceViaIO *c = (CoerceViaIO *) node;
726 :
727 612 : if (c->coerceformat == COERCE_IMPLICIT_CAST)
728 0 : return strip_implicit_coercions((Node *) c->arg);
729 : }
730 1059338 : 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 1059338 : 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 1059338 : else if (IsA(node, CoerceToDomain))
745 : {
746 9114 : CoerceToDomain *c = (CoerceToDomain *) node;
747 :
748 9114 : if (c->coercionformat == COERCE_IMPLICIT_CAST)
749 0 : return strip_implicit_coercions((Node *) c->arg);
750 : }
751 1086596 : 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 877482 : expression_returns_set(Node *clause)
764 : {
765 877482 : return expression_returns_set_walker(clause, NULL);
766 : }
767 :
768 : static bool
769 3763254 : expression_returns_set_walker(Node *node, void *context)
770 : {
771 3763254 : if (node == NULL)
772 37622 : return false;
773 3725632 : if (IsA(node, FuncExpr))
774 : {
775 102154 : FuncExpr *expr = (FuncExpr *) node;
776 :
777 102154 : if (expr->funcretset)
778 13640 : return true;
779 : /* else fall through to check args */
780 : }
781 3711992 : if (IsA(node, OpExpr))
782 : {
783 852926 : OpExpr *expr = (OpExpr *) node;
784 :
785 852926 : if (expr->opretset)
786 6 : 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 3711986 : if (IsA(node, Aggref))
798 1146 : return false;
799 3710840 : if (IsA(node, GroupingFunc))
800 60 : return false;
801 3710780 : if (IsA(node, WindowFunc))
802 30 : return false;
803 :
804 3710750 : 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 14487104 : exprCollation(const Node *expr)
822 : {
823 : Oid coll;
824 :
825 14487104 : if (!expr)
826 0 : return InvalidOid;
827 :
828 14487104 : switch (nodeTag(expr))
829 : {
830 11101574 : case T_Var:
831 11101574 : coll = ((const Var *) expr)->varcollid;
832 11101574 : break;
833 1970022 : case T_Const:
834 1970022 : coll = ((const Const *) expr)->constcollid;
835 1970022 : break;
836 188306 : case T_Param:
837 188306 : coll = ((const Param *) expr)->paramcollid;
838 188306 : break;
839 93950 : case T_Aggref:
840 93950 : coll = ((const Aggref *) expr)->aggcollid;
841 93950 : break;
842 724 : case T_GroupingFunc:
843 724 : coll = InvalidOid;
844 724 : break;
845 5448 : case T_WindowFunc:
846 5448 : coll = ((const WindowFunc *) expr)->wincollid;
847 5448 : break;
848 366 : case T_MergeSupportFunc:
849 366 : coll = ((const MergeSupportFunc *) expr)->msfcollid;
850 366 : break;
851 8610 : case T_SubscriptingRef:
852 8610 : coll = ((const SubscriptingRef *) expr)->refcollid;
853 8610 : break;
854 417356 : case T_FuncExpr:
855 417356 : coll = ((const FuncExpr *) expr)->funccollid;
856 417356 : break;
857 0 : case T_NamedArgExpr:
858 0 : coll = exprCollation((Node *) ((const NamedArgExpr *) expr)->arg);
859 0 : break;
860 113066 : case T_OpExpr:
861 113066 : coll = ((const OpExpr *) expr)->opcollid;
862 113066 : break;
863 78 : case T_DistinctExpr:
864 78 : coll = ((const DistinctExpr *) expr)->opcollid;
865 78 : break;
866 226 : case T_NullIfExpr:
867 226 : coll = ((const NullIfExpr *) expr)->opcollid;
868 226 : break;
869 20146 : case T_ScalarArrayOpExpr:
870 : /* ScalarArrayOpExpr's result is boolean ... */
871 20146 : coll = InvalidOid; /* ... so it has no collation */
872 20146 : break;
873 4966 : case T_BoolExpr:
874 : /* BoolExpr's result is boolean ... */
875 4966 : coll = InvalidOid; /* ... so it has no collation */
876 4966 : break;
877 3596 : case T_SubLink:
878 : {
879 3596 : const SubLink *sublink = (const SubLink *) expr;
880 :
881 3596 : if (sublink->subLinkType == EXPR_SUBLINK ||
882 316 : sublink->subLinkType == ARRAY_SUBLINK)
883 3518 : {
884 : /* get the collation of subselect's first target column */
885 3518 : Query *qtree = (Query *) sublink->subselect;
886 : TargetEntry *tent;
887 :
888 3518 : if (!qtree || !IsA(qtree, Query))
889 0 : elog(ERROR, "cannot get collation for untransformed sublink");
890 3518 : tent = linitial_node(TargetEntry, qtree->targetList);
891 : Assert(!tent->resjunk);
892 3518 : 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 78 : coll = InvalidOid; /* ... so it has no collation */
899 : }
900 : }
901 3596 : break;
902 21828 : case T_SubPlan:
903 : {
904 21828 : const SubPlan *subplan = (const SubPlan *) expr;
905 :
906 21828 : if (subplan->subLinkType == EXPR_SUBLINK ||
907 310 : subplan->subLinkType == ARRAY_SUBLINK)
908 : {
909 : /* get the collation of subselect's first target column */
910 21614 : 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 214 : coll = InvalidOid; /* ... so it has no collation */
917 : }
918 : }
919 21828 : 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 11222 : case T_FieldSelect:
929 11222 : coll = ((const FieldSelect *) expr)->resultcollid;
930 11222 : break;
931 64 : case T_FieldStore:
932 : /* FieldStore's result is composite ... */
933 64 : coll = InvalidOid; /* ... so it has no collation */
934 64 : break;
935 132202 : case T_RelabelType:
936 132202 : coll = ((const RelabelType *) expr)->resultcollid;
937 132202 : break;
938 41834 : case T_CoerceViaIO:
939 41834 : coll = ((const CoerceViaIO *) expr)->resultcollid;
940 41834 : break;
941 1700 : case T_ArrayCoerceExpr:
942 1700 : coll = ((const ArrayCoerceExpr *) expr)->resultcollid;
943 1700 : break;
944 548 : case T_ConvertRowtypeExpr:
945 : /* ConvertRowtypeExpr's result is composite ... */
946 548 : coll = InvalidOid; /* ... so it has no collation */
947 548 : break;
948 212 : case T_CollateExpr:
949 212 : coll = ((const CollateExpr *) expr)->collOid;
950 212 : break;
951 148426 : case T_CaseExpr:
952 148426 : coll = ((const CaseExpr *) expr)->casecollid;
953 148426 : break;
954 35954 : case T_CaseTestExpr:
955 35954 : coll = ((const CaseTestExpr *) expr)->collation;
956 35954 : break;
957 29344 : case T_ArrayExpr:
958 29344 : coll = ((const ArrayExpr *) expr)->array_collid;
959 29344 : break;
960 4796 : case T_RowExpr:
961 : /* RowExpr's result is composite ... */
962 4796 : coll = InvalidOid; /* ... so it has no collation */
963 4796 : break;
964 66 : case T_RowCompareExpr:
965 : /* RowCompareExpr's result is boolean ... */
966 66 : coll = InvalidOid; /* ... so it has no collation */
967 66 : break;
968 3236 : case T_CoalesceExpr:
969 3236 : coll = ((const CoalesceExpr *) expr)->coalescecollid;
970 3236 : break;
971 2988 : case T_MinMaxExpr:
972 2988 : coll = ((const MinMaxExpr *) expr)->minmaxcollid;
973 2988 : break;
974 1508 : case T_SQLValueFunction:
975 : /* Returns either NAME or a non-collatable type */
976 1508 : if (((const SQLValueFunction *) expr)->type == NAMEOID)
977 1350 : coll = C_COLLATION_OID;
978 : else
979 158 : coll = InvalidOid;
980 1508 : break;
981 676 : 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 676 : if (((const XmlExpr *) expr)->op == IS_XMLSERIALIZE)
989 166 : coll = DEFAULT_COLLATION_OID;
990 : else
991 510 : coll = InvalidOid;
992 676 : break;
993 12 : case T_JsonValueExpr:
994 12 : coll = exprCollation((Node *) ((const JsonValueExpr *) expr)->formatted_expr);
995 12 : break;
996 1356 : case T_JsonConstructorExpr:
997 : {
998 1356 : const JsonConstructorExpr *ctor = (const JsonConstructorExpr *) expr;
999 :
1000 1356 : if (ctor->coercion)
1001 236 : coll = exprCollation((Node *) ctor->coercion);
1002 : else
1003 1120 : coll = InvalidOid;
1004 : }
1005 1356 : break;
1006 274 : case T_JsonIsPredicate:
1007 : /* IS JSON's result is boolean ... */
1008 274 : coll = InvalidOid; /* ... so it has no collation */
1009 274 : break;
1010 2432 : case T_JsonExpr:
1011 : {
1012 2432 : const JsonExpr *jsexpr = (JsonExpr *) expr;
1013 :
1014 2432 : coll = jsexpr->collation;
1015 : }
1016 2432 : break;
1017 0 : case T_JsonBehavior:
1018 : {
1019 0 : const JsonBehavior *behavior = (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 2076 : case T_NullTest:
1028 : /* NullTest's result is boolean ... */
1029 2076 : coll = InvalidOid; /* ... so it has no collation */
1030 2076 : break;
1031 492 : case T_BooleanTest:
1032 : /* BooleanTest's result is boolean ... */
1033 492 : coll = InvalidOid; /* ... so it has no collation */
1034 492 : break;
1035 72636 : case T_CoerceToDomain:
1036 72636 : coll = ((const CoerceToDomain *) expr)->resultcollid;
1037 72636 : break;
1038 804 : case T_CoerceToDomainValue:
1039 804 : coll = ((const CoerceToDomainValue *) expr)->collation;
1040 804 : break;
1041 31166 : case T_SetToDefault:
1042 31166 : coll = ((const SetToDefault *) expr)->collation;
1043 31166 : break;
1044 254 : case T_CurrentOfExpr:
1045 : /* CurrentOfExpr's result is boolean ... */
1046 254 : coll = InvalidOid; /* ... so it has no collation */
1047 254 : break;
1048 414 : case T_NextValueExpr:
1049 : /* NextValueExpr's result is an integer type ... */
1050 414 : coll = InvalidOid; /* ... so it has no collation */
1051 414 : break;
1052 0 : case T_InferenceElem:
1053 0 : coll = exprCollation((Node *) ((const InferenceElem *) expr)->expr);
1054 0 : break;
1055 480 : case T_ReturningExpr:
1056 480 : coll = exprCollation((Node *) ((const ReturningExpr *) expr)->retexpr);
1057 480 : break;
1058 9670 : case T_PlaceHolderVar:
1059 9670 : coll = exprCollation((Node *) ((const PlaceHolderVar *) expr)->phexpr);
1060 9670 : 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 14487104 : 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 1422 : exprInputCollation(const Node *expr)
1077 : {
1078 : Oid coll;
1079 :
1080 1422 : if (!expr)
1081 0 : return InvalidOid;
1082 :
1083 1422 : 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 98 : case T_FuncExpr:
1092 98 : coll = ((const FuncExpr *) expr)->inputcollid;
1093 98 : break;
1094 368 : case T_OpExpr:
1095 368 : coll = ((const OpExpr *) expr)->inputcollid;
1096 368 : break;
1097 6 : case T_DistinctExpr:
1098 6 : coll = ((const DistinctExpr *) expr)->inputcollid;
1099 6 : break;
1100 12 : case T_NullIfExpr:
1101 12 : coll = ((const NullIfExpr *) expr)->inputcollid;
1102 12 : break;
1103 6 : case T_ScalarArrayOpExpr:
1104 6 : coll = ((const ScalarArrayOpExpr *) expr)->inputcollid;
1105 6 : break;
1106 6 : case T_MinMaxExpr:
1107 6 : coll = ((const MinMaxExpr *) expr)->inputcollid;
1108 6 : break;
1109 926 : default:
1110 926 : coll = InvalidOid;
1111 926 : break;
1112 : }
1113 1422 : 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 1846816 : exprSetCollation(Node *expr, Oid collation)
1125 : {
1126 1846816 : 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 49594 : case T_Aggref:
1138 49594 : ((Aggref *) expr)->aggcollid = collation;
1139 49594 : break;
1140 362 : case T_GroupingFunc:
1141 : Assert(!OidIsValid(collation));
1142 362 : break;
1143 3824 : case T_WindowFunc:
1144 3824 : ((WindowFunc *) expr)->wincollid = collation;
1145 3824 : break;
1146 222 : case T_MergeSupportFunc:
1147 222 : ((MergeSupportFunc *) expr)->msfcollid = collation;
1148 222 : break;
1149 13056 : case T_SubscriptingRef:
1150 13056 : ((SubscriptingRef *) expr)->refcollid = collation;
1151 13056 : break;
1152 445910 : case T_FuncExpr:
1153 445910 : ((FuncExpr *) expr)->funccollid = collation;
1154 445910 : break;
1155 47050 : case T_NamedArgExpr:
1156 : Assert(collation == exprCollation((Node *) ((NamedArgExpr *) expr)->arg));
1157 47050 : break;
1158 628278 : case T_OpExpr:
1159 628278 : ((OpExpr *) expr)->opcollid = collation;
1160 628278 : break;
1161 1158 : case T_DistinctExpr:
1162 1158 : ((DistinctExpr *) expr)->opcollid = collation;
1163 1158 : break;
1164 484 : case T_NullIfExpr:
1165 484 : ((NullIfExpr *) expr)->opcollid = collation;
1166 484 : break;
1167 37110 : case T_ScalarArrayOpExpr:
1168 : /* ScalarArrayOpExpr's result is boolean ... */
1169 : Assert(!OidIsValid(collation)); /* ... so never set a collation */
1170 37110 : break;
1171 158246 : case T_BoolExpr:
1172 : /* BoolExpr's result is boolean ... */
1173 : Assert(!OidIsValid(collation)); /* ... so never set a collation */
1174 158246 : break;
1175 52048 : 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 52048 : break;
1201 0 : case T_FieldSelect:
1202 0 : ((FieldSelect *) expr)->resultcollid = collation;
1203 0 : break;
1204 604 : case T_FieldStore:
1205 : /* FieldStore's result is composite ... */
1206 : Assert(!OidIsValid(collation)); /* ... so never set a collation */
1207 604 : break;
1208 165000 : case T_RelabelType:
1209 165000 : ((RelabelType *) expr)->resultcollid = collation;
1210 165000 : break;
1211 26446 : case T_CoerceViaIO:
1212 26446 : ((CoerceViaIO *) expr)->resultcollid = collation;
1213 26446 : break;
1214 5750 : case T_ArrayCoerceExpr:
1215 5750 : ((ArrayCoerceExpr *) expr)->resultcollid = collation;
1216 5750 : break;
1217 60 : case T_ConvertRowtypeExpr:
1218 : /* ConvertRowtypeExpr's result is composite ... */
1219 : Assert(!OidIsValid(collation)); /* ... so never set a collation */
1220 60 : break;
1221 46646 : case T_CaseExpr:
1222 46646 : ((CaseExpr *) expr)->casecollid = collation;
1223 46646 : break;
1224 30320 : case T_ArrayExpr:
1225 30320 : ((ArrayExpr *) expr)->array_collid = collation;
1226 30320 : 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 6558 : case T_CoalesceExpr:
1236 6558 : ((CoalesceExpr *) expr)->coalescecollid = collation;
1237 6558 : break;
1238 330 : case T_MinMaxExpr:
1239 330 : ((MinMaxExpr *) expr)->minmaxcollid = collation;
1240 330 : break;
1241 2952 : case T_SQLValueFunction:
1242 : Assert((((SQLValueFunction *) expr)->type == NAMEOID) ?
1243 : (collation == C_COLLATION_OID) :
1244 : (collation == InvalidOid));
1245 2952 : break;
1246 784 : case T_XmlExpr:
1247 : Assert((((XmlExpr *) expr)->op == IS_XMLSERIALIZE) ?
1248 : (collation == DEFAULT_COLLATION_OID) :
1249 : (collation == InvalidOid));
1250 784 : break;
1251 696 : case T_JsonValueExpr:
1252 696 : exprSetCollation((Node *) ((JsonValueExpr *) expr)->formatted_expr,
1253 : collation);
1254 696 : break;
1255 1396 : case T_JsonConstructorExpr:
1256 : {
1257 1396 : JsonConstructorExpr *ctor = (JsonConstructorExpr *) expr;
1258 :
1259 1396 : if (ctor->coercion)
1260 386 : exprSetCollation((Node *) ctor->coercion, collation);
1261 : else
1262 : Assert(!OidIsValid(collation)); /* result is always a
1263 : * json[b] type */
1264 : }
1265 1396 : break;
1266 344 : case T_JsonIsPredicate:
1267 : Assert(!OidIsValid(collation)); /* result is always boolean */
1268 344 : break;
1269 2504 : case T_JsonExpr:
1270 : {
1271 2504 : JsonExpr *jexpr = (JsonExpr *) expr;
1272 :
1273 2504 : jexpr->collation = collation;
1274 : }
1275 2504 : break;
1276 4714 : case T_JsonBehavior:
1277 : Assert(((JsonBehavior *) expr)->expr == NULL ||
1278 : exprCollation(((JsonBehavior *) expr)->expr) == collation);
1279 4714 : break;
1280 21856 : case T_NullTest:
1281 : /* NullTest's result is boolean ... */
1282 : Assert(!OidIsValid(collation)); /* ... so never set a collation */
1283 21856 : break;
1284 946 : case T_BooleanTest:
1285 : /* BooleanTest's result is boolean ... */
1286 : Assert(!OidIsValid(collation)); /* ... so never set a collation */
1287 946 : break;
1288 91568 : case T_CoerceToDomain:
1289 91568 : ((CoerceToDomain *) expr)->resultcollid = collation;
1290 91568 : 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 1846816 : }
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 1754178 : exprSetInputCollation(Node *expr, Oid inputcollation)
1321 : {
1322 1754178 : switch (nodeTag(expr))
1323 : {
1324 49594 : case T_Aggref:
1325 49594 : ((Aggref *) expr)->inputcollid = inputcollation;
1326 49594 : break;
1327 3824 : case T_WindowFunc:
1328 3824 : ((WindowFunc *) expr)->inputcollid = inputcollation;
1329 3824 : break;
1330 445730 : case T_FuncExpr:
1331 445730 : ((FuncExpr *) expr)->inputcollid = inputcollation;
1332 445730 : break;
1333 628278 : case T_OpExpr:
1334 628278 : ((OpExpr *) expr)->inputcollid = inputcollation;
1335 628278 : break;
1336 1158 : case T_DistinctExpr:
1337 1158 : ((DistinctExpr *) expr)->inputcollid = inputcollation;
1338 1158 : break;
1339 484 : case T_NullIfExpr:
1340 484 : ((NullIfExpr *) expr)->inputcollid = inputcollation;
1341 484 : break;
1342 37110 : case T_ScalarArrayOpExpr:
1343 37110 : ((ScalarArrayOpExpr *) expr)->inputcollid = inputcollation;
1344 37110 : break;
1345 330 : case T_MinMaxExpr:
1346 330 : ((MinMaxExpr *) expr)->inputcollid = inputcollation;
1347 330 : break;
1348 587670 : default:
1349 587670 : break;
1350 : }
1351 1754178 : }
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 4526472 : exprLocation(const Node *expr)
1385 : {
1386 : int loc;
1387 :
1388 4526472 : if (expr == NULL)
1389 28100 : return -1;
1390 4498372 : switch (nodeTag(expr))
1391 : {
1392 30 : case T_RangeVar:
1393 30 : loc = ((const RangeVar *) expr)->location;
1394 30 : break;
1395 0 : case T_TableFunc:
1396 0 : loc = ((const TableFunc *) expr)->location;
1397 0 : break;
1398 2328344 : case T_Var:
1399 2328344 : loc = ((const Var *) expr)->location;
1400 2328344 : break;
1401 1402278 : case T_Const:
1402 1402278 : loc = ((const Const *) expr)->location;
1403 1402278 : break;
1404 109924 : case T_Param:
1405 109924 : loc = ((const Param *) expr)->location;
1406 109924 : break;
1407 10064 : case T_Aggref:
1408 : /* function name should always be the first thing */
1409 10064 : loc = ((const Aggref *) expr)->location;
1410 10064 : break;
1411 70 : case T_GroupingFunc:
1412 70 : loc = ((const GroupingFunc *) expr)->location;
1413 70 : break;
1414 54 : case T_WindowFunc:
1415 : /* function name should always be the first thing */
1416 54 : loc = ((const WindowFunc *) expr)->location;
1417 54 : break;
1418 222 : case T_MergeSupportFunc:
1419 222 : loc = ((const MergeSupportFunc *) expr)->location;
1420 222 : break;
1421 312 : case T_SubscriptingRef:
1422 : /* just use container argument's location */
1423 312 : loc = exprLocation((Node *) ((const SubscriptingRef *) expr)->refexpr);
1424 312 : break;
1425 109082 : case T_FuncExpr:
1426 : {
1427 109082 : const FuncExpr *fexpr = (const FuncExpr *) expr;
1428 :
1429 : /* consider both function name and leftmost arg */
1430 109082 : loc = leftmostLoc(fexpr->location,
1431 109082 : exprLocation((Node *) fexpr->args));
1432 : }
1433 109082 : break;
1434 6 : case T_NamedArgExpr:
1435 : {
1436 6 : const NamedArgExpr *na = (const NamedArgExpr *) expr;
1437 :
1438 : /* consider both argument name and value */
1439 6 : loc = leftmostLoc(na->location,
1440 6 : exprLocation((Node *) na->arg));
1441 : }
1442 6 : break;
1443 13522 : case T_OpExpr:
1444 : case T_DistinctExpr: /* struct-equivalent to OpExpr */
1445 : case T_NullIfExpr: /* struct-equivalent to OpExpr */
1446 : {
1447 13522 : const OpExpr *opexpr = (const OpExpr *) expr;
1448 :
1449 : /* consider both operator name and leftmost arg */
1450 13522 : loc = leftmostLoc(opexpr->location,
1451 13522 : exprLocation((Node *) opexpr->args));
1452 : }
1453 13522 : 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 150 : case T_BoolExpr:
1464 : {
1465 150 : 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 150 : loc = leftmostLoc(bexpr->location,
1473 150 : exprLocation((Node *) bexpr->args));
1474 : }
1475 150 : break;
1476 1302 : case T_SubLink:
1477 : {
1478 1302 : const SubLink *sublink = (const SubLink *) expr;
1479 :
1480 : /* check the testexpr, if any, and the operator/keyword */
1481 1302 : loc = leftmostLoc(exprLocation(sublink->testexpr),
1482 1302 : sublink->location);
1483 : }
1484 1302 : break;
1485 4204 : case T_FieldSelect:
1486 : /* just use argument's location */
1487 4204 : loc = exprLocation((Node *) ((const FieldSelect *) expr)->arg);
1488 4204 : 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 14460 : case T_RelabelType:
1494 : {
1495 14460 : const RelabelType *rexpr = (const RelabelType *) expr;
1496 :
1497 : /* Much as above */
1498 14460 : loc = leftmostLoc(rexpr->location,
1499 14460 : exprLocation((Node *) rexpr->arg));
1500 : }
1501 14460 : break;
1502 24714 : case T_CoerceViaIO:
1503 : {
1504 24714 : const CoerceViaIO *cexpr = (const CoerceViaIO *) expr;
1505 :
1506 : /* Much as above */
1507 24714 : loc = leftmostLoc(cexpr->location,
1508 24714 : exprLocation((Node *) cexpr->arg));
1509 : }
1510 24714 : break;
1511 10 : case T_ArrayCoerceExpr:
1512 : {
1513 10 : const ArrayCoerceExpr *cexpr = (const ArrayCoerceExpr *) expr;
1514 :
1515 : /* Much as above */
1516 10 : loc = leftmostLoc(cexpr->location,
1517 10 : exprLocation((Node *) cexpr->arg));
1518 : }
1519 10 : break;
1520 12 : case T_ConvertRowtypeExpr:
1521 : {
1522 12 : const ConvertRowtypeExpr *cexpr = (const ConvertRowtypeExpr *) expr;
1523 :
1524 : /* Much as above */
1525 12 : loc = leftmostLoc(cexpr->location,
1526 12 : exprLocation((Node *) cexpr->arg));
1527 : }
1528 12 : break;
1529 48 : case T_CollateExpr:
1530 : /* just use argument's location */
1531 48 : loc = exprLocation((Node *) ((const CollateExpr *) expr)->arg);
1532 48 : break;
1533 11772 : case T_CaseExpr:
1534 : /* CASE keyword should always be the first thing */
1535 11772 : loc = ((const CaseExpr *) expr)->location;
1536 11772 : 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 462 : case T_ArrayExpr:
1542 : /* the location points at ARRAY or [, which must be leftmost */
1543 462 : loc = ((const ArrayExpr *) expr)->location;
1544 462 : break;
1545 296 : case T_RowExpr:
1546 : /* the location points at ROW or (, which must be leftmost */
1547 296 : loc = ((const RowExpr *) expr)->location;
1548 296 : 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 2280 : case T_CoalesceExpr:
1554 : /* COALESCE keyword should always be the first thing */
1555 2280 : loc = ((const CoalesceExpr *) expr)->location;
1556 2280 : break;
1557 30 : case T_MinMaxExpr:
1558 : /* GREATEST/LEAST keyword should always be the first thing */
1559 30 : loc = ((const MinMaxExpr *) expr)->location;
1560 30 : break;
1561 1878 : case T_SQLValueFunction:
1562 : /* function keyword should always be the first thing */
1563 1878 : loc = ((const SQLValueFunction *) expr)->location;
1564 1878 : break;
1565 218 : case T_XmlExpr:
1566 : {
1567 218 : const XmlExpr *xexpr = (const XmlExpr *) expr;
1568 :
1569 : /* consider both function name and leftmost arg */
1570 218 : loc = leftmostLoc(xexpr->location,
1571 218 : exprLocation((Node *) xexpr->args));
1572 : }
1573 218 : 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 172 : case T_JsonConstructorExpr:
1581 172 : loc = ((const JsonConstructorExpr *) expr)->location;
1582 172 : break;
1583 0 : case T_JsonIsPredicate:
1584 0 : loc = ((const JsonIsPredicate *) expr)->location;
1585 0 : break;
1586 510 : case T_JsonExpr:
1587 : {
1588 510 : const JsonExpr *jsexpr = (const JsonExpr *) expr;
1589 :
1590 : /* consider both function name and leftmost arg */
1591 510 : loc = leftmostLoc(jsexpr->location,
1592 510 : exprLocation(jsexpr->formatted_expr));
1593 : }
1594 510 : break;
1595 210 : case T_JsonBehavior:
1596 210 : loc = exprLocation(((JsonBehavior *) expr)->expr);
1597 210 : break;
1598 196 : case T_NullTest:
1599 : {
1600 196 : const NullTest *nexpr = (const NullTest *) expr;
1601 :
1602 : /* Much as above */
1603 196 : loc = leftmostLoc(nexpr->location,
1604 196 : exprLocation((Node *) nexpr->arg));
1605 : }
1606 196 : 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 86366 : case T_CoerceToDomain:
1617 : {
1618 86366 : const CoerceToDomain *cexpr = (const CoerceToDomain *) expr;
1619 :
1620 : /* Much as above */
1621 86366 : loc = leftmostLoc(cexpr->location,
1622 86366 : exprLocation((Node *) cexpr->arg));
1623 : }
1624 86366 : break;
1625 1022 : case T_CoerceToDomainValue:
1626 1022 : loc = ((const CoerceToDomainValue *) expr)->location;
1627 1022 : break;
1628 60640 : case T_SetToDefault:
1629 60640 : loc = ((const SetToDefault *) expr)->location;
1630 60640 : 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 18 : case T_IntoClause:
1639 : /* use the contained RangeVar's location --- close enough */
1640 18 : loc = exprLocation((Node *) ((const IntoClause *) expr)->rel);
1641 18 : break;
1642 102786 : case T_List:
1643 : {
1644 : /* report location of first list member that has a location */
1645 : ListCell *lc;
1646 :
1647 102786 : loc = -1; /* just to suppress compiler warning */
1648 103626 : foreach(lc, (const List *) expr)
1649 : {
1650 103180 : loc = exprLocation((Node *) lfirst(lc));
1651 103180 : if (loc >= 0)
1652 102340 : break;
1653 : }
1654 : }
1655 102786 : break;
1656 5380 : case T_A_Expr:
1657 : {
1658 5380 : 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 5380 : loc = leftmostLoc(aexpr->location,
1663 5380 : exprLocation(aexpr->lexpr));
1664 : }
1665 5380 : break;
1666 84154 : case T_ColumnRef:
1667 84154 : loc = ((const ColumnRef *) expr)->location;
1668 84154 : break;
1669 0 : case T_ParamRef:
1670 0 : loc = ((const ParamRef *) expr)->location;
1671 0 : break;
1672 69214 : case T_A_Const:
1673 69214 : loc = ((const A_Const *) expr)->location;
1674 69214 : break;
1675 3864 : case T_FuncCall:
1676 : {
1677 3864 : 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 3864 : loc = leftmostLoc(fc->location,
1682 3864 : exprLocation((Node *) fc->args));
1683 : }
1684 3864 : 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 18 : case T_ResTarget:
1690 : /* we need not examine the contained expression (if any) */
1691 18 : loc = ((const ResTarget *) expr)->location;
1692 18 : break;
1693 0 : case T_MultiAssignRef:
1694 0 : loc = exprLocation(((const MultiAssignRef *) expr)->source);
1695 0 : break;
1696 8352 : case T_TypeCast:
1697 : {
1698 8352 : 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 8352 : loc = exprLocation(tc->arg);
1705 8352 : loc = leftmostLoc(loc, tc->typeName->location);
1706 8352 : loc = leftmostLoc(loc, tc->location);
1707 : }
1708 8352 : break;
1709 1016 : case T_CollateClause:
1710 : /* just use argument's location */
1711 1016 : loc = exprLocation(((const CollateClause *) expr)->arg);
1712 1016 : break;
1713 12 : case T_SortBy:
1714 : /* just use argument's location (ignore operator, if any) */
1715 12 : loc = exprLocation(((const SortBy *) expr)->node);
1716 12 : 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 18 : case T_ColumnDef:
1727 18 : loc = ((const ColumnDef *) expr)->location;
1728 18 : 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 36 : case T_GroupingSet:
1743 36 : loc = ((const GroupingSet *) expr)->location;
1744 36 : 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 6 : case T_OnConflictClause:
1752 6 : loc = ((const OnConflictClause *) expr)->location;
1753 6 : 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 54 : case T_PartitionBoundSpec:
1800 54 : loc = ((const PartitionBoundSpec *) expr)->location;
1801 54 : break;
1802 48 : case T_PartitionRangeDatum:
1803 48 : loc = ((const PartitionRangeDatum *) expr)->location;
1804 48 : break;
1805 38536 : default:
1806 : /* for any other node type it's just unknown... */
1807 38536 : loc = -1;
1808 38536 : break;
1809 : }
1810 4498372 : 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 276496 : leftmostLoc(int loc1, int loc2)
1820 : {
1821 276496 : if (loc1 < 0)
1822 23924 : return loc2;
1823 252572 : else if (loc2 < 0)
1824 26984 : return loc1;
1825 : else
1826 225588 : 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 496830 : fix_opfuncids(Node *node)
1841 : {
1842 : /* This tree walk requires no special setup, so away we go... */
1843 496830 : fix_opfuncids_walker(node, NULL);
1844 496830 : }
1845 :
1846 : static bool
1847 1106196 : fix_opfuncids_walker(Node *node, void *context)
1848 : {
1849 1106196 : if (node == NULL)
1850 60588 : return false;
1851 1045608 : if (IsA(node, OpExpr))
1852 63056 : set_opfuncid((OpExpr *) node);
1853 982552 : else if (IsA(node, DistinctExpr))
1854 6 : set_opfuncid((OpExpr *) node); /* rely on struct equivalence */
1855 982546 : else if (IsA(node, NullIfExpr))
1856 616 : set_opfuncid((OpExpr *) node); /* rely on struct equivalence */
1857 981930 : else if (IsA(node, ScalarArrayOpExpr))
1858 2438 : set_sa_opfuncid((ScalarArrayOpExpr *) node);
1859 1045608 : 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 4095510 : set_opfuncid(OpExpr *opexpr)
1872 : {
1873 4095510 : if (opexpr->opfuncid == InvalidOid)
1874 240986 : opexpr->opfuncid = get_opcode(opexpr->opno);
1875 4095510 : }
1876 :
1877 : /*
1878 : * set_sa_opfuncid
1879 : * As above, for ScalarArrayOpExpr nodes.
1880 : */
1881 : void
1882 206254 : set_sa_opfuncid(ScalarArrayOpExpr *opexpr)
1883 : {
1884 206254 : if (opexpr->opfuncid == InvalidOid)
1885 544 : opexpr->opfuncid = get_opcode(opexpr->opno);
1886 206254 : }
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 23758410 : check_functions_in_node(Node *node, check_function_callback checker,
1910 : void *context)
1911 : {
1912 23758410 : switch (nodeTag(node))
1913 : {
1914 123384 : case T_Aggref:
1915 : {
1916 123384 : Aggref *expr = (Aggref *) node;
1917 :
1918 123384 : if (checker(expr->aggfnoid, context))
1919 1052 : return true;
1920 : }
1921 122332 : break;
1922 7852 : case T_WindowFunc:
1923 : {
1924 7852 : WindowFunc *expr = (WindowFunc *) node;
1925 :
1926 7852 : if (checker(expr->winfnoid, context))
1927 150 : return true;
1928 : }
1929 7702 : break;
1930 718246 : case T_FuncExpr:
1931 : {
1932 718246 : FuncExpr *expr = (FuncExpr *) node;
1933 :
1934 718246 : if (checker(expr->funcid, context))
1935 115976 : return true;
1936 : }
1937 602270 : break;
1938 1567036 : case T_OpExpr:
1939 : case T_DistinctExpr: /* struct-equivalent to OpExpr */
1940 : case T_NullIfExpr: /* struct-equivalent to OpExpr */
1941 : {
1942 1567036 : OpExpr *expr = (OpExpr *) node;
1943 :
1944 : /* Set opfuncid if it wasn't set already */
1945 1567036 : set_opfuncid(expr);
1946 1567036 : if (checker(expr->opfuncid, context))
1947 1674 : return true;
1948 : }
1949 1565362 : break;
1950 69668 : case T_ScalarArrayOpExpr:
1951 : {
1952 69668 : ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
1953 :
1954 69668 : set_sa_opfuncid(expr);
1955 69668 : if (checker(expr->opfuncid, context))
1956 94 : return true;
1957 : }
1958 69574 : break;
1959 41798 : case T_CoerceViaIO:
1960 : {
1961 41798 : CoerceViaIO *expr = (CoerceViaIO *) node;
1962 : Oid iofunc;
1963 : Oid typioparam;
1964 : bool typisvarlena;
1965 :
1966 : /* check the result type's input function */
1967 41798 : getTypeInputInfo(expr->resulttype,
1968 : &iofunc, &typioparam);
1969 41798 : if (checker(iofunc, context))
1970 656 : return true;
1971 : /* check the input type's output function */
1972 41750 : getTypeOutputInfo(exprType((Node *) expr->arg),
1973 : &iofunc, &typisvarlena);
1974 41750 : if (checker(iofunc, context))
1975 608 : return true;
1976 : }
1977 41142 : break;
1978 330 : case T_RowCompareExpr:
1979 : {
1980 330 : RowCompareExpr *rcexpr = (RowCompareExpr *) node;
1981 : ListCell *opid;
1982 :
1983 1092 : foreach(opid, rcexpr->opnos)
1984 : {
1985 762 : Oid opfuncid = get_opcode(lfirst_oid(opid));
1986 :
1987 762 : if (checker(opfuncid, context))
1988 0 : return true;
1989 : }
1990 : }
1991 330 : break;
1992 21230096 : default:
1993 21230096 : break;
1994 : }
1995 23638808 : 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 111712642 : 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 111712642 : if (node == NULL)
2111 2238582 : return false;
2112 :
2113 : /* Guard against stack overflow due to overly complex expressions */
2114 109474060 : check_stack_depth();
2115 :
2116 109474054 : switch (nodeTag(node))
2117 : {
2118 46284106 : 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 46284106 : break;
2133 8802 : case T_WithCheckOption:
2134 8802 : return WALK(((WithCheckOption *) node)->qual);
2135 371828 : case T_Aggref:
2136 : {
2137 371828 : Aggref *expr = (Aggref *) node;
2138 :
2139 : /* recurse directly on Lists */
2140 371828 : if (LIST_WALK(expr->aggdirectargs))
2141 0 : return true;
2142 371828 : if (LIST_WALK(expr->args))
2143 22216 : return true;
2144 349612 : if (LIST_WALK(expr->aggorder))
2145 0 : return true;
2146 349612 : if (LIST_WALK(expr->aggdistinct))
2147 0 : return true;
2148 349612 : if (WALK(expr->aggfilter))
2149 78 : return true;
2150 : }
2151 349534 : break;
2152 3846 : case T_GroupingFunc:
2153 : {
2154 3846 : GroupingFunc *grouping = (GroupingFunc *) node;
2155 :
2156 3846 : if (LIST_WALK(grouping->args))
2157 246 : return true;
2158 : }
2159 3600 : break;
2160 19390 : case T_WindowFunc:
2161 : {
2162 19390 : WindowFunc *expr = (WindowFunc *) node;
2163 :
2164 : /* recurse directly on List */
2165 19390 : if (LIST_WALK(expr->args))
2166 672 : return true;
2167 18718 : if (WALK(expr->aggfilter))
2168 12 : return true;
2169 18706 : if (WALK(expr->runCondition))
2170 0 : return true;
2171 : }
2172 18706 : break;
2173 552 : case T_WindowFuncRunCondition:
2174 : {
2175 552 : WindowFuncRunCondition *expr = (WindowFuncRunCondition *) node;
2176 :
2177 552 : if (WALK(expr->arg))
2178 0 : return true;
2179 : }
2180 552 : break;
2181 243790 : case T_SubscriptingRef:
2182 : {
2183 243790 : SubscriptingRef *sbsref = (SubscriptingRef *) node;
2184 :
2185 : /* recurse directly for upper/lower container index lists */
2186 243790 : if (LIST_WALK(sbsref->refupperindexpr))
2187 12078 : return true;
2188 231712 : if (LIST_WALK(sbsref->reflowerindexpr))
2189 0 : return true;
2190 : /* walker must see the refexpr and refassgnexpr, however */
2191 231712 : if (WALK(sbsref->refexpr))
2192 12342 : return true;
2193 :
2194 219370 : if (WALK(sbsref->refassgnexpr))
2195 156 : return true;
2196 : }
2197 219214 : break;
2198 3816942 : case T_FuncExpr:
2199 : {
2200 3816942 : FuncExpr *expr = (FuncExpr *) node;
2201 :
2202 3816942 : if (LIST_WALK(expr->args))
2203 86704 : return true;
2204 : }
2205 3730226 : break;
2206 99228 : case T_NamedArgExpr:
2207 99228 : return WALK(((NamedArgExpr *) node)->arg);
2208 8750612 : case T_OpExpr:
2209 : case T_DistinctExpr: /* struct-equivalent to OpExpr */
2210 : case T_NullIfExpr: /* struct-equivalent to OpExpr */
2211 : {
2212 8750612 : OpExpr *expr = (OpExpr *) node;
2213 :
2214 8750612 : if (LIST_WALK(expr->args))
2215 81910 : return true;
2216 : }
2217 8668576 : break;
2218 488000 : case T_ScalarArrayOpExpr:
2219 : {
2220 488000 : ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
2221 :
2222 488000 : if (LIST_WALK(expr->args))
2223 44264 : return true;
2224 : }
2225 443736 : break;
2226 1108392 : case T_BoolExpr:
2227 : {
2228 1108392 : BoolExpr *expr = (BoolExpr *) node;
2229 :
2230 1108392 : if (LIST_WALK(expr->args))
2231 10192 : return true;
2232 : }
2233 1098194 : break;
2234 266878 : case T_SubLink:
2235 : {
2236 266878 : SubLink *sublink = (SubLink *) node;
2237 :
2238 266878 : if (WALK(sublink->testexpr))
2239 66 : 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 266812 : return WALK(sublink->subselect);
2246 : }
2247 : break;
2248 114664 : case T_SubPlan:
2249 : {
2250 114664 : SubPlan *subplan = (SubPlan *) node;
2251 :
2252 : /* recurse into the testexpr, but not into the Plan */
2253 114664 : if (WALK(subplan->testexpr))
2254 72 : return true;
2255 : /* also examine args list */
2256 114592 : if (LIST_WALK(subplan->args))
2257 420 : return true;
2258 : }
2259 114172 : break;
2260 8368 : case T_AlternativeSubPlan:
2261 8368 : return LIST_WALK(((AlternativeSubPlan *) node)->subplans);
2262 97892 : case T_FieldSelect:
2263 97892 : return WALK(((FieldSelect *) node)->arg);
2264 3088 : case T_FieldStore:
2265 : {
2266 3088 : FieldStore *fstore = (FieldStore *) node;
2267 :
2268 3088 : if (WALK(fstore->arg))
2269 0 : return true;
2270 3088 : if (WALK(fstore->newvals))
2271 12 : return true;
2272 : }
2273 3076 : break;
2274 1392456 : case T_RelabelType:
2275 1392456 : return WALK(((RelabelType *) node)->arg);
2276 248312 : case T_CoerceViaIO:
2277 248312 : return WALK(((CoerceViaIO *) node)->arg);
2278 54474 : case T_ArrayCoerceExpr:
2279 : {
2280 54474 : ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
2281 :
2282 54474 : if (WALK(acoerce->arg))
2283 4248 : return true;
2284 50226 : if (WALK(acoerce->elemexpr))
2285 24 : return true;
2286 : }
2287 50202 : break;
2288 3226 : case T_ConvertRowtypeExpr:
2289 3226 : return WALK(((ConvertRowtypeExpr *) node)->arg);
2290 33828 : case T_CollateExpr:
2291 33828 : return WALK(((CollateExpr *) node)->arg);
2292 468470 : case T_CaseExpr:
2293 : {
2294 468470 : CaseExpr *caseexpr = (CaseExpr *) node;
2295 :
2296 468470 : if (WALK(caseexpr->arg))
2297 448 : return true;
2298 : /* we assume walker doesn't care about CaseWhens, either */
2299 1294614 : foreach(temp, caseexpr->args)
2300 : {
2301 837018 : CaseWhen *when = lfirst_node(CaseWhen, temp);
2302 :
2303 837018 : if (WALK(when->expr))
2304 10426 : return true;
2305 833758 : if (WALK(when->result))
2306 7166 : return true;
2307 : }
2308 457596 : if (WALK(caseexpr->defresult))
2309 9440 : return true;
2310 : }
2311 448156 : break;
2312 246128 : case T_ArrayExpr:
2313 246128 : return WALK(((ArrayExpr *) node)->elements);
2314 34316 : case T_RowExpr:
2315 : /* Assume colnames isn't interesting */
2316 34316 : return WALK(((RowExpr *) node)->args);
2317 2634 : case T_RowCompareExpr:
2318 : {
2319 2634 : RowCompareExpr *rcexpr = (RowCompareExpr *) node;
2320 :
2321 2634 : if (WALK(rcexpr->largs))
2322 0 : return true;
2323 2634 : if (WALK(rcexpr->rargs))
2324 0 : return true;
2325 : }
2326 2634 : break;
2327 54224 : case T_CoalesceExpr:
2328 54224 : return WALK(((CoalesceExpr *) node)->args);
2329 6448 : case T_MinMaxExpr:
2330 6448 : return WALK(((MinMaxExpr *) node)->args);
2331 5118 : case T_XmlExpr:
2332 : {
2333 5118 : XmlExpr *xexpr = (XmlExpr *) node;
2334 :
2335 5118 : if (WALK(xexpr->named_args))
2336 12 : return true;
2337 : /* we assume walker doesn't care about arg_names */
2338 5106 : if (WALK(xexpr->args))
2339 24 : return true;
2340 : }
2341 5082 : break;
2342 3918 : case T_JsonValueExpr:
2343 : {
2344 3918 : JsonValueExpr *jve = (JsonValueExpr *) node;
2345 :
2346 3918 : if (WALK(jve->raw_expr))
2347 48 : return true;
2348 3870 : if (WALK(jve->formatted_expr))
2349 0 : return true;
2350 : }
2351 3870 : break;
2352 9852 : case T_JsonConstructorExpr:
2353 : {
2354 9852 : JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;
2355 :
2356 9852 : if (WALK(ctor->args))
2357 72 : return true;
2358 9780 : if (WALK(ctor->func))
2359 96 : return true;
2360 9684 : if (WALK(ctor->coercion))
2361 12 : return true;
2362 : }
2363 9672 : break;
2364 2460 : case T_JsonIsPredicate:
2365 2460 : return WALK(((JsonIsPredicate *) node)->expr);
2366 18142 : case T_JsonExpr:
2367 : {
2368 18142 : JsonExpr *jexpr = (JsonExpr *) node;
2369 :
2370 18142 : if (WALK(jexpr->formatted_expr))
2371 84 : return true;
2372 18058 : if (WALK(jexpr->path_spec))
2373 6 : return true;
2374 18052 : if (WALK(jexpr->passing_values))
2375 6 : return true;
2376 : /* we assume walker doesn't care about passing_names */
2377 18046 : if (WALK(jexpr->on_empty))
2378 36 : return true;
2379 18010 : if (WALK(jexpr->on_error))
2380 30 : return true;
2381 : }
2382 17980 : break;
2383 31798 : case T_JsonBehavior:
2384 : {
2385 31798 : JsonBehavior *behavior = (JsonBehavior *) node;
2386 :
2387 31798 : if (WALK(behavior->expr))
2388 66 : return true;
2389 : }
2390 31732 : break;
2391 262042 : case T_NullTest:
2392 262042 : return WALK(((NullTest *) node)->arg);
2393 13762 : case T_BooleanTest:
2394 13762 : return WALK(((BooleanTest *) node)->arg);
2395 386522 : case T_CoerceToDomain:
2396 386522 : return WALK(((CoerceToDomain *) node)->arg);
2397 17903724 : case T_TargetEntry:
2398 17903724 : return WALK(((TargetEntry *) node)->expr);
2399 131186 : case T_Query:
2400 : /* Do nothing with a sub-Query, per discussion above */
2401 131186 : break;
2402 274 : case T_WindowClause:
2403 : {
2404 274 : WindowClause *wc = (WindowClause *) node;
2405 :
2406 274 : if (WALK(wc->partitionClause))
2407 0 : return true;
2408 274 : if (WALK(wc->orderClause))
2409 0 : return true;
2410 274 : if (WALK(wc->startOffset))
2411 0 : return true;
2412 274 : if (WALK(wc->endOffset))
2413 0 : return true;
2414 : }
2415 274 : break;
2416 84 : case T_CTECycleClause:
2417 : {
2418 84 : CTECycleClause *cc = (CTECycleClause *) node;
2419 :
2420 84 : if (WALK(cc->cycle_mark_value))
2421 0 : return true;
2422 84 : if (WALK(cc->cycle_mark_default))
2423 0 : return true;
2424 : }
2425 84 : break;
2426 8980 : case T_CommonTableExpr:
2427 : {
2428 8980 : 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 8980 : if (WALK(cte->ctequery))
2435 92 : return true;
2436 :
2437 8888 : if (WALK(cte->search_clause))
2438 0 : return true;
2439 8888 : if (WALK(cte->cycle_clause))
2440 0 : return true;
2441 : }
2442 8888 : 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 4712 : case T_PartitionBoundSpec:
2511 : {
2512 4712 : PartitionBoundSpec *pbs = (PartitionBoundSpec *) node;
2513 :
2514 4712 : if (WALK(pbs->listdatums))
2515 0 : return true;
2516 4712 : if (WALK(pbs->lowerdatums))
2517 0 : return true;
2518 4712 : if (WALK(pbs->upperdatums))
2519 0 : return true;
2520 : }
2521 4712 : break;
2522 6172 : case T_PartitionRangeDatum:
2523 : {
2524 6172 : PartitionRangeDatum *prd = (PartitionRangeDatum *) node;
2525 :
2526 6172 : if (WALK(prd->value))
2527 0 : return true;
2528 : }
2529 6172 : break;
2530 24342728 : case T_List:
2531 83927768 : foreach(temp, (List *) node)
2532 : {
2533 60455544 : if (WALK(lfirst(temp)))
2534 870270 : return true;
2535 : }
2536 23472224 : break;
2537 1475230 : case T_FromExpr:
2538 : {
2539 1475230 : FromExpr *from = (FromExpr *) node;
2540 :
2541 1475230 : if (LIST_WALK(from->fromlist))
2542 69958 : return true;
2543 1405272 : if (WALK(from->quals))
2544 3460 : return true;
2545 : }
2546 1401800 : break;
2547 2932 : case T_OnConflictExpr:
2548 : {
2549 2932 : OnConflictExpr *onconflict = (OnConflictExpr *) node;
2550 :
2551 2932 : if (WALK(onconflict->arbiterElems))
2552 0 : return true;
2553 2932 : if (WALK(onconflict->arbiterWhere))
2554 0 : return true;
2555 2932 : if (WALK(onconflict->onConflictSet))
2556 0 : return true;
2557 2932 : if (WALK(onconflict->onConflictWhere))
2558 0 : return true;
2559 2932 : if (WALK(onconflict->exclRelTlist))
2560 0 : return true;
2561 : }
2562 2932 : break;
2563 6900 : case T_MergeAction:
2564 : {
2565 6900 : MergeAction *action = (MergeAction *) node;
2566 :
2567 6900 : if (WALK(action->qual))
2568 140 : return true;
2569 6760 : if (WALK(action->targetList))
2570 356 : return true;
2571 : }
2572 6404 : break;
2573 798 : case T_PartitionPruneStepOp:
2574 : {
2575 798 : PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;
2576 :
2577 798 : if (WALK(opstep->exprs))
2578 0 : return true;
2579 : }
2580 798 : break;
2581 152 : case T_PartitionPruneStepCombine:
2582 : /* no expression subnodes */
2583 152 : break;
2584 330512 : case T_JoinExpr:
2585 : {
2586 330512 : JoinExpr *join = (JoinExpr *) node;
2587 :
2588 330512 : if (WALK(join->larg))
2589 18832 : return true;
2590 311680 : if (WALK(join->rarg))
2591 21124 : return true;
2592 290556 : if (WALK(join->quals))
2593 60 : return true;
2594 :
2595 : /*
2596 : * alias clause, using list are deemed uninteresting.
2597 : */
2598 : }
2599 290496 : break;
2600 37344 : case T_SetOperationStmt:
2601 : {
2602 37344 : SetOperationStmt *setop = (SetOperationStmt *) node;
2603 :
2604 37344 : if (WALK(setop->larg))
2605 0 : return true;
2606 37344 : if (WALK(setop->rarg))
2607 0 : return true;
2608 :
2609 : /* groupClauses are deemed uninteresting */
2610 : }
2611 37344 : 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 31318 : case T_PlaceHolderVar:
2623 31318 : return WALK(((PlaceHolderVar *) node)->phexpr);
2624 2942 : case T_InferenceElem:
2625 2942 : return WALK(((InferenceElem *) node)->expr);
2626 3456 : case T_ReturningExpr:
2627 3456 : return WALK(((ReturningExpr *) node)->retexpr);
2628 2256 : case T_AppendRelInfo:
2629 : {
2630 2256 : AppendRelInfo *appinfo = (AppendRelInfo *) node;
2631 :
2632 2256 : if (LIST_WALK(appinfo->translated_vars))
2633 0 : return true;
2634 : }
2635 2256 : break;
2636 0 : case T_PlaceHolderInfo:
2637 0 : return WALK(((PlaceHolderInfo *) node)->ph_var);
2638 213842 : case T_RangeTblFunction:
2639 213842 : return WALK(((RangeTblFunction *) node)->funcexpr);
2640 782 : case T_TableSampleClause:
2641 : {
2642 782 : TableSampleClause *tsc = (TableSampleClause *) node;
2643 :
2644 782 : if (LIST_WALK(tsc->args))
2645 0 : return true;
2646 782 : if (WALK(tsc->repeatable))
2647 0 : return true;
2648 : }
2649 782 : break;
2650 3222 : case T_TableFunc:
2651 : {
2652 3222 : TableFunc *tf = (TableFunc *) node;
2653 :
2654 3222 : if (WALK(tf->ns_uris))
2655 0 : return true;
2656 3222 : if (WALK(tf->docexpr))
2657 90 : return true;
2658 3132 : if (WALK(tf->rowexpr))
2659 0 : return true;
2660 3132 : if (WALK(tf->colexprs))
2661 0 : return true;
2662 3132 : if (WALK(tf->coldefexprs))
2663 0 : return true;
2664 3132 : if (WALK(tf->colvalexprs))
2665 0 : return true;
2666 3132 : if (WALK(tf->passingvalexprs))
2667 0 : return true;
2668 : }
2669 3132 : break;
2670 0 : default:
2671 0 : elog(ERROR, "unrecognized node type: %d",
2672 : (int) nodeTag(node));
2673 : break;
2674 : }
2675 86872656 : 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 1826286 : 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 1826286 : if (WALK(query->targetList))
2712 353154 : return true;
2713 1473102 : if (WALK(query->withCheckOptions))
2714 0 : return true;
2715 1473102 : if (WALK(query->onConflict))
2716 0 : return true;
2717 1473102 : if (WALK(query->mergeActionList))
2718 496 : return true;
2719 1472606 : if (WALK(query->mergeJoinCondition))
2720 344 : return true;
2721 1472262 : if (WALK(query->returningList))
2722 90 : return true;
2723 1472172 : if (WALK(query->jointree))
2724 72968 : return true;
2725 1399192 : if (WALK(query->setOperations))
2726 0 : return true;
2727 1399192 : if (WALK(query->havingQual))
2728 0 : return true;
2729 1399192 : if (WALK(query->limitOffset))
2730 6 : return true;
2731 1399186 : 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 1399186 : if ((flags & QTW_EXAMINE_SORTGROUP))
2740 : {
2741 68198 : if (WALK(query->groupClause))
2742 0 : return true;
2743 68198 : if (WALK(query->windowClause))
2744 0 : return true;
2745 68198 : if (WALK(query->sortClause))
2746 0 : return true;
2747 68198 : 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 1337126 : foreach(lc, query->windowClause)
2759 : {
2760 6144 : WindowClause *wc = lfirst_node(WindowClause, lc);
2761 :
2762 6144 : if (WALK(wc->startOffset))
2763 6 : return true;
2764 6138 : 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 1399180 : if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
2782 : {
2783 759820 : if (WALK(query->cteList))
2784 86 : return true;
2785 : }
2786 1399094 : if (!(flags & QTW_IGNORE_RANGE_TABLE))
2787 : {
2788 807740 : if (range_table_walker(query->rtable, walker, context, flags))
2789 26934 : return true;
2790 : }
2791 1372160 : 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 812660 : range_table_walker_impl(List *rtable,
2801 : tree_walker_callback walker,
2802 : void *context,
2803 : int flags)
2804 : {
2805 : ListCell *rt;
2806 :
2807 2022274 : foreach(rt, rtable)
2808 : {
2809 1236548 : RangeTblEntry *rte = lfirst_node(RangeTblEntry, rt);
2810 :
2811 1236548 : if (range_table_entry_walker(rte, walker, context, flags))
2812 26934 : return true;
2813 : }
2814 785726 : return false;
2815 : }
2816 :
2817 : /*
2818 : * Some callers even want to scan the expressions in individual RTEs.
2819 : */
2820 : bool
2821 1236572 : 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 1236572 : if (flags & QTW_EXAMINE_RTES_BEFORE)
2832 132202 : if (WALK(rte))
2833 12 : return true;
2834 :
2835 1236560 : switch (rte->rtekind)
2836 : {
2837 735326 : case RTE_RELATION:
2838 735326 : if (WALK(rte->tablesample))
2839 0 : return true;
2840 735326 : break;
2841 134922 : case RTE_SUBQUERY:
2842 134922 : if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
2843 133362 : if (WALK(rte->subquery))
2844 6384 : return true;
2845 128538 : break;
2846 195780 : case RTE_JOIN:
2847 195780 : if (!(flags & QTW_IGNORE_JOINALIASES))
2848 165924 : if (WALK(rte->joinaliasvars))
2849 0 : return true;
2850 195780 : break;
2851 91978 : case RTE_FUNCTION:
2852 91978 : if (WALK(rte->functions))
2853 20480 : return true;
2854 71498 : break;
2855 988 : case RTE_TABLEFUNC:
2856 988 : if (WALK(rte->tablefunc))
2857 0 : return true;
2858 988 : break;
2859 26612 : case RTE_VALUES:
2860 26612 : if (WALK(rte->values_lists))
2861 64 : return true;
2862 26548 : break;
2863 43844 : case RTE_CTE:
2864 : case RTE_NAMEDTUPLESTORE:
2865 : case RTE_RESULT:
2866 : /* nothing to do */
2867 43844 : break;
2868 7110 : case RTE_GROUP:
2869 7110 : if (!(flags & QTW_IGNORE_GROUPEXPRS))
2870 7110 : if (WALK(rte->groupexprs))
2871 0 : return true;
2872 7110 : break;
2873 : }
2874 :
2875 1209632 : if (WALK(rte->securityQuals))
2876 18 : return true;
2877 :
2878 1209614 : if (flags & QTW_EXAMINE_RTES_AFTER)
2879 21034 : if (WALK(rte))
2880 0 : return true;
2881 :
2882 1209614 : 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 20147528 : 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 20147528 : if (node == NULL)
2966 97346 : return NULL;
2967 :
2968 : /* Guard against stack overflow due to overly complex expressions */
2969 20050182 : check_stack_depth();
2970 :
2971 20050182 : 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 3836704 : case T_Var:
2979 : {
2980 3836704 : Var *var = (Var *) node;
2981 : Var *newnode;
2982 :
2983 3836704 : FLATCOPY(newnode, var, Var);
2984 : /* Assume we need not copy the varnullingrels bitmapset */
2985 3836704 : return (Node *) newnode;
2986 : }
2987 : break;
2988 3246066 : case T_Const:
2989 : {
2990 3246066 : Const *oldnode = (Const *) node;
2991 : Const *newnode;
2992 :
2993 3246066 : FLATCOPY(newnode, oldnode, Const);
2994 : /* XXX we don't bother with datumCopy; should we? */
2995 3246066 : return (Node *) newnode;
2996 : }
2997 : break;
2998 126610 : 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 126610 : return copyObject(node);
3011 1408 : case T_WithCheckOption:
3012 : {
3013 1408 : WithCheckOption *wco = (WithCheckOption *) node;
3014 : WithCheckOption *newnode;
3015 :
3016 1408 : FLATCOPY(newnode, wco, WithCheckOption);
3017 1408 : MUTATE(newnode->qual, wco->qual, Node *);
3018 1408 : return (Node *) newnode;
3019 : }
3020 178258 : case T_Aggref:
3021 : {
3022 178258 : Aggref *aggref = (Aggref *) node;
3023 : Aggref *newnode;
3024 :
3025 178258 : FLATCOPY(newnode, aggref, Aggref);
3026 : /* assume mutation doesn't change types of arguments */
3027 178258 : newnode->aggargtypes = list_copy(aggref->aggargtypes);
3028 178258 : MUTATE(newnode->aggdirectargs, aggref->aggdirectargs, List *);
3029 178258 : MUTATE(newnode->args, aggref->args, List *);
3030 178258 : MUTATE(newnode->aggorder, aggref->aggorder, List *);
3031 178258 : MUTATE(newnode->aggdistinct, aggref->aggdistinct, List *);
3032 178258 : MUTATE(newnode->aggfilter, aggref->aggfilter, Expr *);
3033 178258 : return (Node *) newnode;
3034 : }
3035 : break;
3036 1466 : case T_GroupingFunc:
3037 : {
3038 1466 : GroupingFunc *grouping = (GroupingFunc *) node;
3039 : GroupingFunc *newnode;
3040 :
3041 1466 : FLATCOPY(newnode, grouping, GroupingFunc);
3042 1466 : 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 1466 : newnode->refs = list_copy(grouping->refs);
3054 1466 : newnode->cols = list_copy(grouping->cols);
3055 :
3056 1466 : return (Node *) newnode;
3057 : }
3058 : break;
3059 5306 : case T_WindowFunc:
3060 : {
3061 5306 : WindowFunc *wfunc = (WindowFunc *) node;
3062 : WindowFunc *newnode;
3063 :
3064 5306 : FLATCOPY(newnode, wfunc, WindowFunc);
3065 5306 : MUTATE(newnode->args, wfunc->args, List *);
3066 5306 : MUTATE(newnode->aggfilter, wfunc->aggfilter, Expr *);
3067 5306 : 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 58322 : case T_SubscriptingRef:
3081 : {
3082 58322 : SubscriptingRef *sbsref = (SubscriptingRef *) node;
3083 : SubscriptingRef *newnode;
3084 :
3085 58322 : FLATCOPY(newnode, sbsref, SubscriptingRef);
3086 58322 : MUTATE(newnode->refupperindexpr, sbsref->refupperindexpr,
3087 : List *);
3088 58322 : MUTATE(newnode->reflowerindexpr, sbsref->reflowerindexpr,
3089 : List *);
3090 58322 : MUTATE(newnode->refexpr, sbsref->refexpr,
3091 : Expr *);
3092 58322 : MUTATE(newnode->refassgnexpr, sbsref->refassgnexpr,
3093 : Expr *);
3094 :
3095 58322 : return (Node *) newnode;
3096 : }
3097 : break;
3098 328384 : case T_FuncExpr:
3099 : {
3100 328384 : FuncExpr *expr = (FuncExpr *) node;
3101 : FuncExpr *newnode;
3102 :
3103 328384 : FLATCOPY(newnode, expr, FuncExpr);
3104 328384 : MUTATE(newnode->args, expr->args, List *);
3105 328384 : 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 1302894 : case T_OpExpr:
3119 : {
3120 1302894 : OpExpr *expr = (OpExpr *) node;
3121 : OpExpr *newnode;
3122 :
3123 1302894 : FLATCOPY(newnode, expr, OpExpr);
3124 1302894 : MUTATE(newnode->args, expr->args, List *);
3125 1302882 : return (Node *) newnode;
3126 : }
3127 : break;
3128 3270 : case T_DistinctExpr:
3129 : {
3130 3270 : DistinctExpr *expr = (DistinctExpr *) node;
3131 : DistinctExpr *newnode;
3132 :
3133 3270 : FLATCOPY(newnode, expr, DistinctExpr);
3134 3270 : MUTATE(newnode->args, expr->args, List *);
3135 3270 : return (Node *) newnode;
3136 : }
3137 : break;
3138 882 : case T_NullIfExpr:
3139 : {
3140 882 : NullIfExpr *expr = (NullIfExpr *) node;
3141 : NullIfExpr *newnode;
3142 :
3143 882 : FLATCOPY(newnode, expr, NullIfExpr);
3144 882 : MUTATE(newnode->args, expr->args, List *);
3145 882 : return (Node *) newnode;
3146 : }
3147 : break;
3148 93716 : case T_ScalarArrayOpExpr:
3149 : {
3150 93716 : ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
3151 : ScalarArrayOpExpr *newnode;
3152 :
3153 93716 : FLATCOPY(newnode, expr, ScalarArrayOpExpr);
3154 93716 : MUTATE(newnode->args, expr->args, List *);
3155 93716 : return (Node *) newnode;
3156 : }
3157 : break;
3158 158348 : case T_BoolExpr:
3159 : {
3160 158348 : BoolExpr *expr = (BoolExpr *) node;
3161 : BoolExpr *newnode;
3162 :
3163 158348 : FLATCOPY(newnode, expr, BoolExpr);
3164 158348 : MUTATE(newnode->args, expr->args, List *);
3165 158342 : return (Node *) newnode;
3166 : }
3167 : break;
3168 56840 : case T_SubLink:
3169 : {
3170 56840 : SubLink *sublink = (SubLink *) node;
3171 : SubLink *newnode;
3172 :
3173 56840 : FLATCOPY(newnode, sublink, SubLink);
3174 56840 : 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 56840 : MUTATE(newnode->subselect, sublink->subselect, Node *);
3181 56840 : return (Node *) newnode;
3182 : }
3183 : break;
3184 19132 : case T_SubPlan:
3185 : {
3186 19132 : SubPlan *subplan = (SubPlan *) node;
3187 : SubPlan *newnode;
3188 :
3189 19132 : FLATCOPY(newnode, subplan, SubPlan);
3190 : /* transform testexpr */
3191 19132 : MUTATE(newnode->testexpr, subplan->testexpr, Node *);
3192 : /* transform args list (params to be passed to subplan) */
3193 19132 : MUTATE(newnode->args, subplan->args, List *);
3194 : /* but not the sub-Plan itself, which is referenced as-is */
3195 19132 : return (Node *) newnode;
3196 : }
3197 : break;
3198 216 : case T_AlternativeSubPlan:
3199 : {
3200 216 : AlternativeSubPlan *asplan = (AlternativeSubPlan *) node;
3201 : AlternativeSubPlan *newnode;
3202 :
3203 216 : FLATCOPY(newnode, asplan, AlternativeSubPlan);
3204 216 : MUTATE(newnode->subplans, asplan->subplans, List *);
3205 216 : return (Node *) newnode;
3206 : }
3207 : break;
3208 8370 : case T_FieldSelect:
3209 : {
3210 8370 : FieldSelect *fselect = (FieldSelect *) node;
3211 : FieldSelect *newnode;
3212 :
3213 8370 : FLATCOPY(newnode, fselect, FieldSelect);
3214 8370 : MUTATE(newnode->arg, fselect->arg, Expr *);
3215 8370 : return (Node *) newnode;
3216 : }
3217 : break;
3218 436 : case T_FieldStore:
3219 : {
3220 436 : FieldStore *fstore = (FieldStore *) node;
3221 : FieldStore *newnode;
3222 :
3223 436 : FLATCOPY(newnode, fstore, FieldStore);
3224 436 : MUTATE(newnode->arg, fstore->arg, Expr *);
3225 436 : MUTATE(newnode->newvals, fstore->newvals, List *);
3226 436 : newnode->fieldnums = list_copy(fstore->fieldnums);
3227 436 : return (Node *) newnode;
3228 : }
3229 : break;
3230 161518 : case T_RelabelType:
3231 : {
3232 161518 : RelabelType *relabel = (RelabelType *) node;
3233 : RelabelType *newnode;
3234 :
3235 161518 : FLATCOPY(newnode, relabel, RelabelType);
3236 161518 : MUTATE(newnode->arg, relabel->arg, Expr *);
3237 161518 : return (Node *) newnode;
3238 : }
3239 : break;
3240 30314 : case T_CoerceViaIO:
3241 : {
3242 30314 : CoerceViaIO *iocoerce = (CoerceViaIO *) node;
3243 : CoerceViaIO *newnode;
3244 :
3245 30314 : FLATCOPY(newnode, iocoerce, CoerceViaIO);
3246 30314 : MUTATE(newnode->arg, iocoerce->arg, Expr *);
3247 30314 : return (Node *) newnode;
3248 : }
3249 : break;
3250 13688 : case T_ArrayCoerceExpr:
3251 : {
3252 13688 : ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
3253 : ArrayCoerceExpr *newnode;
3254 :
3255 13688 : FLATCOPY(newnode, acoerce, ArrayCoerceExpr);
3256 13688 : MUTATE(newnode->arg, acoerce->arg, Expr *);
3257 13688 : MUTATE(newnode->elemexpr, acoerce->elemexpr, Expr *);
3258 13688 : return (Node *) newnode;
3259 : }
3260 : break;
3261 358 : case T_ConvertRowtypeExpr:
3262 : {
3263 358 : ConvertRowtypeExpr *convexpr = (ConvertRowtypeExpr *) node;
3264 : ConvertRowtypeExpr *newnode;
3265 :
3266 358 : FLATCOPY(newnode, convexpr, ConvertRowtypeExpr);
3267 358 : MUTATE(newnode->arg, convexpr->arg, Expr *);
3268 358 : return (Node *) newnode;
3269 : }
3270 : break;
3271 7164 : case T_CollateExpr:
3272 : {
3273 7164 : CollateExpr *collate = (CollateExpr *) node;
3274 : CollateExpr *newnode;
3275 :
3276 7164 : FLATCOPY(newnode, collate, CollateExpr);
3277 7164 : MUTATE(newnode->arg, collate->arg, Expr *);
3278 7164 : return (Node *) newnode;
3279 : }
3280 : break;
3281 74882 : case T_CaseExpr:
3282 : {
3283 74882 : CaseExpr *caseexpr = (CaseExpr *) node;
3284 : CaseExpr *newnode;
3285 :
3286 74882 : FLATCOPY(newnode, caseexpr, CaseExpr);
3287 74882 : MUTATE(newnode->arg, caseexpr->arg, Expr *);
3288 74882 : MUTATE(newnode->args, caseexpr->args, List *);
3289 74882 : MUTATE(newnode->defresult, caseexpr->defresult, Expr *);
3290 74882 : return (Node *) newnode;
3291 : }
3292 : break;
3293 144216 : case T_CaseWhen:
3294 : {
3295 144216 : CaseWhen *casewhen = (CaseWhen *) node;
3296 : CaseWhen *newnode;
3297 :
3298 144216 : FLATCOPY(newnode, casewhen, CaseWhen);
3299 144216 : MUTATE(newnode->expr, casewhen->expr, Expr *);
3300 144216 : MUTATE(newnode->result, casewhen->result, Expr *);
3301 144216 : return (Node *) newnode;
3302 : }
3303 : break;
3304 48218 : case T_ArrayExpr:
3305 : {
3306 48218 : ArrayExpr *arrayexpr = (ArrayExpr *) node;
3307 : ArrayExpr *newnode;
3308 :
3309 48218 : FLATCOPY(newnode, arrayexpr, ArrayExpr);
3310 48218 : MUTATE(newnode->elements, arrayexpr->elements, List *);
3311 48218 : return (Node *) newnode;
3312 : }
3313 : break;
3314 9034 : case T_RowExpr:
3315 : {
3316 9034 : RowExpr *rowexpr = (RowExpr *) node;
3317 : RowExpr *newnode;
3318 :
3319 9034 : FLATCOPY(newnode, rowexpr, RowExpr);
3320 9034 : MUTATE(newnode->args, rowexpr->args, List *);
3321 : /* Assume colnames needn't be duplicated */
3322 9034 : return (Node *) newnode;
3323 : }
3324 : break;
3325 588 : case T_RowCompareExpr:
3326 : {
3327 588 : RowCompareExpr *rcexpr = (RowCompareExpr *) node;
3328 : RowCompareExpr *newnode;
3329 :
3330 588 : FLATCOPY(newnode, rcexpr, RowCompareExpr);
3331 588 : MUTATE(newnode->largs, rcexpr->largs, List *);
3332 588 : MUTATE(newnode->rargs, rcexpr->rargs, List *);
3333 588 : return (Node *) newnode;
3334 : }
3335 : break;
3336 10806 : case T_CoalesceExpr:
3337 : {
3338 10806 : CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
3339 : CoalesceExpr *newnode;
3340 :
3341 10806 : FLATCOPY(newnode, coalesceexpr, CoalesceExpr);
3342 10806 : MUTATE(newnode->args, coalesceexpr->args, List *);
3343 10806 : return (Node *) newnode;
3344 : }
3345 : break;
3346 1390 : case T_MinMaxExpr:
3347 : {
3348 1390 : MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
3349 : MinMaxExpr *newnode;
3350 :
3351 1390 : FLATCOPY(newnode, minmaxexpr, MinMaxExpr);
3352 1390 : MUTATE(newnode->args, minmaxexpr->args, List *);
3353 1390 : return (Node *) newnode;
3354 : }
3355 : break;
3356 822 : case T_XmlExpr:
3357 : {
3358 822 : XmlExpr *xexpr = (XmlExpr *) node;
3359 : XmlExpr *newnode;
3360 :
3361 822 : FLATCOPY(newnode, xexpr, XmlExpr);
3362 822 : MUTATE(newnode->named_args, xexpr->named_args, List *);
3363 : /* assume mutator does not care about arg_names */
3364 822 : MUTATE(newnode->args, xexpr->args, List *);
3365 822 : return (Node *) newnode;
3366 : }
3367 : break;
3368 2524 : case T_JsonReturning:
3369 : {
3370 2524 : JsonReturning *jr = (JsonReturning *) node;
3371 : JsonReturning *newnode;
3372 :
3373 2524 : FLATCOPY(newnode, jr, JsonReturning);
3374 2524 : MUTATE(newnode->format, jr->format, JsonFormat *);
3375 :
3376 2524 : return (Node *) newnode;
3377 : }
3378 168 : case T_JsonValueExpr:
3379 : {
3380 168 : JsonValueExpr *jve = (JsonValueExpr *) node;
3381 : JsonValueExpr *newnode;
3382 :
3383 168 : FLATCOPY(newnode, jve, JsonValueExpr);
3384 168 : MUTATE(newnode->raw_expr, jve->raw_expr, Expr *);
3385 168 : MUTATE(newnode->formatted_expr, jve->formatted_expr, Expr *);
3386 168 : MUTATE(newnode->format, jve->format, JsonFormat *);
3387 :
3388 168 : return (Node *) newnode;
3389 : }
3390 2524 : case T_JsonConstructorExpr:
3391 : {
3392 2524 : JsonConstructorExpr *jce = (JsonConstructorExpr *) node;
3393 : JsonConstructorExpr *newnode;
3394 :
3395 2524 : FLATCOPY(newnode, jce, JsonConstructorExpr);
3396 2524 : MUTATE(newnode->args, jce->args, List *);
3397 2524 : MUTATE(newnode->func, jce->func, Expr *);
3398 2524 : MUTATE(newnode->coercion, jce->coercion, Expr *);
3399 2524 : MUTATE(newnode->returning, jce->returning, JsonReturning *);
3400 :
3401 2524 : return (Node *) newnode;
3402 : }
3403 526 : case T_JsonIsPredicate:
3404 : {
3405 526 : JsonIsPredicate *pred = (JsonIsPredicate *) node;
3406 : JsonIsPredicate *newnode;
3407 :
3408 526 : FLATCOPY(newnode, pred, JsonIsPredicate);
3409 526 : MUTATE(newnode->expr, pred->expr, Node *);
3410 526 : MUTATE(newnode->format, pred->format, JsonFormat *);
3411 :
3412 526 : return (Node *) newnode;
3413 : }
3414 3886 : case T_JsonExpr:
3415 : {
3416 3886 : JsonExpr *jexpr = (JsonExpr *) node;
3417 : JsonExpr *newnode;
3418 :
3419 3886 : FLATCOPY(newnode, jexpr, JsonExpr);
3420 3886 : MUTATE(newnode->formatted_expr, jexpr->formatted_expr, Node *);
3421 3886 : MUTATE(newnode->path_spec, jexpr->path_spec, Node *);
3422 3880 : MUTATE(newnode->passing_values, jexpr->passing_values, List *);
3423 : /* assume mutator does not care about passing_names */
3424 3880 : MUTATE(newnode->on_empty, jexpr->on_empty, JsonBehavior *);
3425 3874 : MUTATE(newnode->on_error, jexpr->on_error, JsonBehavior *);
3426 3868 : return (Node *) newnode;
3427 : }
3428 : break;
3429 6816 : case T_JsonBehavior:
3430 : {
3431 6816 : JsonBehavior *behavior = (JsonBehavior *) node;
3432 : JsonBehavior *newnode;
3433 :
3434 6816 : FLATCOPY(newnode, behavior, JsonBehavior);
3435 6816 : MUTATE(newnode->expr, behavior->expr, Node *);
3436 6804 : return (Node *) newnode;
3437 : }
3438 : break;
3439 45366 : case T_NullTest:
3440 : {
3441 45366 : NullTest *ntest = (NullTest *) node;
3442 : NullTest *newnode;
3443 :
3444 45366 : FLATCOPY(newnode, ntest, NullTest);
3445 45366 : MUTATE(newnode->arg, ntest->arg, Expr *);
3446 45366 : return (Node *) newnode;
3447 : }
3448 : break;
3449 2338 : case T_BooleanTest:
3450 : {
3451 2338 : BooleanTest *btest = (BooleanTest *) node;
3452 : BooleanTest *newnode;
3453 :
3454 2338 : FLATCOPY(newnode, btest, BooleanTest);
3455 2338 : MUTATE(newnode->arg, btest->arg, Expr *);
3456 2338 : return (Node *) newnode;
3457 : }
3458 : break;
3459 16738 : case T_CoerceToDomain:
3460 : {
3461 16738 : CoerceToDomain *ctest = (CoerceToDomain *) node;
3462 : CoerceToDomain *newnode;
3463 :
3464 16738 : FLATCOPY(newnode, ctest, CoerceToDomain);
3465 16738 : MUTATE(newnode->arg, ctest->arg, Expr *);
3466 16738 : return (Node *) newnode;
3467 : }
3468 : break;
3469 1878 : case T_ReturningExpr:
3470 : {
3471 1878 : ReturningExpr *rexpr = (ReturningExpr *) node;
3472 : ReturningExpr *newnode;
3473 :
3474 1878 : FLATCOPY(newnode, rexpr, ReturningExpr);
3475 1878 : MUTATE(newnode->retexpr, rexpr->retexpr, Expr *);
3476 1878 : return (Node *) newnode;
3477 : }
3478 : break;
3479 4361384 : case T_TargetEntry:
3480 : {
3481 4361384 : TargetEntry *targetentry = (TargetEntry *) node;
3482 : TargetEntry *newnode;
3483 :
3484 4361384 : FLATCOPY(newnode, targetentry, TargetEntry);
3485 4361384 : MUTATE(newnode->expr, targetentry->expr, Expr *);
3486 4357324 : return (Node *) newnode;
3487 : }
3488 : break;
3489 39828 : case T_Query:
3490 : /* Do nothing with a sub-Query, per discussion above */
3491 39828 : 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 166 : case T_CommonTableExpr:
3517 : {
3518 166 : CommonTableExpr *cte = (CommonTableExpr *) node;
3519 : CommonTableExpr *newnode;
3520 :
3521 166 : 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 166 : MUTATE(newnode->ctequery, cte->ctequery, Node *);
3528 :
3529 166 : MUTATE(newnode->search_clause, cte->search_clause, CTESearchClause *);
3530 166 : MUTATE(newnode->cycle_clause, cte->cycle_clause, CTECycleClause *);
3531 :
3532 166 : 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 5454688 : 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 5454688 : resultlist = NIL;
3568 17645260 : foreach(temp, (List *) node)
3569 : {
3570 12190572 : resultlist = lappend(resultlist,
3571 12194782 : mutator((Node *) lfirst(temp),
3572 : context));
3573 : }
3574 5450478 : return (Node *) resultlist;
3575 : }
3576 : break;
3577 28972 : case T_FromExpr:
3578 : {
3579 28972 : FromExpr *from = (FromExpr *) node;
3580 : FromExpr *newnode;
3581 :
3582 28972 : FLATCOPY(newnode, from, FromExpr);
3583 28972 : MUTATE(newnode->fromlist, from->fromlist, List *);
3584 28972 : MUTATE(newnode->quals, from->quals, Node *);
3585 28972 : return (Node *) newnode;
3586 : }
3587 : break;
3588 360 : case T_OnConflictExpr:
3589 : {
3590 360 : OnConflictExpr *oc = (OnConflictExpr *) node;
3591 : OnConflictExpr *newnode;
3592 :
3593 360 : FLATCOPY(newnode, oc, OnConflictExpr);
3594 360 : MUTATE(newnode->arbiterElems, oc->arbiterElems, List *);
3595 360 : MUTATE(newnode->arbiterWhere, oc->arbiterWhere, Node *);
3596 360 : MUTATE(newnode->onConflictSet, oc->onConflictSet, List *);
3597 360 : MUTATE(newnode->onConflictWhere, oc->onConflictWhere, Node *);
3598 360 : MUTATE(newnode->exclRelTlist, oc->exclRelTlist, List *);
3599 :
3600 360 : return (Node *) newnode;
3601 : }
3602 : break;
3603 1062 : case T_MergeAction:
3604 : {
3605 1062 : MergeAction *action = (MergeAction *) node;
3606 : MergeAction *newnode;
3607 :
3608 1062 : FLATCOPY(newnode, action, MergeAction);
3609 1062 : MUTATE(newnode->qual, action->qual, Node *);
3610 1062 : MUTATE(newnode->targetList, action->targetList, List *);
3611 :
3612 1062 : return (Node *) newnode;
3613 : }
3614 : break;
3615 156 : case T_PartitionPruneStepOp:
3616 : {
3617 156 : PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;
3618 : PartitionPruneStepOp *newnode;
3619 :
3620 156 : FLATCOPY(newnode, opstep, PartitionPruneStepOp);
3621 156 : MUTATE(newnode->exprs, opstep->exprs, List *);
3622 :
3623 156 : return (Node *) newnode;
3624 : }
3625 : break;
3626 12 : case T_PartitionPruneStepCombine:
3627 : /* no expression sub-nodes */
3628 12 : return copyObject(node);
3629 4648 : case T_JoinExpr:
3630 : {
3631 4648 : JoinExpr *join = (JoinExpr *) node;
3632 : JoinExpr *newnode;
3633 :
3634 4648 : FLATCOPY(newnode, join, JoinExpr);
3635 4648 : MUTATE(newnode->larg, join->larg, Node *);
3636 4648 : MUTATE(newnode->rarg, join->rarg, Node *);
3637 4648 : MUTATE(newnode->quals, join->quals, Node *);
3638 : /* We do not mutate alias or using by default */
3639 4648 : return (Node *) newnode;
3640 : }
3641 : break;
3642 202 : case T_SetOperationStmt:
3643 : {
3644 202 : SetOperationStmt *setop = (SetOperationStmt *) node;
3645 : SetOperationStmt *newnode;
3646 :
3647 202 : FLATCOPY(newnode, setop, SetOperationStmt);
3648 202 : MUTATE(newnode->larg, setop->larg, Node *);
3649 202 : MUTATE(newnode->rarg, setop->rarg, Node *);
3650 : /* We do not mutate groupClauses by default */
3651 202 : return (Node *) newnode;
3652 : }
3653 : break;
3654 522 : case T_IndexClause:
3655 : {
3656 522 : IndexClause *iclause = (IndexClause *) node;
3657 : IndexClause *newnode;
3658 :
3659 522 : FLATCOPY(newnode, iclause, IndexClause);
3660 522 : MUTATE(newnode->rinfo, iclause->rinfo, RestrictInfo *);
3661 522 : MUTATE(newnode->indexquals, iclause->indexquals, List *);
3662 522 : return (Node *) newnode;
3663 : }
3664 : break;
3665 14352 : case T_PlaceHolderVar:
3666 : {
3667 14352 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
3668 : PlaceHolderVar *newnode;
3669 :
3670 14352 : FLATCOPY(newnode, phv, PlaceHolderVar);
3671 14352 : MUTATE(newnode->phexpr, phv->phexpr, Expr *);
3672 : /* Assume we need not copy the relids bitmapsets */
3673 14352 : return (Node *) newnode;
3674 : }
3675 : break;
3676 2506 : case T_InferenceElem:
3677 : {
3678 2506 : InferenceElem *inferenceelemdexpr = (InferenceElem *) node;
3679 : InferenceElem *newnode;
3680 :
3681 2506 : FLATCOPY(newnode, inferenceelemdexpr, InferenceElem);
3682 2506 : MUTATE(newnode->expr, newnode->expr, Node *);
3683 2506 : return (Node *) newnode;
3684 : }
3685 : break;
3686 25510 : case T_AppendRelInfo:
3687 : {
3688 25510 : AppendRelInfo *appinfo = (AppendRelInfo *) node;
3689 : AppendRelInfo *newnode;
3690 :
3691 25510 : FLATCOPY(newnode, appinfo, AppendRelInfo);
3692 25510 : MUTATE(newnode->translated_vars, appinfo->translated_vars, List *);
3693 : /* Assume nothing need be done with parent_colnos[] */
3694 25510 : 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 101918 : case T_RangeTblFunction:
3709 : {
3710 101918 : RangeTblFunction *rtfunc = (RangeTblFunction *) node;
3711 : RangeTblFunction *newnode;
3712 :
3713 101918 : FLATCOPY(newnode, rtfunc, RangeTblFunction);
3714 101918 : MUTATE(newnode->funcexpr, rtfunc->funcexpr, Node *);
3715 : /* Assume we need not copy the coldef info lists */
3716 101918 : return (Node *) newnode;
3717 : }
3718 : break;
3719 478 : case T_TableSampleClause:
3720 : {
3721 478 : TableSampleClause *tsc = (TableSampleClause *) node;
3722 : TableSampleClause *newnode;
3723 :
3724 478 : FLATCOPY(newnode, tsc, TableSampleClause);
3725 478 : MUTATE(newnode->args, tsc->args, List *);
3726 478 : MUTATE(newnode->repeatable, tsc->repeatable, Expr *);
3727 478 : return (Node *) newnode;
3728 : }
3729 : break;
3730 1028 : case T_TableFunc:
3731 : {
3732 1028 : TableFunc *tf = (TableFunc *) node;
3733 : TableFunc *newnode;
3734 :
3735 1028 : FLATCOPY(newnode, tf, TableFunc);
3736 1028 : MUTATE(newnode->ns_uris, tf->ns_uris, List *);
3737 1028 : MUTATE(newnode->docexpr, tf->docexpr, Node *);
3738 1028 : MUTATE(newnode->rowexpr, tf->rowexpr, Node *);
3739 1028 : MUTATE(newnode->colexprs, tf->colexprs, List *);
3740 1028 : MUTATE(newnode->coldefexprs, tf->coldefexprs, List *);
3741 1028 : MUTATE(newnode->colvalexprs, tf->colvalexprs, List *);
3742 1028 : MUTATE(newnode->passingvalexprs, tf->passingvalexprs, List *);
3743 1028 : 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 28690 : 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 28690 : if (!(flags & QTW_DONT_COPY_QUERY))
3784 : {
3785 : Query *newquery;
3786 :
3787 28690 : FLATCOPY(newquery, query, Query);
3788 28690 : query = newquery;
3789 : }
3790 :
3791 28690 : MUTATE(query->targetList, query->targetList, List *);
3792 28690 : MUTATE(query->withCheckOptions, query->withCheckOptions, List *);
3793 28690 : MUTATE(query->onConflict, query->onConflict, OnConflictExpr *);
3794 28690 : MUTATE(query->mergeActionList, query->mergeActionList, List *);
3795 28690 : MUTATE(query->mergeJoinCondition, query->mergeJoinCondition, Node *);
3796 28690 : MUTATE(query->returningList, query->returningList, List *);
3797 28690 : MUTATE(query->jointree, query->jointree, FromExpr *);
3798 28690 : MUTATE(query->setOperations, query->setOperations, Node *);
3799 28690 : MUTATE(query->havingQual, query->havingQual, Node *);
3800 28690 : MUTATE(query->limitOffset, query->limitOffset, Node *);
3801 28690 : 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 28690 : 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 28690 : resultlist = NIL;
3826 28738 : foreach(temp, query->windowClause)
3827 : {
3828 48 : WindowClause *wc = lfirst_node(WindowClause, temp);
3829 : WindowClause *newnode;
3830 :
3831 48 : FLATCOPY(newnode, wc, WindowClause);
3832 48 : MUTATE(newnode->startOffset, wc->startOffset, Node *);
3833 48 : MUTATE(newnode->endOffset, wc->endOffset, Node *);
3834 :
3835 48 : resultlist = lappend(resultlist, (Node *) newnode);
3836 : }
3837 28690 : 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 28690 : if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
3853 28690 : MUTATE(query->cteList, query->cteList, List *);
3854 : else /* else copy CTE list as-is */
3855 0 : query->cteList = copyObject(query->cteList);
3856 28690 : query->rtable = range_table_mutator(query->rtable,
3857 : mutator, context, flags);
3858 28690 : 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 28690 : range_table_mutator_impl(List *rtable,
3868 : tree_mutator_callback mutator,
3869 : void *context,
3870 : int flags)
3871 : {
3872 28690 : List *newrt = NIL;
3873 : ListCell *rt;
3874 :
3875 79784 : foreach(rt, rtable)
3876 : {
3877 51094 : RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
3878 : RangeTblEntry *newrte;
3879 :
3880 51094 : FLATCOPY(newrte, rte, RangeTblEntry);
3881 51094 : switch (rte->rtekind)
3882 : {
3883 33856 : case RTE_RELATION:
3884 33856 : MUTATE(newrte->tablesample, rte->tablesample,
3885 : TableSampleClause *);
3886 : /* we don't bother to copy eref, aliases, etc; OK? */
3887 33856 : break;
3888 3894 : case RTE_SUBQUERY:
3889 3894 : if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
3890 3894 : 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 3894 : break;
3897 4658 : case RTE_JOIN:
3898 4658 : if (!(flags & QTW_IGNORE_JOINALIASES))
3899 4182 : MUTATE(newrte->joinaliasvars, rte->joinaliasvars, List *);
3900 : else
3901 : {
3902 : /* else, copy join aliases as-is */
3903 476 : newrte->joinaliasvars = copyObject(rte->joinaliasvars);
3904 : }
3905 4658 : break;
3906 6450 : case RTE_FUNCTION:
3907 6450 : MUTATE(newrte->functions, rte->functions, List *);
3908 6450 : break;
3909 0 : case RTE_TABLEFUNC:
3910 0 : MUTATE(newrte->tablefunc, rte->tablefunc, TableFunc *);
3911 0 : break;
3912 1480 : case RTE_VALUES:
3913 1480 : MUTATE(newrte->values_lists, rte->values_lists, List *);
3914 1480 : break;
3915 502 : case RTE_CTE:
3916 : case RTE_NAMEDTUPLESTORE:
3917 : case RTE_RESULT:
3918 : /* nothing to do */
3919 502 : break;
3920 254 : case RTE_GROUP:
3921 254 : if (!(flags & QTW_IGNORE_GROUPEXPRS))
3922 254 : 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 254 : break;
3929 : }
3930 51094 : MUTATE(newrte->securityQuals, rte->securityQuals, List *);
3931 51094 : newrt = lappend(newrt, newrte);
3932 : }
3933 28690 : 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 4228332 : query_or_expression_tree_walker_impl(Node *node,
3946 : tree_walker_callback walker,
3947 : void *context,
3948 : int flags)
3949 : {
3950 4228332 : if (node && IsA(node, Query))
3951 461084 : return query_tree_walker((Query *) node,
3952 : walker,
3953 : context,
3954 : flags);
3955 : else
3956 3767248 : 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 655252 : query_or_expression_tree_mutator_impl(Node *node,
3969 : tree_mutator_callback mutator,
3970 : void *context,
3971 : int flags)
3972 : {
3973 655252 : if (node && IsA(node, Query))
3974 8010 : return (Node *) query_tree_mutator((Query *) node,
3975 : mutator,
3976 : context,
3977 : flags);
3978 : else
3979 647242 : 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 12328742 : 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 12328742 : if (node == NULL)
4010 0 : return false;
4011 :
4012 : /* Guard against stack overflow due to overly complex expressions */
4013 12328742 : check_stack_depth();
4014 :
4015 12328742 : switch (nodeTag(node))
4016 : {
4017 1534944 : 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 1534944 : break;
4033 392520 : case T_Alias:
4034 : /* we assume the colnames list isn't interesting */
4035 392520 : break;
4036 640424 : case T_RangeVar:
4037 640424 : return WALK(((RangeVar *) node)->alias);
4038 472 : case T_GroupingFunc:
4039 472 : return WALK(((GroupingFunc *) node)->args);
4040 54370 : case T_SubLink:
4041 : {
4042 54370 : SubLink *sublink = (SubLink *) node;
4043 :
4044 54370 : if (WALK(sublink->testexpr))
4045 0 : return true;
4046 : /* we assume the operName is not interesting */
4047 54370 : if (WALK(sublink->subselect))
4048 0 : return true;
4049 : }
4050 54370 : break;
4051 44422 : case T_CaseExpr:
4052 : {
4053 44422 : CaseExpr *caseexpr = (CaseExpr *) node;
4054 :
4055 44422 : if (WALK(caseexpr->arg))
4056 0 : return true;
4057 : /* we assume walker doesn't care about CaseWhens, either */
4058 118880 : foreach(temp, caseexpr->args)
4059 : {
4060 74458 : CaseWhen *when = lfirst_node(CaseWhen, temp);
4061 :
4062 74458 : if (WALK(when->expr))
4063 0 : return true;
4064 74458 : if (WALK(when->result))
4065 0 : return true;
4066 : }
4067 44422 : if (WALK(caseexpr->defresult))
4068 0 : return true;
4069 : }
4070 44422 : break;
4071 7690 : case T_RowExpr:
4072 : /* Assume colnames isn't interesting */
4073 7690 : return WALK(((RowExpr *) node)->args);
4074 6072 : case T_CoalesceExpr:
4075 6072 : return WALK(((CoalesceExpr *) node)->args);
4076 390 : case T_MinMaxExpr:
4077 390 : return WALK(((MinMaxExpr *) node)->args);
4078 620 : case T_XmlExpr:
4079 : {
4080 620 : XmlExpr *xexpr = (XmlExpr *) node;
4081 :
4082 620 : if (WALK(xexpr->named_args))
4083 0 : return true;
4084 : /* we assume walker doesn't care about arg_names */
4085 620 : if (WALK(xexpr->args))
4086 0 : return true;
4087 : }
4088 620 : break;
4089 1504 : case T_JsonReturning:
4090 1504 : return WALK(((JsonReturning *) node)->format);
4091 3986 : case T_JsonValueExpr:
4092 : {
4093 3986 : JsonValueExpr *jve = (JsonValueExpr *) node;
4094 :
4095 3986 : if (WALK(jve->raw_expr))
4096 0 : return true;
4097 3986 : if (WALK(jve->formatted_expr))
4098 0 : return true;
4099 3986 : if (WALK(jve->format))
4100 0 : return true;
4101 : }
4102 3986 : break;
4103 164 : case T_JsonParseExpr:
4104 : {
4105 164 : JsonParseExpr *jpe = (JsonParseExpr *) node;
4106 :
4107 164 : if (WALK(jpe->expr))
4108 0 : return true;
4109 164 : if (WALK(jpe->output))
4110 0 : return true;
4111 : }
4112 164 : break;
4113 112 : case T_JsonScalarExpr:
4114 : {
4115 112 : JsonScalarExpr *jse = (JsonScalarExpr *) node;
4116 :
4117 112 : if (WALK(jse->expr))
4118 0 : return true;
4119 112 : if (WALK(jse->output))
4120 0 : return true;
4121 : }
4122 112 : break;
4123 108 : case T_JsonSerializeExpr:
4124 : {
4125 108 : JsonSerializeExpr *jse = (JsonSerializeExpr *) node;
4126 :
4127 108 : if (WALK(jse->expr))
4128 0 : return true;
4129 108 : if (WALK(jse->output))
4130 0 : return true;
4131 : }
4132 108 : 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 362 : case T_JsonIsPredicate:
4148 362 : return WALK(((JsonIsPredicate *) node)->expr);
4149 378 : case T_JsonArgument:
4150 378 : return WALK(((JsonArgument *) node)->val);
4151 1524 : case T_JsonFuncExpr:
4152 : {
4153 1524 : JsonFuncExpr *jfe = (JsonFuncExpr *) node;
4154 :
4155 1524 : if (WALK(jfe->context_item))
4156 0 : return true;
4157 1524 : if (WALK(jfe->pathspec))
4158 0 : return true;
4159 1524 : if (WALK(jfe->passing))
4160 0 : return true;
4161 1524 : if (WALK(jfe->output))
4162 0 : return true;
4163 1524 : if (WALK(jfe->on_empty))
4164 0 : return true;
4165 1524 : if (WALK(jfe->on_error))
4166 0 : return true;
4167 : }
4168 1524 : break;
4169 1098 : case T_JsonBehavior:
4170 : {
4171 1098 : JsonBehavior *jb = (JsonBehavior *) node;
4172 :
4173 1098 : if (WALK(jb->expr))
4174 0 : return true;
4175 : }
4176 1098 : break;
4177 524 : case T_JsonTable:
4178 : {
4179 524 : JsonTable *jt = (JsonTable *) node;
4180 :
4181 524 : if (WALK(jt->context_item))
4182 0 : return true;
4183 524 : if (WALK(jt->pathspec))
4184 0 : return true;
4185 524 : if (WALK(jt->passing))
4186 0 : return true;
4187 524 : if (WALK(jt->columns))
4188 0 : return true;
4189 524 : if (WALK(jt->on_error))
4190 0 : return true;
4191 : }
4192 524 : break;
4193 1342 : case T_JsonTableColumn:
4194 : {
4195 1342 : JsonTableColumn *jtc = (JsonTableColumn *) node;
4196 :
4197 1342 : if (WALK(jtc->typeName))
4198 0 : return true;
4199 1342 : if (WALK(jtc->on_empty))
4200 0 : return true;
4201 1342 : if (WALK(jtc->on_error))
4202 0 : return true;
4203 1342 : if (WALK(jtc->columns))
4204 0 : return true;
4205 : }
4206 1342 : break;
4207 524 : case T_JsonTablePathSpec:
4208 524 : return WALK(((JsonTablePathSpec *) node)->string);
4209 23964 : case T_NullTest:
4210 23964 : return WALK(((NullTest *) node)->arg);
4211 924 : case T_BooleanTest:
4212 924 : return WALK(((BooleanTest *) node)->arg);
4213 111936 : case T_JoinExpr:
4214 : {
4215 111936 : JoinExpr *join = (JoinExpr *) node;
4216 :
4217 111936 : if (WALK(join->larg))
4218 0 : return true;
4219 111936 : if (WALK(join->rarg))
4220 0 : return true;
4221 111936 : if (WALK(join->quals))
4222 0 : return true;
4223 111936 : if (WALK(join->alias))
4224 0 : return true;
4225 : /* using list is deemed uninteresting */
4226 : }
4227 111936 : break;
4228 30 : case T_IntoClause:
4229 : {
4230 30 : IntoClause *into = (IntoClause *) node;
4231 :
4232 30 : 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 30 : if (WALK(into->viewQuery))
4237 0 : return true;
4238 : }
4239 30 : break;
4240 2270226 : case T_List:
4241 6436442 : foreach(temp, (List *) node)
4242 : {
4243 4166318 : if (WALK((Node *) lfirst(temp)))
4244 0 : return true;
4245 : }
4246 2270124 : break;
4247 72084 : case T_InsertStmt:
4248 : {
4249 72084 : InsertStmt *stmt = (InsertStmt *) node;
4250 :
4251 72084 : if (WALK(stmt->relation))
4252 0 : return true;
4253 72084 : if (WALK(stmt->cols))
4254 0 : return true;
4255 72084 : if (WALK(stmt->selectStmt))
4256 0 : return true;
4257 72084 : if (WALK(stmt->onConflictClause))
4258 0 : return true;
4259 72084 : if (WALK(stmt->returningClause))
4260 0 : return true;
4261 72084 : if (WALK(stmt->withClause))
4262 0 : return true;
4263 : }
4264 72084 : break;
4265 4648 : case T_DeleteStmt:
4266 : {
4267 4648 : DeleteStmt *stmt = (DeleteStmt *) node;
4268 :
4269 4648 : if (WALK(stmt->relation))
4270 0 : return true;
4271 4648 : if (WALK(stmt->usingClause))
4272 0 : return true;
4273 4648 : if (WALK(stmt->whereClause))
4274 0 : return true;
4275 4648 : if (WALK(stmt->returningClause))
4276 0 : return true;
4277 4648 : if (WALK(stmt->withClause))
4278 0 : return true;
4279 : }
4280 4648 : break;
4281 14826 : case T_UpdateStmt:
4282 : {
4283 14826 : UpdateStmt *stmt = (UpdateStmt *) node;
4284 :
4285 14826 : if (WALK(stmt->relation))
4286 0 : return true;
4287 14826 : if (WALK(stmt->targetList))
4288 0 : return true;
4289 14826 : if (WALK(stmt->whereClause))
4290 0 : return true;
4291 14826 : if (WALK(stmt->fromClause))
4292 0 : return true;
4293 14826 : if (WALK(stmt->returningClause))
4294 0 : return true;
4295 14826 : if (WALK(stmt->withClause))
4296 0 : return true;
4297 : }
4298 14826 : break;
4299 2152 : case T_MergeStmt:
4300 : {
4301 2152 : MergeStmt *stmt = (MergeStmt *) node;
4302 :
4303 2152 : if (WALK(stmt->relation))
4304 0 : return true;
4305 2152 : if (WALK(stmt->sourceRelation))
4306 0 : return true;
4307 2152 : if (WALK(stmt->joinCondition))
4308 0 : return true;
4309 2152 : if (WALK(stmt->mergeWhenClauses))
4310 0 : return true;
4311 2152 : if (WALK(stmt->returningClause))
4312 0 : return true;
4313 2152 : if (WALK(stmt->withClause))
4314 0 : return true;
4315 : }
4316 2152 : break;
4317 3312 : case T_MergeWhenClause:
4318 : {
4319 3312 : MergeWhenClause *mergeWhenClause = (MergeWhenClause *) node;
4320 :
4321 3312 : if (WALK(mergeWhenClause->condition))
4322 0 : return true;
4323 3312 : if (WALK(mergeWhenClause->targetList))
4324 0 : return true;
4325 3312 : if (WALK(mergeWhenClause->values))
4326 0 : return true;
4327 : }
4328 3312 : break;
4329 3642 : case T_ReturningClause:
4330 : {
4331 3642 : ReturningClause *returning = (ReturningClause *) node;
4332 :
4333 3642 : if (WALK(returning->options))
4334 0 : return true;
4335 3642 : if (WALK(returning->exprs))
4336 0 : return true;
4337 : }
4338 3642 : break;
4339 716790 : case T_SelectStmt:
4340 : {
4341 716790 : SelectStmt *stmt = (SelectStmt *) node;
4342 :
4343 716790 : if (WALK(stmt->distinctClause))
4344 0 : return true;
4345 716790 : if (WALK(stmt->intoClause))
4346 0 : return true;
4347 716790 : if (WALK(stmt->targetList))
4348 0 : return true;
4349 716784 : if (WALK(stmt->fromClause))
4350 0 : return true;
4351 716700 : if (WALK(stmt->whereClause))
4352 0 : return true;
4353 716694 : if (WALK(stmt->groupClause))
4354 0 : return true;
4355 716694 : if (WALK(stmt->havingClause))
4356 0 : return true;
4357 716694 : if (WALK(stmt->windowClause))
4358 0 : return true;
4359 716694 : if (WALK(stmt->valuesLists))
4360 0 : return true;
4361 716694 : if (WALK(stmt->sortClause))
4362 0 : return true;
4363 716694 : if (WALK(stmt->limitOffset))
4364 0 : return true;
4365 716694 : if (WALK(stmt->limitCount))
4366 0 : return true;
4367 716694 : if (WALK(stmt->lockingClause))
4368 0 : return true;
4369 716694 : if (WALK(stmt->withClause))
4370 0 : return true;
4371 716694 : if (WALK(stmt->larg))
4372 0 : return true;
4373 716694 : if (WALK(stmt->rarg))
4374 0 : return true;
4375 : }
4376 716682 : 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 784812 : case T_A_Expr:
4388 : {
4389 784812 : A_Expr *expr = (A_Expr *) node;
4390 :
4391 784812 : if (WALK(expr->lexpr))
4392 0 : return true;
4393 784812 : if (WALK(expr->rexpr))
4394 0 : return true;
4395 : /* operator name is deemed uninteresting */
4396 : }
4397 784812 : break;
4398 208720 : case T_BoolExpr:
4399 : {
4400 208720 : BoolExpr *expr = (BoolExpr *) node;
4401 :
4402 208720 : if (WALK(expr->args))
4403 0 : return true;
4404 : }
4405 208720 : break;
4406 2378766 : case T_ColumnRef:
4407 : /* we assume the fields contain nothing interesting */
4408 2378766 : break;
4409 455550 : case T_FuncCall:
4410 : {
4411 455550 : FuncCall *fcall = (FuncCall *) node;
4412 :
4413 455550 : if (WALK(fcall->args))
4414 0 : return true;
4415 455550 : if (WALK(fcall->agg_order))
4416 0 : return true;
4417 455550 : if (WALK(fcall->agg_filter))
4418 0 : return true;
4419 455550 : if (WALK(fcall->over))
4420 0 : return true;
4421 : /* function name is deemed uninteresting */
4422 : }
4423 455550 : break;
4424 46992 : case T_NamedArgExpr:
4425 46992 : return WALK(((NamedArgExpr *) node)->arg);
4426 20306 : case T_A_Indices:
4427 : {
4428 20306 : A_Indices *indices = (A_Indices *) node;
4429 :
4430 20306 : if (WALK(indices->lidx))
4431 0 : return true;
4432 20306 : if (WALK(indices->uidx))
4433 0 : return true;
4434 : }
4435 20306 : break;
4436 32936 : case T_A_Indirection:
4437 : {
4438 32936 : A_Indirection *indir = (A_Indirection *) node;
4439 :
4440 32936 : if (WALK(indir->arg))
4441 0 : return true;
4442 32936 : if (WALK(indir->indirection))
4443 0 : return true;
4444 : }
4445 32936 : break;
4446 9412 : case T_A_ArrayExpr:
4447 9412 : return WALK(((A_ArrayExpr *) node)->elements);
4448 1454578 : case T_ResTarget:
4449 : {
4450 1454578 : ResTarget *rt = (ResTarget *) node;
4451 :
4452 1454578 : if (WALK(rt->indirection))
4453 0 : return true;
4454 1454578 : if (WALK(rt->val))
4455 0 : return true;
4456 : }
4457 1454572 : break;
4458 396 : case T_MultiAssignRef:
4459 396 : return WALK(((MultiAssignRef *) node)->source);
4460 371566 : case T_TypeCast:
4461 : {
4462 371566 : TypeCast *tc = (TypeCast *) node;
4463 :
4464 371566 : if (WALK(tc->arg))
4465 0 : return true;
4466 371566 : if (WALK(tc->typeName))
4467 0 : return true;
4468 : }
4469 371566 : break;
4470 10002 : case T_CollateClause:
4471 10002 : return WALK(((CollateClause *) node)->arg);
4472 119090 : case T_SortBy:
4473 119090 : return WALK(((SortBy *) node)->node);
4474 5048 : case T_WindowDef:
4475 : {
4476 5048 : WindowDef *wd = (WindowDef *) node;
4477 :
4478 5048 : if (WALK(wd->partitionClause))
4479 0 : return true;
4480 5048 : if (WALK(wd->orderClause))
4481 0 : return true;
4482 5048 : if (WALK(wd->startOffset))
4483 0 : return true;
4484 5048 : if (WALK(wd->endOffset))
4485 0 : return true;
4486 : }
4487 5048 : break;
4488 26570 : case T_RangeSubselect:
4489 : {
4490 26570 : RangeSubselect *rs = (RangeSubselect *) node;
4491 :
4492 26570 : if (WALK(rs->subquery))
4493 0 : return true;
4494 26564 : if (WALK(rs->alias))
4495 0 : return true;
4496 : }
4497 26564 : break;
4498 67156 : case T_RangeFunction:
4499 : {
4500 67156 : RangeFunction *rf = (RangeFunction *) node;
4501 :
4502 67156 : if (WALK(rf->functions))
4503 0 : return true;
4504 67156 : if (WALK(rf->alias))
4505 0 : return true;
4506 67156 : if (WALK(rf->coldeflist))
4507 0 : return true;
4508 : }
4509 67156 : break;
4510 320 : case T_RangeTableSample:
4511 : {
4512 320 : RangeTableSample *rts = (RangeTableSample *) node;
4513 :
4514 320 : if (WALK(rts->relation))
4515 0 : return true;
4516 : /* method name is deemed uninteresting */
4517 320 : if (WALK(rts->args))
4518 0 : return true;
4519 320 : if (WALK(rts->repeatable))
4520 0 : return true;
4521 : }
4522 320 : break;
4523 232 : case T_RangeTableFunc:
4524 : {
4525 232 : RangeTableFunc *rtf = (RangeTableFunc *) node;
4526 :
4527 232 : if (WALK(rtf->docexpr))
4528 0 : return true;
4529 232 : if (WALK(rtf->rowexpr))
4530 0 : return true;
4531 232 : if (WALK(rtf->namespaces))
4532 0 : return true;
4533 232 : if (WALK(rtf->columns))
4534 0 : return true;
4535 232 : if (WALK(rtf->alias))
4536 0 : return true;
4537 : }
4538 232 : break;
4539 822 : case T_RangeTableFuncCol:
4540 : {
4541 822 : RangeTableFuncCol *rtfc = (RangeTableFuncCol *) node;
4542 :
4543 822 : if (WALK(rtfc->colexpr))
4544 0 : return true;
4545 822 : if (WALK(rtfc->coldefexpr))
4546 0 : return true;
4547 : }
4548 822 : break;
4549 376232 : case T_TypeName:
4550 : {
4551 376232 : TypeName *tn = (TypeName *) node;
4552 :
4553 376232 : if (WALK(tn->typmods))
4554 0 : return true;
4555 376232 : if (WALK(tn->arrayBounds))
4556 0 : return true;
4557 : /* type name itself is deemed uninteresting */
4558 : }
4559 376232 : break;
4560 1976 : case T_ColumnDef:
4561 : {
4562 1976 : ColumnDef *coldef = (ColumnDef *) node;
4563 :
4564 1976 : if (WALK(coldef->typeName))
4565 0 : return true;
4566 1976 : if (WALK(coldef->raw_default))
4567 0 : return true;
4568 1976 : if (WALK(coldef->collClause))
4569 0 : return true;
4570 : /* for now, constraints are ignored */
4571 : }
4572 1976 : break;
4573 2008 : case T_IndexElem:
4574 : {
4575 2008 : IndexElem *indelem = (IndexElem *) node;
4576 :
4577 2008 : if (WALK(indelem->expr))
4578 0 : return true;
4579 : /* collation and opclass names are deemed uninteresting */
4580 : }
4581 2008 : break;
4582 1740 : case T_GroupingSet:
4583 1740 : return WALK(((GroupingSet *) node)->content);
4584 16970 : case T_LockingClause:
4585 16970 : return WALK(((LockingClause *) node)->lockedRels);
4586 218 : case T_XmlSerialize:
4587 : {
4588 218 : XmlSerialize *xs = (XmlSerialize *) node;
4589 :
4590 218 : if (WALK(xs->expr))
4591 0 : return true;
4592 218 : if (WALK(xs->typeName))
4593 0 : return true;
4594 : }
4595 218 : break;
4596 4658 : case T_WithClause:
4597 4658 : return WALK(((WithClause *) node)->ctes);
4598 1752 : case T_InferClause:
4599 : {
4600 1752 : InferClause *stmt = (InferClause *) node;
4601 :
4602 1752 : if (WALK(stmt->indexElems))
4603 0 : return true;
4604 1752 : if (WALK(stmt->whereClause))
4605 0 : return true;
4606 : }
4607 1752 : break;
4608 2004 : case T_OnConflictClause:
4609 : {
4610 2004 : OnConflictClause *stmt = (OnConflictClause *) node;
4611 :
4612 2004 : if (WALK(stmt->infer))
4613 0 : return true;
4614 2004 : if (WALK(stmt->targetList))
4615 0 : return true;
4616 2004 : if (WALK(stmt->whereClause))
4617 0 : return true;
4618 : }
4619 2004 : break;
4620 5992 : case T_CommonTableExpr:
4621 : /* search_clause and cycle_clause are not interesting here */
4622 5992 : return WALK(((CommonTableExpr *) node)->ctequery);
4623 1504 : case T_JsonOutput:
4624 : {
4625 1504 : JsonOutput *out = (JsonOutput *) node;
4626 :
4627 1504 : if (WALK(out->typeName))
4628 0 : return true;
4629 1504 : if (WALK(out->returning))
4630 0 : return true;
4631 : }
4632 1504 : break;
4633 808 : case T_JsonKeyValue:
4634 : {
4635 808 : JsonKeyValue *jkv = (JsonKeyValue *) node;
4636 :
4637 808 : if (WALK(jkv->key))
4638 0 : return true;
4639 808 : if (WALK(jkv->value))
4640 0 : return true;
4641 : }
4642 808 : break;
4643 440 : case T_JsonObjectConstructor:
4644 : {
4645 440 : JsonObjectConstructor *joc = (JsonObjectConstructor *) node;
4646 :
4647 440 : if (WALK(joc->output))
4648 0 : return true;
4649 440 : if (WALK(joc->exprs))
4650 0 : return true;
4651 : }
4652 440 : break;
4653 218 : case T_JsonArrayConstructor:
4654 : {
4655 218 : JsonArrayConstructor *jac = (JsonArrayConstructor *) node;
4656 :
4657 218 : if (WALK(jac->output))
4658 0 : return true;
4659 218 : if (WALK(jac->exprs))
4660 0 : return true;
4661 : }
4662 218 : break;
4663 402 : case T_JsonAggConstructor:
4664 : {
4665 402 : JsonAggConstructor *ctor = (JsonAggConstructor *) node;
4666 :
4667 402 : if (WALK(ctor->output))
4668 0 : return true;
4669 402 : if (WALK(ctor->agg_order))
4670 0 : return true;
4671 402 : if (WALK(ctor->agg_filter))
4672 0 : return true;
4673 402 : if (WALK(ctor->over))
4674 0 : return true;
4675 : }
4676 402 : break;
4677 204 : case T_JsonObjectAgg:
4678 : {
4679 204 : JsonObjectAgg *joa = (JsonObjectAgg *) node;
4680 :
4681 204 : if (WALK(joa->constructor))
4682 0 : return true;
4683 204 : if (WALK(joa->arg))
4684 0 : return true;
4685 : }
4686 204 : break;
4687 198 : case T_JsonArrayAgg:
4688 : {
4689 198 : JsonArrayAgg *jaa = (JsonArrayAgg *) node;
4690 :
4691 198 : if (WALK(jaa->constructor))
4692 0 : return true;
4693 198 : if (WALK(jaa->arg))
4694 0 : return true;
4695 : }
4696 198 : break;
4697 60 : case T_JsonArrayQueryConstructor:
4698 : {
4699 60 : JsonArrayQueryConstructor *jaqc = (JsonArrayQueryConstructor *) node;
4700 :
4701 60 : if (WALK(jaqc->output))
4702 0 : return true;
4703 60 : if (WALK(jaqc->query))
4704 0 : return true;
4705 : }
4706 60 : break;
4707 0 : default:
4708 0 : elog(ERROR, "unrecognized node type: %d",
4709 : (int) nodeTag(node));
4710 : break;
4711 : }
4712 11430564 : 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 1400900 : planstate_tree_walker_impl(PlanState *planstate,
4723 : planstate_tree_walker_callback walker,
4724 : void *context)
4725 : {
4726 1400900 : 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 1400900 : check_stack_depth();
4734 :
4735 : /* initPlan-s */
4736 1400900 : if (planstate_walk_subplans(planstate->initPlan, walker, context))
4737 0 : return true;
4738 :
4739 : /* lefttree */
4740 1400900 : if (outerPlanState(planstate))
4741 : {
4742 538030 : if (PSWALK(outerPlanState(planstate)))
4743 0 : return true;
4744 : }
4745 :
4746 : /* righttree */
4747 1400900 : if (innerPlanState(planstate))
4748 : {
4749 153188 : if (PSWALK(innerPlanState(planstate)))
4750 0 : return true;
4751 : }
4752 :
4753 : /* special child plans */
4754 1400900 : switch (nodeTag(plan))
4755 : {
4756 19772 : case T_Append:
4757 19772 : if (planstate_walk_members(((AppendState *) planstate)->appendplans,
4758 : ((AppendState *) planstate)->as_nplans,
4759 : walker, context))
4760 0 : return true;
4761 19772 : break;
4762 640 : case T_MergeAppend:
4763 640 : if (planstate_walk_members(((MergeAppendState *) planstate)->mergeplans,
4764 : ((MergeAppendState *) planstate)->ms_nplans,
4765 : walker, context))
4766 0 : return true;
4767 640 : break;
4768 250 : case T_BitmapAnd:
4769 250 : if (planstate_walk_members(((BitmapAndState *) planstate)->bitmapplans,
4770 : ((BitmapAndState *) planstate)->nplans,
4771 : walker, context))
4772 0 : return true;
4773 250 : break;
4774 438 : case T_BitmapOr:
4775 438 : if (planstate_walk_members(((BitmapOrState *) planstate)->bitmapplans,
4776 : ((BitmapOrState *) planstate)->nplans,
4777 : walker, context))
4778 0 : return true;
4779 438 : break;
4780 21502 : case T_SubqueryScan:
4781 21502 : if (PSWALK(((SubqueryScanState *) planstate)->subplan))
4782 0 : return true;
4783 21502 : 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 1358298 : default:
4792 1358298 : break;
4793 : }
4794 :
4795 : /* subPlan-s */
4796 1400900 : if (planstate_walk_subplans(planstate->subPlan, walker, context))
4797 0 : return true;
4798 :
4799 1400900 : return false;
4800 : }
4801 :
4802 : /*
4803 : * Walk a list of SubPlans (or initPlans, which also use SubPlan nodes).
4804 : */
4805 : static bool
4806 2801800 : planstate_walk_subplans(List *plans,
4807 : planstate_tree_walker_callback walker,
4808 : void *context)
4809 : {
4810 : ListCell *lc;
4811 :
4812 2845634 : foreach(lc, plans)
4813 : {
4814 43834 : SubPlanState *sps = lfirst_node(SubPlanState, lc);
4815 :
4816 43834 : if (PSWALK(sps->planstate))
4817 0 : return true;
4818 : }
4819 :
4820 2801800 : 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 21100 : planstate_walk_members(PlanState **planstates, int nplans,
4829 : planstate_tree_walker_callback walker,
4830 : void *context)
4831 : {
4832 84712 : for (int j = 0; j < nplans; j++)
4833 : {
4834 63612 : if (PSWALK(planstates[j]))
4835 0 : return true;
4836 : }
4837 :
4838 21100 : return false;
4839 : }
|
