LCOV - code coverage report
Current view: top level - src/backend/nodes - nodeFuncs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 1923 2490 77.2 %
Date: 2023-11-29 05:10:53 Functions: 32 32 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14