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

Generated by: LCOV version 1.14