/*-------------------------------------------------------------------------
 *
 * nodeFuncs.c
 *  Various general-purpose manipulations of Node trees
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/nodes/nodeFuncs.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "nodes/execnodes.h"
#include "nodes/nodeFuncs.h"
#include "nodes/pathnodes.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"

static bool expression_returns_set_walker(Node *node, void *context);
static int leftmostLoc(int loc1, int loc2);
static bool fix_opfuncids_walker(Node *node, void *context);
static bool planstate_walk_subplans(List *plans,
         planstate_tree_walker_callback walker,
         void *context);
static bool planstate_walk_members(PlanState **planstates, int nplans,
           planstate_tree_walker_callback walker,
           void *context);


/*
 * exprType -
 *   returns the Oid of the type of the expression's result.
 */
Oid
exprType(const Node *expr)
{
 Oid   type;

 if (!expr)
  return InvalidOid;

 switch (nodeTag(expr))
 {
  case T_Var:
   type = ((const Var *) expr)->vartype;
   break;
  case T_Const:
   type = ((const Const *) expr)->consttype;
   break;
  case T_Param:
   type = ((const Param *) expr)->paramtype;
   break;
  case T_Aggref:
   type = ((const Aggref *) expr)->aggtype;
   break;
  case T_GroupingFunc:
   type = INT4OID;
   break;
  case T_WindowFunc:
   type = ((const WindowFunc *) expr)->wintype;
   break;
  case T_MergeSupportFunc:
   type = ((const MergeSupportFunc *) expr)->msftype;
   break;
  case T_SubscriptingRef:
   type = ((const SubscriptingRef *) expr)->refrestype;
   break;
  case T_FuncExpr:
   type = ((const FuncExpr *) expr)->funcresulttype;
   break;
  case T_NamedArgExpr:
   type = exprType((Node *) ((const NamedArgExpr *) expr)->arg);
   break;
  case T_OpExpr:
   type = ((const OpExpr *) expr)->opresulttype;
   break;
  case T_DistinctExpr:
   type = ((const DistinctExpr *) expr)->opresulttype;
   break;
  case T_NullIfExpr:
   type = ((const NullIfExpr *) expr)->opresulttype;
   break;
  case T_ScalarArrayOpExpr:
   type = BOOLOID;
   break;
  case T_BoolExpr:
   type = BOOLOID;
   break;
  case T_SubLink:
   {
    const SubLink *sublink = (const SubLink *) expr;

    if (sublink->subLinkType == EXPR_SUBLINK ||
     sublink->subLinkType == ARRAY_SUBLINK)
    {
     /* get the type of the subselect's first target column */
     Query    *qtree = (Query *) sublink->subselect;
     TargetEntry *tent;

     if (!qtree || !IsA(qtree, Query))
      elog(ERROR, "cannot get type for untransformed sublink");
     tent = linitial_node(TargetEntry, qtree->targetList);
     Assert(!tent->resjunk);
     type = exprType((Node *) tent->expr);
     if (sublink->subLinkType == ARRAY_SUBLINK)
     {
      type = get_promoted_array_type(type);
      if (!OidIsValid(type))
       ereport(ERROR,
         (errcode(ERRCODE_UNDEFINED_OBJECT),
          errmsg("could not find array type for data type %s",
           format_type_be(exprType((Node *) tent->expr)))));
     }
    }
    else if (sublink->subLinkType == MULTIEXPR_SUBLINK)
    {
     /* MULTIEXPR is always considered to return RECORD */
     type = RECORDOID;
    }
    else
    {
     /* for all other sublink types, result is boolean */
     type = BOOLOID;
    }
   }
   break;
  case T_SubPlan:
   {
    const SubPlan *subplan = (const SubPlan *) expr;

    if (subplan->subLinkType == EXPR_SUBLINK ||
     subplan->subLinkType == ARRAY_SUBLINK)
    {
     /* get the type of the subselect's first target column */
     type = subplan->firstColType;
     if (subplan->subLinkType == ARRAY_SUBLINK)
     {
      type = get_promoted_array_type(type);
      if (!OidIsValid(type))
       ereport(ERROR,
         (errcode(ERRCODE_UNDEFINED_OBJECT),
          errmsg("could not find array type for data type %s",
           format_type_be(subplan->firstColType))));
     }
    }
    else if (subplan->subLinkType == MULTIEXPR_SUBLINK)
    {
     /* MULTIEXPR is always considered to return RECORD */
     type = RECORDOID;
    }
    else
    {
     /* for all other subplan types, result is boolean */
     type = BOOLOID;
    }
   }
   break;
  case T_AlternativeSubPlan:
   {
    const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;

    /* subplans should all return the same thing */
    type = exprType((Node *) linitial(asplan->subplans));
   }
   break;
  case T_FieldSelect:
   type = ((const FieldSelect *) expr)->resulttype;
   break;
  case T_FieldStore:
   type = ((const FieldStore *) expr)->resulttype;
   break;
  case T_RelabelType:
   type = ((const RelabelType *) expr)->resulttype;
   break;
  case T_CoerceViaIO:
   type = ((const CoerceViaIO *) expr)->resulttype;
   break;
  case T_ArrayCoerceExpr:
   type = ((const ArrayCoerceExpr *) expr)->resulttype;
   break;
  case T_ConvertRowtypeExpr:
   type = ((const ConvertRowtypeExpr *) expr)->resulttype;
   break;
  case T_CollateExpr:
   type = exprType((Node *) ((const CollateExpr *) expr)->arg);
   break;
  case T_CaseExpr:
   type = ((const CaseExpr *) expr)->casetype;
   break;
  case T_CaseTestExpr:
   type = ((const CaseTestExpr *) expr)->typeId;
   break;
  case T_ArrayExpr:
   type = ((const ArrayExpr *) expr)->array_typeid;
   break;
  case T_RowExpr:
   type = ((const RowExpr *) expr)->row_typeid;
   break;
  case T_RowCompareExpr:
   type = BOOLOID;
   break;
  case T_CoalesceExpr:
   type = ((const CoalesceExpr *) expr)->coalescetype;
   break;
  case T_MinMaxExpr:
   type = ((const MinMaxExpr *) expr)->minmaxtype;
   break;
  case T_SQLValueFunction:
   type = ((const SQLValueFunction *) expr)->type;
   break;
  case T_XmlExpr:
   if (((const XmlExpr *) expr)->op == IS_DOCUMENT)
    type = BOOLOID;
   else if (((const XmlExpr *) expr)->op == IS_XMLSERIALIZE)
    type = TEXTOID;
   else
    type = XMLOID;
   break;
  case T_JsonValueExpr:
   {
    const JsonValueExpr *jve = (const JsonValueExpr *) expr;

    type = exprType((Node *) jve->formatted_expr);
   }
   break;
  case T_JsonConstructorExpr:
   type = ((const JsonConstructorExpr *) expr)->returning->typid;
   break;
  case T_JsonIsPredicate:
   type = BOOLOID;
   break;
  case T_JsonExpr:
   {
    const JsonExpr *jexpr = (const JsonExpr *) expr;

    type = jexpr->returning->typid;
    break;
   }
  case T_JsonBehavior:
   {
    const JsonBehavior *behavior = (const JsonBehavior *) expr;

    type = exprType(behavior->expr);
    break;
   }
  case T_NullTest:
   type = BOOLOID;
   break;
  case T_BooleanTest:
   type = BOOLOID;
   break;
  case T_CoerceToDomain:
   type = ((const CoerceToDomain *) expr)->resulttype;
   break;
  case T_CoerceToDomainValue:
   type = ((const CoerceToDomainValue *) expr)->typeId;
   break;
  case T_SetToDefault:
   type = ((const SetToDefault *) expr)->typeId;
   break;
  case T_CurrentOfExpr:
   type = BOOLOID;
   break;
  case T_NextValueExpr:
   type = ((const NextValueExpr *) expr)->typeId;
   break;
  case T_InferenceElem:
   {
    const InferenceElem *n = (const InferenceElem *) expr;

    type = exprType((Node *) n->expr);
   }
   break;
  case T_ReturningExpr:
   type = exprType((Node *) ((const ReturningExpr *) expr)->retexpr);
   break;
  case T_PlaceHolderVar:
   type = exprType((Node *) ((const PlaceHolderVar *) expr)->phexpr);
   break;
  default:
   elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
   type = InvalidOid; /* keep compiler quiet */
   break;
 }
 return type;
}

/*
 * exprTypmod -
 *   returns the type-specific modifier of the expression's result type,
 *   if it can be determined.  In many cases, it can't and we return -1.
 */
int32
exprTypmod(const Node *expr)
{
 if (!expr)
  return -1;

 switch (nodeTag(expr))
 {
  case T_Var:
   return ((const Var *) expr)->vartypmod;
  case T_Const:
   return ((const Const *) expr)->consttypmod;
  case T_Param:
   return ((const Param *) expr)->paramtypmod;
  case T_SubscriptingRef:
   return ((const SubscriptingRef *) expr)->reftypmod;
  case T_FuncExpr:
   {
    int32  coercedTypmod;

    /* Be smart about length-coercion functions... */
    if (exprIsLengthCoercion(expr, &coercedTypmod))
     return coercedTypmod;
   }
   break;
  case T_NamedArgExpr:
   return exprTypmod((Node *) ((const NamedArgExpr *) expr)->arg);
  case T_NullIfExpr:
   {
    /*
     * Result is either first argument or NULL, so we can report
     * first argument's typmod if known.
 */
    const NullIfExpr *nexpr = (const NullIfExpr *) expr;

    return exprTypmod((Node *) linitial(nexpr->args));
   }
   break;
  case T_SubLink:
   {
    const SubLink *sublink = (const SubLink *) expr;

    if (sublink->subLinkType == EXPR_SUBLINK ||
     sublink->subLinkType == ARRAY_SUBLINK)
    {
     /* get the typmod of the subselect's first target column */
     Query    *qtree = (Query *) sublink->subselect;
     TargetEntry *tent;

     if (!qtree || !IsA(qtree, Query))
      elog(ERROR, "cannot get type for untransformed sublink");
     tent = linitial_node(TargetEntry, qtree->targetList);
     Assert(!tent->resjunk);
     return exprTypmod((Node *) tent->expr);
     /* note we don't need to care if it's an array */
    }
    /* otherwise, result is RECORD or BOOLEAN, typmod is -1 */
   }
   break;
  case T_SubPlan:
   {
    const SubPlan *subplan = (const SubPlan *) expr;

    if (subplan->subLinkType == EXPR_SUBLINK ||
     subplan->subLinkType == ARRAY_SUBLINK)
    {
     /* get the typmod of the subselect's first target column */
     /* note we don't need to care if it's an array */
     return subplan->firstColTypmod;
    }
    /* otherwise, result is RECORD or BOOLEAN, typmod is -1 */
   }
   break;
  case T_AlternativeSubPlan:
   {
    const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;

    /* subplans should all return the same thing */
    return exprTypmod((Node *) linitial(asplan->subplans));
   }
   break;
  case T_FieldSelect:
   return ((const FieldSelect *) expr)->resulttypmod;
  case T_RelabelType:
   return ((const RelabelType *) expr)->resulttypmod;
  case T_ArrayCoerceExpr:
   return ((const ArrayCoerceExpr *) expr)->resulttypmod;
  case T_CollateExpr:
   return exprTypmod((Node *) ((const CollateExpr *) expr)->arg);
  case T_CaseExpr:
   {
    /*
     * If all the alternatives agree on type/typmod, return that
     * typmod, else use -1
 */
    const CaseExpr *cexpr = (const CaseExpr *) expr;
    Oid   casetype = cexpr->casetype;
    int32  typmod;
    ListCell   *arg;

    if (!cexpr->defresult)
     return -1;
    if (exprType((Node *) cexpr->defresult) != casetype)
     return -1;
    typmod = exprTypmod((Node *) cexpr->defresult);
    if (typmod < 0)
     return -1; /* no point in trying harder */
    foreach(arg, cexpr->args)
    {
     CaseWhen   *w = lfirst_node(CaseWhen, arg);

     if (exprType((Node *) w->result) != casetype)
      return -1;
     if (exprTypmod((Node *) w->result) != typmod)
      return -1;
    }
    return typmod;
   }
   break;
  case T_CaseTestExpr:
   return ((const CaseTestExpr *) expr)->typeMod;
  case T_ArrayExpr:
   {
    /*
     * If all the elements agree on type/typmod, return that
     * typmod, else use -1
 */
    const ArrayExpr *arrayexpr = (const ArrayExpr *) expr;
    Oid   commontype;
    int32  typmod;
    ListCell   *elem;

    if (arrayexpr->elements == NIL)
     return -1;
    typmod = exprTypmod((Node *) linitial(arrayexpr->elements));
    if (typmod < 0)
     return -1; /* no point in trying harder */
    if (arrayexpr->multidims)
     commontype = arrayexpr->array_typeid;
    else
     commontype = arrayexpr->element_typeid;
    foreach(elem, arrayexpr->elements)
    {
     Node    *e = (Node *) lfirst(elem);

     if (exprType(e) != commontype)
      return -1;
     if (exprTypmod(e) != typmod)
      return -1;
    }
    return typmod;
   }
   break;
  case T_CoalesceExpr:
   {
    /*
     * If all the alternatives agree on type/typmod, return that
     * typmod, else use -1
 */
    const CoalesceExpr *cexpr = (const CoalesceExpr *) expr;
    Oid   coalescetype = cexpr->coalescetype;
    int32  typmod;
    ListCell   *arg;

    if (exprType((Node *) linitial(cexpr->args)) != coalescetype)
     return -1;
    typmod = exprTypmod((Node *) linitial(cexpr->args));
    if (typmod < 0)
     return -1; /* no point in trying harder */
    for_each_from(arg, cexpr->args, 1)
    {
     Node    *e = (Node *) lfirst(arg);

     if (exprType(e) != coalescetype)
      return -1;
     if (exprTypmod(e) != typmod)
      return -1;
    }
    return typmod;
   }
   break;
  case T_MinMaxExpr:
   {
    /*
     * If all the alternatives agree on type/typmod, return that
     * typmod, else use -1
 */
    const MinMaxExpr *mexpr = (const MinMaxExpr *) expr;
    Oid   minmaxtype = mexpr->minmaxtype;
    int32  typmod;
    ListCell   *arg;

    if (exprType((Node *) linitial(mexpr->args)) != minmaxtype)
     return -1;
    typmod = exprTypmod((Node *) linitial(mexpr->args));
    if (typmod < 0)
     return -1; /* no point in trying harder */
    for_each_from(arg, mexpr->args, 1)
    {
     Node    *e = (Node *) lfirst(arg);

     if (exprType(e) != minmaxtype)
      return -1;
     if (exprTypmod(e) != typmod)
      return -1;
    }
    return typmod;
   }
   break;
  case T_SQLValueFunction:
   return ((const SQLValueFunction *) expr)->typmod;
  case T_JsonValueExpr:
   return exprTypmod((Node *) ((const JsonValueExpr *) expr)->formatted_expr);
  case T_JsonConstructorExpr:
   return ((const JsonConstructorExpr *) expr)->returning->typmod;
  case T_JsonExpr:
   {
    const JsonExpr *jexpr = (const JsonExpr *) expr;

    return jexpr->returning->typmod;
   }
   break;
  case T_JsonBehavior:
   {
    const JsonBehavior *behavior = (const JsonBehavior *) expr;

    return exprTypmod(behavior->expr);
   }
   break;
  case T_CoerceToDomain:
   return ((const CoerceToDomain *) expr)->resulttypmod;
  case T_CoerceToDomainValue:
   return ((const CoerceToDomainValue *) expr)->typeMod;
  case T_SetToDefault:
   return ((const SetToDefault *) expr)->typeMod;
  case T_ReturningExpr:
   return exprTypmod((Node *) ((const ReturningExpr *) expr)->retexpr);
  case T_PlaceHolderVar:
   return exprTypmod((Node *) ((const PlaceHolderVar *) expr)->phexpr);
  default:
   break;
 }
 return -1;
}

/*
 * exprIsLengthCoercion
 *  Detect whether an expression tree is an application of a datatype's
 *  typmod-coercion function.  Optionally extract the result's typmod.
 *
 * If coercedTypmod is not NULL, the typmod is stored there if the expression
 * is a length-coercion function, else -1 is stored there.
 *
 * Note that a combined type-and-length coercion will be treated as a
 * length coercion by this routine.
 */
bool
exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
{
 if (coercedTypmod != NULL)
  *coercedTypmod = -1; /* default result on failure */

 /*
  * Scalar-type length coercions are FuncExprs, array-type length coercions
  * are ArrayCoerceExprs
 */
 if (expr && IsA(expr, FuncExpr))
 {
  const FuncExpr *func = (const FuncExpr *) expr;
  int   nargs;
  Const    *second_arg;

  /*
   * If it didn't come from a coercion context, reject.
 */
  if (func->funcformat != COERCE_EXPLICIT_CAST &&
   func->funcformat != COERCE_IMPLICIT_CAST)
   return false;

  /*
   * If it's not a two-argument or three-argument function with the
   * second argument being an int4 constant, it can't have been created
   * from a length coercion (it must be a type coercion, instead).
 */
  nargs = list_length(func->args);
  if (nargs < 2 || nargs > 3)
   return false;

  second_arg = (Const *) lsecond(func->args);
  if (!IsA(second_arg, Const) ||
   second_arg->consttype != INT4OID ||
   second_arg->constisnull)
   return false;

  /*
   * OK, it is indeed a length-coercion function.
 */
  if (coercedTypmod != NULL)
   *coercedTypmod = DatumGetInt32(second_arg->constvalue);

  return true;
 }

 if (expr && IsA(expr, ArrayCoerceExpr))
 {
  const ArrayCoerceExpr *acoerce = (const ArrayCoerceExpr *) expr;

  /* It's not a length coercion unless there's a nondefault typmod */
  if (acoerce->resulttypmod < 0)
   return false;

  /*
   * OK, it is indeed a length-coercion expression.
 */
  if (coercedTypmod != NULL)
   *coercedTypmod = acoerce->resulttypmod;

  return true;
 }

 return false;
}

/*
 * applyRelabelType
 *  Add a RelabelType node if needed to make the expression expose
 *  the specified type, typmod, and collation.
 *
 * This is primarily intended to be used during planning.  Therefore, it must
 * maintain the post-eval_const_expressions invariants that there are not
 * adjacent RelabelTypes, and that the tree is fully const-folded (hence,
 * we mustn't return a RelabelType atop a Const).  If we do find a Const,
 * we'll modify it in-place if "overwrite_ok" is true; that should only be
 * passed as true if caller knows the Const is newly generated.
 */
Node *
applyRelabelType(Node *arg, Oid rtype, int32 rtypmod, Oid rcollid,
     CoercionForm rformat, int rlocation, bool overwrite_ok)
{
 /*
  * If we find stacked RelabelTypes (eg, from foo::int::oid) we can discard
  * all but the top one, and must do so to ensure that semantically
  * equivalent expressions are equal().
 */
 while (arg && IsA(arg, RelabelType))
  arg = (Node *) ((RelabelType *) arg)->arg;

 if (arg && IsA(arg, Const))
 {
  /* Modify the Const directly to preserve const-flatness. */
  Const    *con = (Const *) arg;

  if (!overwrite_ok)
   con = copyObject(con);
  con->consttype = rtype;
  con->consttypmod = rtypmod;
  con->constcollid = rcollid;
  /* We keep the Const's original location. */
  return (Node *) con;
 }
 else if (exprType(arg) == rtype &&
    exprTypmod(arg) == rtypmod &&
    exprCollation(arg) == rcollid)
 {
  /* Sometimes we find a nest of relabels that net out to nothing. */
  return arg;
 }
 else
 {
  /* Nope, gotta have a RelabelType. */
  RelabelType *newrelabel = makeNode(RelabelType);

  newrelabel->arg = (Expr *) arg;
  newrelabel->resulttype = rtype;
  newrelabel->resulttypmod = rtypmod;
  newrelabel->resultcollid = rcollid;
  newrelabel->relabelformat = rformat;
  newrelabel->location = rlocation;
  return (Node *) newrelabel;
 }
}

/*
 * relabel_to_typmod
 *  Add a RelabelType node that changes just the typmod of the expression.
 *
 * Convenience function for a common usage of applyRelabelType.
 */
Node *
relabel_to_typmod(Node *expr, int32 typmod)
{
 return applyRelabelType(expr, exprType(expr), typmod, exprCollation(expr),
       COERCE_EXPLICIT_CAST, -1, false);
}

/*
 * strip_implicit_coercions: remove implicit coercions at top level of tree
 *
 * This doesn't modify or copy the input expression tree, just return a
 * pointer to a suitable place within it.
 *
 * Note: there isn't any useful thing we can do with a RowExpr here, so
 * just return it unchanged, even if it's marked as an implicit coercion.
 */
Node *
strip_implicit_coercions(Node *node)
{
 if (node == NULL)
  return NULL;
 if (IsA(node, FuncExpr))
 {
  FuncExpr   *f = (FuncExpr *) node;

  if (f->funcformat == COERCE_IMPLICIT_CAST)
   return strip_implicit_coercions(linitial(f->args));
 }
 else if (IsA(node, RelabelType))
 {
  RelabelType *r = (RelabelType *) node;

  if (r->relabelformat == COERCE_IMPLICIT_CAST)
   return strip_implicit_coercions((Node *) r->arg);
 }
 else if (IsA(node, CoerceViaIO))
 {
  CoerceViaIO *c = (CoerceViaIO *) node;

  if (c->coerceformat == COERCE_IMPLICIT_CAST)
   return strip_implicit_coercions((Node *) c->arg);
 }
 else if (IsA(node, ArrayCoerceExpr))
 {
  ArrayCoerceExpr *c = (ArrayCoerceExpr *) node;

  if (c->coerceformat == COERCE_IMPLICIT_CAST)
   return strip_implicit_coercions((Node *) c->arg);
 }
 else if (IsA(node, ConvertRowtypeExpr))
 {
  ConvertRowtypeExpr *c = (ConvertRowtypeExpr *) node;

  if (c->convertformat == COERCE_IMPLICIT_CAST)
   return strip_implicit_coercions((Node *) c->arg);
 }
 else if (IsA(node, CoerceToDomain))
 {
  CoerceToDomain *c = (CoerceToDomain *) node;

  if (c->coercionformat == COERCE_IMPLICIT_CAST)
   return strip_implicit_coercions((Node *) c->arg);
 }
 return node;
}

/*
 * expression_returns_set
 *   Test whether an expression returns a set result.
 *
 * Because we use expression_tree_walker(), this can also be applied to
 * whole targetlists; it'll produce true if any one of the tlist items
 * returns a set.
 */
bool
expression_returns_set(Node *clause)
{
 return expression_returns_set_walker(clause, NULL);
}

static bool
expression_returns_set_walker(Node *node, void *context)
{
 if (node == NULL)
  return false;
 if (IsA(node, FuncExpr))
 {
  FuncExpr   *expr = (FuncExpr *) node;

  if (expr->funcretset)
   return true;
  /* else fall through to check args */
 }
 if (IsA(node, OpExpr))
 {
  OpExpr    *expr = (OpExpr *) node;

  if (expr->opretset)
   return true;
  /* else fall through to check args */
 }

 /*
  * If you add any more cases that return sets, also fix
  * expression_returns_set_rows() in clauses.c and IS_SRF_CALL() in
  * tlist.c.
 */

 /* Avoid recursion for some cases that parser checks not to return a set */
 if (IsA(node, Aggref))
  return false;
 if (IsA(node, GroupingFunc))
  return false;
 if (IsA(node, WindowFunc))
  return false;

 return expression_tree_walker(node, expression_returns_set_walker,
          context);
}


/*
 * exprCollation -
 *   returns the Oid of the collation of the expression's result.
 *
 * Note: expression nodes that can invoke functions generally have an
 * "inputcollid" field, which is what the function should use as collation.
 * That is the resolved common collation of the node's inputs.  It is often
 * but not always the same as the result collation; in particular, if the
 * function produces a non-collatable result type from collatable inputs
 * or vice versa, the two are different.
 */
Oid
exprCollation(const Node *expr)
{
 Oid   coll;

 if (!expr)
  return InvalidOid;

 switch (nodeTag(expr))
 {
  case T_Var:
   coll = ((const Var *) expr)->varcollid;
   break;
  case T_Const:
   coll = ((const Const *) expr)->constcollid;
   break;
  case T_Param:
   coll = ((const Param *) expr)->paramcollid;
   break;
  case T_Aggref:
   coll = ((const Aggref *) expr)->aggcollid;
   break;
  case T_GroupingFunc:
   coll = InvalidOid;
   break;
  case T_WindowFunc:
   coll = ((const WindowFunc *) expr)->wincollid;
   break;
  case T_MergeSupportFunc:
   coll = ((const MergeSupportFunc *) expr)->msfcollid;
   break;
  case T_SubscriptingRef:
   coll = ((const SubscriptingRef *) expr)->refcollid;
   break;
  case T_FuncExpr:
   coll = ((const FuncExpr *) expr)->funccollid;
   break;
  case T_NamedArgExpr:
   coll = exprCollation((Node *) ((const NamedArgExpr *) expr)->arg);
   break;
  case T_OpExpr:
   coll = ((const OpExpr *) expr)->opcollid;
   break;
  case T_DistinctExpr:
   coll = ((const DistinctExpr *) expr)->opcollid;
   break;
  case T_NullIfExpr:
   coll = ((const NullIfExpr *) expr)->opcollid;
   break;
  case T_ScalarArrayOpExpr:
   /* ScalarArrayOpExpr's result is boolean ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_BoolExpr:
   /* BoolExpr's result is boolean ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_SubLink:
   {
    const SubLink *sublink = (const SubLink *) expr;

    if (sublink->subLinkType == EXPR_SUBLINK ||
     sublink->subLinkType == ARRAY_SUBLINK)
    {
     /* get the collation of subselect's first target column */
     Query    *qtree = (Query *) sublink->subselect;
     TargetEntry *tent;

     if (!qtree || !IsA(qtree, Query))
      elog(ERROR, "cannot get collation for untransformed sublink");
     tent = linitial_node(TargetEntry, qtree->targetList);
     Assert(!tent->resjunk);
     coll = exprCollation((Node *) tent->expr);
     /* collation doesn't change if it's converted to array */
    }
    else
    {
     /* otherwise, SubLink's result is RECORD or BOOLEAN */
     coll = InvalidOid; /* ... so it has no collation */
    }
   }
   break;
  case T_SubPlan:
   {
    const SubPlan *subplan = (const SubPlan *) expr;

    if (subplan->subLinkType == EXPR_SUBLINK ||
     subplan->subLinkType == ARRAY_SUBLINK)
    {
     /* get the collation of subselect's first target column */
     coll = subplan->firstColCollation;
     /* collation doesn't change if it's converted to array */
    }
    else
    {
     /* otherwise, SubPlan's result is RECORD or BOOLEAN */
     coll = InvalidOid; /* ... so it has no collation */
    }
   }
   break;
  case T_AlternativeSubPlan:
   {
    const AlternativeSubPlan *asplan = (const AlternativeSubPlan *) expr;

    /* subplans should all return the same thing */
    coll = exprCollation((Node *) linitial(asplan->subplans));
   }
   break;
  case T_FieldSelect:
   coll = ((const FieldSelect *) expr)->resultcollid;
   break;
  case T_FieldStore:
   /* FieldStore's result is composite ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_RelabelType:
   coll = ((const RelabelType *) expr)->resultcollid;
   break;
  case T_CoerceViaIO:
   coll = ((const CoerceViaIO *) expr)->resultcollid;
   break;
  case T_ArrayCoerceExpr:
   coll = ((const ArrayCoerceExpr *) expr)->resultcollid;
   break;
  case T_ConvertRowtypeExpr:
   /* ConvertRowtypeExpr's result is composite ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_CollateExpr:
   coll = ((const CollateExpr *) expr)->collOid;
   break;
  case T_CaseExpr:
   coll = ((const CaseExpr *) expr)->casecollid;
   break;
  case T_CaseTestExpr:
   coll = ((const CaseTestExpr *) expr)->collation;
   break;
  case T_ArrayExpr:
   coll = ((const ArrayExpr *) expr)->array_collid;
   break;
  case T_RowExpr:
   /* RowExpr's result is composite ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_RowCompareExpr:
   /* RowCompareExpr's result is boolean ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_CoalesceExpr:
   coll = ((const CoalesceExpr *) expr)->coalescecollid;
   break;
  case T_MinMaxExpr:
   coll = ((const MinMaxExpr *) expr)->minmaxcollid;
   break;
  case T_SQLValueFunction:
   /* Returns either NAME or a non-collatable type */
   if (((const SQLValueFunction *) expr)->type == NAMEOID)
    coll = C_COLLATION_OID;
   else
    coll = InvalidOid;
   break;
  case T_XmlExpr:

   /*
    * XMLSERIALIZE returns text from non-collatable inputs, so its
    * collation is always default.  The other cases return boolean or
    * XML, which are non-collatable.
 */
   if (((const XmlExpr *) expr)->op == IS_XMLSERIALIZE)
    coll = DEFAULT_COLLATION_OID;
   else
    coll = InvalidOid;
   break;
  case T_JsonValueExpr:
   coll = exprCollation((Node *) ((const JsonValueExpr *) expr)->formatted_expr);
   break;
  case T_JsonConstructorExpr:
   {
    const JsonConstructorExpr *ctor = (const JsonConstructorExpr *) expr;

    if (ctor->coercion)
     coll = exprCollation((Node *) ctor->coercion);
    else
     coll = InvalidOid;
   }
   break;
  case T_JsonIsPredicate:
   /* IS JSON's result is boolean ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_JsonExpr:
   {
    const JsonExpr *jsexpr = (JsonExpr *) expr;

    coll = jsexpr->collation;
   }
   break;
  case T_JsonBehavior:
   {
    const JsonBehavior *behavior = (JsonBehavior *) expr;

    if (behavior->expr)
     coll = exprCollation(behavior->expr);
    else
     coll = InvalidOid;
   }
   break;
  case T_NullTest:
   /* NullTest's result is boolean ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_BooleanTest:
   /* BooleanTest's result is boolean ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_CoerceToDomain:
   coll = ((const CoerceToDomain *) expr)->resultcollid;
   break;
  case T_CoerceToDomainValue:
   coll = ((const CoerceToDomainValue *) expr)->collation;
   break;
  case T_SetToDefault:
   coll = ((const SetToDefault *) expr)->collation;
   break;
  case T_CurrentOfExpr:
   /* CurrentOfExpr's result is boolean ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_NextValueExpr:
   /* NextValueExpr's result is an integer type ... */
   coll = InvalidOid; /* ... so it has no collation */
   break;
  case T_InferenceElem:
   coll = exprCollation((Node *) ((const InferenceElem *) expr)->expr);
   break;
  case T_ReturningExpr:
   coll = exprCollation((Node *) ((const ReturningExpr *) expr)->retexpr);
   break;
  case T_PlaceHolderVar:
   coll = exprCollation((Node *) ((const PlaceHolderVar *) expr)->phexpr);
   break;
  default:
   elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
   coll = InvalidOid; /* keep compiler quiet */
   break;
 }
 return coll;
}

/*
 * exprInputCollation -
 *   returns the Oid of the collation a function should use, if available.
 *
 * Result is InvalidOid if the node type doesn't store this information.
 */
Oid
exprInputCollation(const Node *expr)
{
 Oid   coll;

 if (!expr)
  return InvalidOid;

 switch (nodeTag(expr))
 {
  case T_Aggref:
   coll = ((const Aggref *) expr)->inputcollid;
   break;
  case T_WindowFunc:
   coll = ((const WindowFunc *) expr)->inputcollid;
   break;
  case T_FuncExpr:
   coll = ((const FuncExpr *) expr)->inputcollid;
   break;
  case T_OpExpr:
   coll = ((const OpExpr *) expr)->inputcollid;
   break;
  case T_DistinctExpr:
   coll = ((const DistinctExpr *) expr)->inputcollid;
   break;
  case T_NullIfExpr:
   coll = ((const NullIfExpr *) expr)->inputcollid;
   break;
  case T_ScalarArrayOpExpr:
   coll = ((const ScalarArrayOpExpr *) expr)->inputcollid;
   break;
  case T_MinMaxExpr:
   coll = ((const MinMaxExpr *) expr)->inputcollid;
   break;
  default:
   coll = InvalidOid;
   break;
 }
 return coll;
}

/*
 * exprSetCollation -
 *   Assign collation information to an expression tree node.
 *
 * Note: since this is only used during parse analysis, we don't need to
 * worry about subplans, PlaceHolderVars, or ReturningExprs.
 */
void
exprSetCollation(Node *expr, Oid collation)
{
 switch (nodeTag(expr))
 {
  case T_Var:
   ((Var *) expr)->varcollid = collation;
   break;
  case T_Const:
   ((Const *) expr)->constcollid = collation;
   break;
  case T_Param:
   ((Param *) expr)->paramcollid = collation;
   break;
  case T_Aggref:
   ((Aggref *) expr)->aggcollid = collation;
   break;
  case T_GroupingFunc:
   Assert(!OidIsValid(collation));
   break;
  case T_WindowFunc:
   ((WindowFunc *) expr)->wincollid = collation;
   break;
  case T_MergeSupportFunc:
   ((MergeSupportFunc *) expr)->msfcollid = collation;
   break;
  case T_SubscriptingRef:
   ((SubscriptingRef *) expr)->refcollid = collation;
   break;
  case T_FuncExpr:
   ((FuncExpr *) expr)->funccollid = collation;
   break;
  case T_NamedArgExpr:
   Assert(collation == exprCollation((Node *) ((NamedArgExpr *) expr)->arg));
   break;
  case T_OpExpr:
   ((OpExpr *) expr)->opcollid = collation;
   break;
  case T_DistinctExpr:
   ((DistinctExpr *) expr)->opcollid = collation;
   break;
  case T_NullIfExpr:
   ((NullIfExpr *) expr)->opcollid = collation;
   break;
  case T_ScalarArrayOpExpr:
   /* ScalarArrayOpExpr's result is boolean ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_BoolExpr:
   /* BoolExpr's result is boolean ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_SubLink:
#ifdef USE_ASSERT_CHECKING
   {
    SubLink    *sublink = (SubLink *) expr;

    if (sublink->subLinkType == EXPR_SUBLINK ||
     sublink->subLinkType == ARRAY_SUBLINK)
    {
     /* get the collation of subselect's first target column */
     Query    *qtree = (Query *) sublink->subselect;
     TargetEntry *tent;

     if (!qtree || !IsA(qtree, Query))
      elog(ERROR, "cannot set collation for untransformed sublink");
     tent = linitial_node(TargetEntry, qtree->targetList);
     Assert(!tent->resjunk);
     Assert(collation == exprCollation((Node *) tent->expr));
    }
    else
    {
     /* otherwise, result is RECORD or BOOLEAN */
     Assert(!OidIsValid(collation));
    }
   }
#endif       /* USE_ASSERT_CHECKING */
   break;
  case T_FieldSelect:
   ((FieldSelect *) expr)->resultcollid = collation;
   break;
  case T_FieldStore:
   /* FieldStore's result is composite ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_RelabelType:
   ((RelabelType *) expr)->resultcollid = collation;
   break;
  case T_CoerceViaIO:
   ((CoerceViaIO *) expr)->resultcollid = collation;
   break;
  case T_ArrayCoerceExpr:
   ((ArrayCoerceExpr *) expr)->resultcollid = collation;
   break;
  case T_ConvertRowtypeExpr:
   /* ConvertRowtypeExpr's result is composite ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_CaseExpr:
   ((CaseExpr *) expr)->casecollid = collation;
   break;
  case T_ArrayExpr:
   ((ArrayExpr *) expr)->array_collid = collation;
   break;
  case T_RowExpr:
   /* RowExpr's result is composite ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_RowCompareExpr:
   /* RowCompareExpr's result is boolean ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_CoalesceExpr:
   ((CoalesceExpr *) expr)->coalescecollid = collation;
   break;
  case T_MinMaxExpr:
   ((MinMaxExpr *) expr)->minmaxcollid = collation;
   break;
  case T_SQLValueFunction:
   Assert((((SQLValueFunction *) expr)->type == NAMEOID) ?
       (collation == C_COLLATION_OID) :
       (collation == InvalidOid));
   break;
  case T_XmlExpr:
   Assert((((XmlExpr *) expr)->op == IS_XMLSERIALIZE) ?
       (collation == DEFAULT_COLLATION_OID) :
       (collation == InvalidOid));
   break;
  case T_JsonValueExpr:
   exprSetCollation((Node *) ((JsonValueExpr *) expr)->formatted_expr,
        collation);
   break;
  case T_JsonConstructorExpr:
   {
    JsonConstructorExpr *ctor = (JsonConstructorExpr *) expr;

    if (ctor->coercion)
     exprSetCollation((Node *) ctor->coercion, collation);
    else
     Assert(!OidIsValid(collation)); /* result is always a
 * json[b] type */
   }
   break;
  case T_JsonIsPredicate:
   Assert(!OidIsValid(collation)); /* result is always boolean */
   break;
  case T_JsonExpr:
   {
    JsonExpr   *jexpr = (JsonExpr *) expr;

    jexpr->collation = collation;
   }
   break;
  case T_JsonBehavior:
   Assert(((JsonBehavior *) expr)->expr == NULL ||
       exprCollation(((JsonBehavior *) expr)->expr) == collation);
   break;
  case T_NullTest:
   /* NullTest's result is boolean ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_BooleanTest:
   /* BooleanTest's result is boolean ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_CoerceToDomain:
   ((CoerceToDomain *) expr)->resultcollid = collation;
   break;
  case T_CoerceToDomainValue:
   ((CoerceToDomainValue *) expr)->collation = collation;
   break;
  case T_SetToDefault:
   ((SetToDefault *) expr)->collation = collation;
   break;
  case T_CurrentOfExpr:
   /* CurrentOfExpr's result is boolean ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  case T_NextValueExpr:
   /* NextValueExpr's result is an integer type ... */
   Assert(!OidIsValid(collation)); /* ... so never set a collation */
   break;
  default:
   elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
   break;
 }
}

/*
 * exprSetInputCollation -
 *   Assign input-collation information to an expression tree node.
 *
 * This is a no-op for node types that don't store their input collation.
 * Note we omit RowCompareExpr, which needs special treatment since it
 * contains multiple input collation OIDs.
 */
void
exprSetInputCollation(Node *expr, Oid inputcollation)
{
 switch (nodeTag(expr))
 {
  case T_Aggref:
   ((Aggref *) expr)->inputcollid = inputcollation;
   break;
  case T_WindowFunc:
   ((WindowFunc *) expr)->inputcollid = inputcollation;
   break;
  case T_FuncExpr:
   ((FuncExpr *) expr)->inputcollid = inputcollation;
   break;
  case T_OpExpr:
   ((OpExpr *) expr)->inputcollid = inputcollation;
   break;
  case T_DistinctExpr:
   ((DistinctExpr *) expr)->inputcollid = inputcollation;
   break;
  case T_NullIfExpr:
   ((NullIfExpr *) expr)->inputcollid = inputcollation;
   break;
  case T_ScalarArrayOpExpr:
   ((ScalarArrayOpExpr *) expr)->inputcollid = inputcollation;
   break;
  case T_MinMaxExpr:
   ((MinMaxExpr *) expr)->inputcollid = inputcollation;
   break;
  default:
   break;
 }
}


/*
 * exprLocation -
 *   returns the parse location of an expression tree, for error reports
 *
 * -1 is returned if the location can't be determined.
 *
 * For expressions larger than a single token, the intent here is to
 * return the location of the expression's leftmost token, not necessarily
 * the topmost Node's location field.  For example, an OpExpr's location
 * field will point at the operator name, but if it is not a prefix operator
 * then we should return the location of the left-hand operand instead.
 * The reason is that we want to reference the entire expression not just
 * that operator, and pointing to its start seems to be the most natural way.
 *
 * The location is not perfect --- for example, since the grammar doesn't
 * explicitly represent parentheses in the parsetree, given something that
 * had been written "(a + b) * c" we are going to point at "a" not "(".
 * But it should be plenty good enough for error reporting purposes.
 *
 * You might think that this code is overly general, for instance why check
 * the operands of a FuncExpr node, when the function name can be expected
 * to be to the left of them?  There are a couple of reasons.  The grammar
 * sometimes builds expressions that aren't quite what the user wrote;
 * for instance x IS NOT BETWEEN ... becomes a NOT-expression whose keyword
 * pointer is to the right of its leftmost argument.  Also, nodes that were
 * inserted implicitly by parse analysis (such as FuncExprs for implicit
 * coercions) will have location -1, and so we can have odd combinations of
 * known and unknown locations in a tree.
 */
int
exprLocation(const Node *expr)
{
 int   loc;

 if (expr == NULL)
  return -1;
 switch (nodeTag(expr))
 {
  case T_RangeVar:
   loc = ((const RangeVar *) expr)->location;
   break;
  case T_TableFunc:
   loc = ((const TableFunc *) expr)->location;
   break;
  case T_Var:
   loc = ((const Var *) expr)->location;
   break;
  case T_Const:
   loc = ((const Const *) expr)->location;
   break;
  case T_Param:
   loc = ((const Param *) expr)->location;
   break;
  case T_Aggref:
   /* function name should always be the first thing */
   loc = ((const Aggref *) expr)->location;
   break;
  case T_GroupingFunc:
   loc = ((const GroupingFunc *) expr)->location;
   break;
  case T_WindowFunc:
   /* function name should always be the first thing */
   loc = ((const WindowFunc *) expr)->location;
   break;
  case T_MergeSupportFunc:
   loc = ((const MergeSupportFunc *) expr)->location;
   break;
  case T_SubscriptingRef:
   /* just use container argument's location */
   loc = exprLocation((Node *) ((const SubscriptingRef *) expr)->refexpr);
   break;
  case T_FuncExpr:
   {
    const FuncExpr *fexpr = (const FuncExpr *) expr;

    /* consider both function name and leftmost arg */
    loc = leftmostLoc(fexpr->location,
          exprLocation((Node *) fexpr->args));
   }
   break;
  case T_NamedArgExpr:
   {
    const NamedArgExpr *na = (const NamedArgExpr *) expr;

    /* consider both argument name and value */
    loc = leftmostLoc(na->location,
          exprLocation((Node *) na->arg));
   }
   break;
  case T_OpExpr:
  case T_DistinctExpr: /* struct-equivalent to OpExpr */
  case T_NullIfExpr:  /* struct-equivalent to OpExpr */
   {
    const OpExpr *opexpr = (const OpExpr *) expr;

    /* consider both operator name and leftmost arg */
    loc = leftmostLoc(opexpr->location,
          exprLocation((Node *) opexpr->args));
   }
   break;
  case T_ScalarArrayOpExpr:
   {
    const ScalarArrayOpExpr *saopexpr = (const ScalarArrayOpExpr *) expr;

    /* consider both operator name and leftmost arg */
    loc = leftmostLoc(saopexpr->location,
          exprLocation((Node *) saopexpr->args));
   }
   break;
  case T_BoolExpr:
   {
    const BoolExpr *bexpr = (const BoolExpr *) expr;

    /*
     * Same as above, to handle either NOT or AND/OR.  We can't
     * special-case NOT because of the way that it's used for
     * things like IS NOT BETWEEN.
 */
    loc = leftmostLoc(bexpr->location,
          exprLocation((Node *) bexpr->args));
   }
   break;
  case T_SubLink:
   {
    const SubLink *sublink = (const SubLink *) expr;

    /* check the testexpr, if any, and the operator/keyword */
    loc = leftmostLoc(exprLocation(sublink->testexpr),
          sublink->location);
   }
   break;
  case T_FieldSelect:
   /* just use argument's location */
   loc = exprLocation((Node *) ((const FieldSelect *) expr)->arg);
   break;
  case T_FieldStore:
   /* just use argument's location */
   loc = exprLocation((Node *) ((const FieldStore *) expr)->arg);
   break;
  case T_RelabelType:
   {
    const RelabelType *rexpr = (const RelabelType *) expr;

    /* Much as above */
    loc = leftmostLoc(rexpr->location,
          exprLocation((Node *) rexpr->arg));
   }
   break;
  case T_CoerceViaIO:
   {
    const CoerceViaIO *cexpr = (const CoerceViaIO *) expr;

    /* Much as above */
    loc = leftmostLoc(cexpr->location,
          exprLocation((Node *) cexpr->arg));
   }
   break;
  case T_ArrayCoerceExpr:
   {
    const ArrayCoerceExpr *cexpr = (const ArrayCoerceExpr *) expr;

    /* Much as above */
    loc = leftmostLoc(cexpr->location,
          exprLocation((Node *) cexpr->arg));
   }
   break;
  case T_ConvertRowtypeExpr:
   {
    const ConvertRowtypeExpr *cexpr = (const ConvertRowtypeExpr *) expr;

    /* Much as above */
    loc = leftmostLoc(cexpr->location,
          exprLocation((Node *) cexpr->arg));
   }
   break;
  case T_CollateExpr:
   /* just use argument's location */
   loc = exprLocation((Node *) ((const CollateExpr *) expr)->arg);
   break;
  case T_CaseExpr:
   /* CASE keyword should always be the first thing */
   loc = ((const CaseExpr *) expr)->location;
   break;
  case T_CaseWhen:
   /* WHEN keyword should always be the first thing */
   loc = ((const CaseWhen *) expr)->location;
   break;
  case T_ArrayExpr:
   /* the location points at ARRAY or [, which must be leftmost */
   loc = ((const ArrayExpr *) expr)->location;
   break;
  case T_RowExpr:
   /* the location points at ROW or (, which must be leftmost */
   loc = ((const RowExpr *) expr)->location;
   break;
  case T_RowCompareExpr:
   /* just use leftmost argument's location */
   loc = exprLocation((Node *) ((const RowCompareExpr *) expr)->largs);
   break;
  case T_CoalesceExpr:
   /* COALESCE keyword should always be the first thing */
   loc = ((const CoalesceExpr *) expr)->location;
   break;
  case T_MinMaxExpr:
   /* GREATEST/LEAST keyword should always be the first thing */
   loc = ((const MinMaxExpr *) expr)->location;
   break;
  case T_SQLValueFunction:
   /* function keyword should always be the first thing */
   loc = ((const SQLValueFunction *) expr)->location;
   break;
  case T_XmlExpr:
   {
    const XmlExpr *xexpr = (const XmlExpr *) expr;

    /* consider both function name and leftmost arg */
    loc = leftmostLoc(xexpr->location,
          exprLocation((Node *) xexpr->args));
   }
   break;
  case T_JsonFormat:
   loc = ((const JsonFormat *) expr)->location;
   break;
  case T_JsonValueExpr:
   loc = exprLocation((Node *) ((const JsonValueExpr *) expr)->raw_expr);
   break;
  case T_JsonConstructorExpr:
   loc = ((const JsonConstructorExpr *) expr)->location;
   break;
  case T_JsonIsPredicate:
   loc = ((const JsonIsPredicate *) expr)->location;
   break;
  case T_JsonExpr:
   {
    const JsonExpr *jsexpr = (const JsonExpr *) expr;

    /* consider both function name and leftmost arg */
    loc = leftmostLoc(jsexpr->location,
          exprLocation(jsexpr->formatted_expr));
   }
   break;
  case T_JsonBehavior:
   loc = exprLocation(((JsonBehavior *) expr)->expr);
   break;
  case T_NullTest:
   {
    const NullTest *nexpr = (const NullTest *) expr;

    /* Much as above */
    loc = leftmostLoc(nexpr->location,
          exprLocation((Node *) nexpr->arg));
   }
   break;
  case T_BooleanTest:
   {
    const BooleanTest *bexpr = (const BooleanTest *) expr;

    /* Much as above */
    loc = leftmostLoc(bexpr->location,
          exprLocation((Node *) bexpr->arg));
   }
   break;
  case T_CoerceToDomain:
   {
    const CoerceToDomain *cexpr = (const CoerceToDomain *) expr;

    /* Much as above */
    loc = leftmostLoc(cexpr->location,
          exprLocation((Node *) cexpr->arg));
   }
   break;
  case T_CoerceToDomainValue:
   loc = ((const CoerceToDomainValue *) expr)->location;
   break;
  case T_SetToDefault:
   loc = ((const SetToDefault *) expr)->location;
   break;
  case T_ReturningExpr:
   loc = exprLocation((Node *) ((const ReturningExpr *) expr)->retexpr);
   break;
  case T_TargetEntry:
   /* just use argument's location */
   loc = exprLocation((Node *) ((const TargetEntry *) expr)->expr);
   break;
  case T_IntoClause:
   /* use the contained RangeVar's location --- close enough */
   loc = exprLocation((Node *) ((const IntoClause *) expr)->rel);
   break;
  case T_List:
   {
    /* report location of first list member that has a location */
    ListCell   *lc;

    loc = -1;  /* just to suppress compiler warning */
    foreach(lc, (const List *) expr)
    {
     loc = exprLocation((Node *) lfirst(lc));
     if (loc >= 0)
      break;
    }
   }
   break;
  case T_A_Expr:
   {
    const A_Expr *aexpr = (const A_Expr *) expr;

    /* use leftmost of operator or left operand (if any) */
    /* we assume right operand can't be to left of operator */
    loc = leftmostLoc(aexpr->location,
          exprLocation(aexpr->lexpr));
   }
   break;
  case T_ColumnRef:
   loc = ((const ColumnRef *) expr)->location;
   break;
  case T_ParamRef:
   loc = ((const ParamRef *) expr)->location;
   break;
  case T_A_Const:
   loc = ((const A_Const *) expr)->location;
   break;
  case T_FuncCall:
   {
    const FuncCall *fc = (const FuncCall *) expr;

    /* consider both function name and leftmost arg */
    /* (we assume any ORDER BY nodes must be to right of name) */
    loc = leftmostLoc(fc->location,
          exprLocation((Node *) fc->args));
   }
   break;
  case T_A_ArrayExpr:
   /* the location points at ARRAY or [, which must be leftmost */
   loc = ((const A_ArrayExpr *) expr)->location;
   break;
  case T_ResTarget:
   /* we need not examine the contained expression (if any) */
   loc = ((const ResTarget *) expr)->location;
   break;
  case T_MultiAssignRef:
   loc = exprLocation(((const MultiAssignRef *) expr)->source);
   break;
  case T_TypeCast:
   {
    const TypeCast *tc = (const TypeCast *) expr;

    /*
     * This could represent CAST(), ::, or TypeName 'literal', so
     * any of the components might be leftmost.
 */
    loc = exprLocation(tc->arg);
    loc = leftmostLoc(loc, tc->typeName->location);
    loc = leftmostLoc(loc, tc->location);
   }
   break;
  case T_CollateClause:
   /* just use argument's location */
   loc = exprLocation(((const CollateClause *) expr)->arg);
   break;
  case T_SortBy:
   /* just use argument's location (ignore operator, if any) */
   loc = exprLocation(((const SortBy *) expr)->node);
   break;
  case T_WindowDef:
   loc = ((const WindowDef *) expr)->location;
   break;
  case T_RangeTableSample:
   loc = ((const RangeTableSample *) expr)->location;
   break;
  case T_TypeName:
   loc = ((const TypeName *) expr)->location;
   break;
  case T_ColumnDef:
   loc = ((const ColumnDef *) expr)->location;
   break;
  case T_Constraint:
   loc = ((const Constraint *) expr)->location;
   break;
  case T_FunctionParameter:
   loc = ((const FunctionParameter *) expr)->location;
   break;
  case T_XmlSerialize:
   /* XMLSERIALIZE keyword should always be the first thing */
   loc = ((const XmlSerialize *) expr)->location;
   break;
  case T_GroupingSet:
   loc = ((const GroupingSet *) expr)->location;
   break;
  case T_WithClause:
   loc = ((const WithClause *) expr)->location;
   break;
  case T_InferClause:
   loc = ((const InferClause *) expr)->location;
   break;
  case T_OnConflictClause:
   loc = ((const OnConflictClause *) expr)->location;
   break;
  case T_CTESearchClause:
   loc = ((const CTESearchClause *) expr)->location;
   break;
  case T_CTECycleClause:
   loc = ((const CTECycleClause *) expr)->location;
   break;
  case T_CommonTableExpr:
   loc = ((const CommonTableExpr *) expr)->location;
   break;
  case T_JsonKeyValue:
   /* just use the key's location */
   loc = exprLocation((Node *) ((const JsonKeyValue *) expr)->key);
   break;
  case T_JsonObjectConstructor:
   loc = ((const JsonObjectConstructor *) expr)->location;
   break;
  case T_JsonArrayConstructor:
   loc = ((const JsonArrayConstructor *) expr)->location;
   break;
  case T_JsonArrayQueryConstructor:
   loc = ((const JsonArrayQueryConstructor *) expr)->location;
   break;
  case T_JsonAggConstructor:
   loc = ((const JsonAggConstructor *) expr)->location;
   break;
  case T_JsonObjectAgg:
   loc = exprLocation((Node *) ((const JsonObjectAgg *) expr)->constructor);
   break;
  case T_JsonArrayAgg:
   loc = exprLocation((Node *) ((const JsonArrayAgg *) expr)->constructor);
   break;
  case T_PlaceHolderVar:
   /* just use argument's location */
   loc = exprLocation((Node *) ((const PlaceHolderVar *) expr)->phexpr);
   break;
  case T_InferenceElem:
   /* just use nested expr's location */
   loc = exprLocation((Node *) ((const InferenceElem *) expr)->expr);
   break;
  case T_PartitionElem:
   loc = ((const PartitionElem *) expr)->location;
   break;
  case T_PartitionSpec:
   loc = ((const PartitionSpec *) expr)->location;
   break;
  case T_PartitionBoundSpec:
   loc = ((const PartitionBoundSpec *) expr)->location;
   break;
  case T_PartitionRangeDatum:
   loc = ((const PartitionRangeDatum *) expr)->location;
   break;
  default:
   /* for any other node type it's just unknown... */
   loc = -1;
   break;
 }
 return loc;
}

/*
 * leftmostLoc - support for exprLocation
 *
 * Take the minimum of two parse location values, but ignore unknowns
 */
static int
leftmostLoc(int loc1, int loc2)
{
 if (loc1 < 0)
  return loc2;
 else if (loc2 < 0)
  return loc1;
 else
  return Min(loc1, loc2);
}


/*
 * fix_opfuncids
 *   Calculate opfuncid field from opno for each OpExpr node in given tree.
 *   The given tree can be anything expression_tree_walker handles.
 *
 * The argument is modified in-place.  (This is OK since we'd want the
 * same change for any node, even if it gets visited more than once due to
 * shared structure.)
 */
void
fix_opfuncids(Node *node)
{
 /* This tree walk requires no special setup, so away we go... */
 fix_opfuncids_walker(node, NULL);
}

static bool
fix_opfuncids_walker(Node *node, void *context)
{
 if (node == NULL)
  return false;
 if (IsA(node, OpExpr))
  set_opfuncid((OpExpr *) node);
 else if (IsA(node, DistinctExpr))
  set_opfuncid((OpExpr *) node); /* rely on struct equivalence */
 else if (IsA(node, NullIfExpr))
  set_opfuncid((OpExpr *) node); /* rely on struct equivalence */
 else if (IsA(node, ScalarArrayOpExpr))
  set_sa_opfuncid((ScalarArrayOpExpr *) node);
 return expression_tree_walker(node, fix_opfuncids_walker, context);
}

/*
 * set_opfuncid
 *  Set the opfuncid (procedure OID) in an OpExpr node,
 *  if it hasn't been set already.
 *
 * Because of struct equivalence, this can also be used for
 * DistinctExpr and NullIfExpr nodes.
 */
void
set_opfuncid(OpExpr *opexpr)
{
 if (opexpr->opfuncid == InvalidOid)
  opexpr->opfuncid = get_opcode(opexpr->opno);
}

/*
 * set_sa_opfuncid
 *  As above, for ScalarArrayOpExpr nodes.
 */
void
set_sa_opfuncid(ScalarArrayOpExpr *opexpr)
{
 if (opexpr->opfuncid == InvalidOid)
  opexpr->opfuncid = get_opcode(opexpr->opno);
}


/*
 * check_functions_in_node -
 *   apply checker() to each function OID contained in given expression node
 *
 * Returns true if the checker() function does; for nodes representing more
 * than one function call, returns true if the checker() function does so
 * for any of those functions.  Returns false if node does not invoke any
 * SQL-visible function.  Caller must not pass node == NULL.
 *
 * This function examines only the given node; it does not recurse into any
 * sub-expressions.  Callers typically prefer to keep control of the recursion
 * for themselves, in case additional checks should be made, or because they
 * have special rules about which parts of the tree need to be visited.
 *
 * Note: we ignore MinMaxExpr, SQLValueFunction, XmlExpr, CoerceToDomain,
 * and NextValueExpr nodes, because they do not contain SQL function OIDs.
 * However, they can invoke SQL-visible functions, so callers should take
 * thought about how to treat them.
 */
bool
check_functions_in_node(Node *node, check_function_callback checker,
      void *context)
{
 switch (nodeTag(node))
 {
  case T_Aggref:
   {
    Aggref    *expr = (Aggref *) node;

    if (checker(expr->aggfnoid, context))
     return true;
   }
   break;
  case T_WindowFunc:
   {
    WindowFunc *expr = (WindowFunc *) node;

    if (checker(expr->winfnoid, context))
     return true;
   }
   break;
  case T_FuncExpr:
   {
    FuncExpr   *expr = (FuncExpr *) node;

    if (checker(expr->funcid, context))
     return true;
   }
   break;
  case T_OpExpr:
  case T_DistinctExpr: /* struct-equivalent to OpExpr */
  case T_NullIfExpr:  /* struct-equivalent to OpExpr */
   {
    OpExpr    *expr = (OpExpr *) node;

    /* Set opfuncid if it wasn't set already */
    set_opfuncid(expr);
    if (checker(expr->opfuncid, context))
     return true;
   }
   break;
  case T_ScalarArrayOpExpr:
   {
    ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;

    set_sa_opfuncid(expr);
    if (checker(expr->opfuncid, context))
     return true;
   }
   break;
  case T_CoerceViaIO:
   {
    CoerceViaIO *expr = (CoerceViaIO *) node;
    Oid   iofunc;
    Oid   typioparam;
    bool  typisvarlena;

    /* check the result type's input function */
    getTypeInputInfo(expr->resulttype,
         &iofunc, &typioparam);
    if (checker(iofunc, context))
     return true;
    /* check the input type's output function */
    getTypeOutputInfo(exprType((Node *) expr->arg),
          &iofunc, &typisvarlena);
    if (checker(iofunc, context))
     return true;
   }
   break;
  case T_RowCompareExpr:
   {
    RowCompareExpr *rcexpr = (RowCompareExpr *) node;
    ListCell   *opid;

    foreach(opid, rcexpr->opnos)
    {
     Oid   opfuncid = get_opcode(lfirst_oid(opid));

     if (checker(opfuncid, context))
      return true;
    }
   }
   break;
  default:
   break;
 }
 return false;
}


/*
 * Standard expression-tree walking support
 *
 * We used to have near-duplicate code in many different routines that
 * understood how to recurse through an expression node tree.  That was
 * a pain to maintain, and we frequently had bugs due to some particular
 * routine neglecting to support a particular node type.  In most cases,
 * these routines only actually care about certain node types, and don't
 * care about other types except insofar as they have to recurse through
 * non-primitive node types.  Therefore, we now provide generic tree-walking
 * logic to consolidate the redundant "boilerplate" code.  There are
 * two versions: expression_tree_walker() and expression_tree_mutator().
 */

/*
 * expression_tree_walker() is designed to support routines that traverse
 * a tree in a read-only fashion (although it will also work for routines
 * that modify nodes in-place but never add/delete/replace nodes).
 * A walker routine should look like this:
 *
 * bool my_walker (Node *node, my_struct *context)
 * {
 *  if (node == NULL)
 *   return false;
 *  // check for nodes that special work is required for, eg:
 *  if (IsA(node, Var))
 *  {
 *   ... do special actions for Var nodes
 *  }
 *  else if (IsA(node, ...))
 *  {
 *   ... do special actions for other node types
 *  }
 *  // for any node type not specially processed, do:
 *  return expression_tree_walker(node, my_walker, context);
 * }
 *
 * The "context" argument points to a struct that holds whatever context
 * information the walker routine needs --- it can be used to return data
 * gathered by the walker, too.  This argument is not touched by
 * expression_tree_walker, but it is passed down to recursive sub-invocations
 * of my_walker.  The tree walk is started from a setup routine that
 * fills in the appropriate context struct, calls my_walker with the top-level
 * node of the tree, and then examines the results.
 *
 * The walker routine should return "false" to continue the tree walk, or
 * "true" to abort the walk and immediately return "true" to the top-level
 * caller.  This can be used to short-circuit the traversal if the walker
 * has found what it came for.  "false" is returned to the top-level caller
 * iff no invocation of the walker returned "true".
 *
 * The node types handled by expression_tree_walker include all those
 * normally found in target lists and qualifier clauses during the planning
 * stage.  In particular, it handles List nodes since a cnf-ified qual clause
 * will have List structure at the top level, and it handles TargetEntry nodes
 * so that a scan of a target list can be handled without additional code.
 * Also, RangeTblRef, FromExpr, JoinExpr, and SetOperationStmt nodes are
 * handled, so that query jointrees and setOperation trees can be processed
 * without additional code.
 *
 * expression_tree_walker will handle SubLink nodes by recursing normally
 * into the "testexpr" subtree (which is an expression belonging to the outer
 * plan).  It will also call the walker on the sub-Query node; however, when
 * expression_tree_walker itself is called on a Query node, it does nothing
 * and returns "false".  The net effect is that unless the walker does
 * something special at a Query node, sub-selects will not be visited during
 * an expression tree walk. This is exactly the behavior wanted in many cases
 * --- and for those walkers that do want to recurse into sub-selects, special
 * behavior is typically needed anyway at the entry to a sub-select (such as
 * incrementing a depth counter). A walker that wants to examine sub-selects
 * should include code along the lines of:
 *
 *  if (IsA(node, Query))
 *  {
 *   adjust context for subquery;
 *   result = query_tree_walker((Query *) node, my_walker, context,
 *            0); // adjust flags as needed
 *   restore context if needed;
 *   return result;
 *  }
 *
 * query_tree_walker is a convenience routine (see below) that calls the
 * walker on all the expression subtrees of the given Query node.
 *
 * expression_tree_walker will handle SubPlan nodes by recursing normally
 * into the "testexpr" and the "args" list (which are expressions belonging to
 * the outer plan).  It will not touch the completed subplan, however.  Since
 * there is no link to the original Query, it is not possible to recurse into
 * subselects of an already-planned expression tree.  This is OK for current
 * uses, but may need to be revisited in future.
 */

bool
expression_tree_walker_impl(Node *node,
       tree_walker_callback walker,
       void *context)
{
 ListCell   *temp;

 /*
  * The walker has already visited the current node, and so we need only
  * recurse into any sub-nodes it has.
  *
  * We assume that the walker is not interested in List nodes per se, so
  * when we expect a List we just recurse directly to self without
  * bothering to call the walker.
 */
#define WALK(n) walker((Node *) (n), context)

#define LIST_WALK(l) expression_tree_walker_impl((Node *) (l), walker, context)

 if (node == NULL)
  return false;

 /* Guard against stack overflow due to overly complex expressions */
 check_stack_depth();

 switch (nodeTag(node))
 {
  case T_Var:
  case T_Const:
  case T_Param:
  case T_CaseTestExpr:
  case T_SQLValueFunction:
  case T_CoerceToDomainValue:
  case T_SetToDefault:
  case T_CurrentOfExpr:
  case T_NextValueExpr:
  case T_RangeTblRef:
  case T_SortGroupClause:
  case T_CTESearchClause:
  case T_MergeSupportFunc:
   /* primitive node types with no expression subnodes */
   break;
  case T_WithCheckOption:
   return WALK(((WithCheckOption *) node)->qual);
  case T_Aggref:
   {
    Aggref    *expr = (Aggref *) node;

    /* recurse directly on Lists */
    if (LIST_WALK(expr->aggdirectargs))
     return true;
    if (LIST_WALK(expr->args))
     return true;
    if (LIST_WALK(expr->aggorder))
     return true;
    if (LIST_WALK(expr->aggdistinct))
     return true;
    if (WALK(expr->aggfilter))
     return true;
   }
   break;
  case T_GroupingFunc:
   {
    GroupingFunc *grouping = (GroupingFunc *) node;

    if (LIST_WALK(grouping->args))
     return true;
   }
   break;
  case T_WindowFunc:
   {
    WindowFunc *expr = (WindowFunc *) node;

    /* recurse directly on List */
    if (LIST_WALK(expr->args))
     return true;
    if (WALK(expr->aggfilter))
     return true;
    if (WALK(expr->runCondition))
     return true;
   }
   break;
  case T_WindowFuncRunCondition:
   {
    WindowFuncRunCondition *expr = (WindowFuncRunCondition *) node;

    if (WALK(expr->arg))
     return true;
   }
   break;
  case T_SubscriptingRef:
   {
    SubscriptingRef *sbsref = (SubscriptingRef *) node;

    /* recurse directly for upper/lower container index lists */
    if (LIST_WALK(sbsref->refupperindexpr))
     return true;
    if (LIST_WALK(sbsref->reflowerindexpr))
     return true;
    /* walker must see the refexpr and refassgnexpr, however */
    if (WALK(sbsref->refexpr))
     return true;

    if (WALK(sbsref->refassgnexpr))
     return true;
   }
   break;
  case T_FuncExpr:
   {
    FuncExpr   *expr = (FuncExpr *) node;

    if (LIST_WALK(expr->args))
     return true;
   }
   break;
  case T_NamedArgExpr:
   return WALK(((NamedArgExpr *) node)->arg);
  case T_OpExpr:
  case T_DistinctExpr: /* struct-equivalent to OpExpr */
  case T_NullIfExpr:  /* struct-equivalent to OpExpr */
   {
    OpExpr    *expr = (OpExpr *) node;

    if (LIST_WALK(expr->args))
     return true;
   }
   break;
  case T_ScalarArrayOpExpr:
   {
    ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;

    if (LIST_WALK(expr->args))
     return true;
   }
   break;
  case T_BoolExpr:
   {
    BoolExpr   *expr = (BoolExpr *) node;

    if (LIST_WALK(expr->args))
     return true;
   }
   break;
  case T_SubLink:
   {
    SubLink    *sublink = (SubLink *) node;

    if (WALK(sublink->testexpr))
     return true;

    /*
     * Also invoke the walker on the sublink's Query node, so it
     * can recurse into the sub-query if it wants to.
 */
    return WALK(sublink->subselect);
   }
   break;
  case T_SubPlan:
   {
    SubPlan    *subplan = (SubPlan *) node;

    /* recurse into the testexpr, but not into the Plan */
    if (WALK(subplan->testexpr))
     return true;
    /* also examine args list */
    if (LIST_WALK(subplan->args))
     return true;
   }
   break;
  case T_AlternativeSubPlan:
   return LIST_WALK(((AlternativeSubPlan *) node)->subplans);
  case T_FieldSelect:
   return WALK(((FieldSelect *) node)->arg);
  case T_FieldStore:
   {
    FieldStore *fstore = (FieldStore *) node;

    if (WALK(fstore->arg))
     return true;
    if (WALK(fstore->newvals))
     return true;
   }
   break;
  case T_RelabelType:
   return WALK(((RelabelType *) node)->arg);
  case T_CoerceViaIO:
   return WALK(((CoerceViaIO *) node)->arg);
  case T_ArrayCoerceExpr:
   {
    ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;

    if (WALK(acoerce->arg))
     return true;
    if (WALK(acoerce->elemexpr))
     return true;
   }
   break;
  case T_ConvertRowtypeExpr:
   return WALK(((ConvertRowtypeExpr *) node)->arg);
  case T_CollateExpr:
   return WALK(((CollateExpr *) node)->arg);
  case T_CaseExpr:
   {
    CaseExpr   *caseexpr = (CaseExpr *) node;

    if (WALK(caseexpr->arg))
     return true;
    /* we assume walker doesn't care about CaseWhens, either */
    foreach(temp, caseexpr->args)
    {
     CaseWhen   *when = lfirst_node(CaseWhen, temp);

     if (WALK(when->expr))
      return true;
     if (WALK(when->result))
      return true;
    }
    if (WALK(caseexpr->defresult))
     return true;
   }
   break;
  case T_ArrayExpr:
   return WALK(((ArrayExpr *) node)->elements);
  case T_RowExpr:
   /* Assume colnames isn't interesting */
   return WALK(((RowExpr *) node)->args);
  case T_RowCompareExpr:
   {
    RowCompareExpr *rcexpr = (RowCompareExpr *) node;

    if (WALK(rcexpr->largs))
     return true;
    if (WALK(rcexpr->rargs))
     return true;
   }
   break;
  case T_CoalesceExpr:
   return WALK(((CoalesceExpr *) node)->args);
  case T_MinMaxExpr:
   return WALK(((MinMaxExpr *) node)->args);
  case T_XmlExpr:
   {
    XmlExpr    *xexpr = (XmlExpr *) node;

    if (WALK(xexpr->named_args))
     return true;
    /* we assume walker doesn't care about arg_names */
    if (WALK(xexpr->args))
     return true;
   }
   break;
  case T_JsonValueExpr:
   {
    JsonValueExpr *jve = (JsonValueExpr *) node;

    if (WALK(jve->raw_expr))
     return true;
    if (WALK(jve->formatted_expr))
     return true;
   }
   break;
  case T_JsonConstructorExpr:
   {
    JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;

    if (WALK(ctor->args))
     return true;
    if (WALK(ctor->func))
     return true;
    if (WALK(ctor->coercion))
     return true;
   }
   break;
  case T_JsonIsPredicate:
   return WALK(((JsonIsPredicate *) node)->expr);
  case T_JsonExpr:
   {
    JsonExpr   *jexpr = (JsonExpr *) node;

    if (WALK(jexpr->formatted_expr))
     return true;
    if (WALK(jexpr->path_spec))
     return true;
    if (WALK(jexpr->passing_values))
     return true;
    /* we assume walker doesn't care about passing_names */
    if (WALK(jexpr->on_empty))
     return true;
    if (WALK(jexpr->on_error))
     return true;
   }
   break;
  case T_JsonBehavior:
   {
    JsonBehavior *behavior = (JsonBehavior *) node;

    if (WALK(behavior->expr))
     return true;
   }
   break;
  case T_NullTest:
   return WALK(((NullTest *) node)->arg);
  case T_BooleanTest:
   return WALK(((BooleanTest *) node)->arg);
  case T_CoerceToDomain:
   return WALK(((CoerceToDomain *) node)->arg);
  case T_TargetEntry:
   return WALK(((TargetEntry *) node)->expr);
  case T_Query:
   /* Do nothing with a sub-Query, per discussion above */
   break;
  case T_WindowClause:
   {
    WindowClause *wc = (WindowClause *) node;

    if (WALK(wc->partitionClause))
     return true;
    if (WALK(wc->orderClause))
     return true;
    if (WALK(wc->startOffset))
     return true;
    if (WALK(wc->endOffset))
     return true;
   }
   break;
  case T_CTECycleClause:
   {
    CTECycleClause *cc = (CTECycleClause *) node;

    if (WALK(cc->cycle_mark_value))
     return true;
    if (WALK(cc->cycle_mark_default))
     return true;
   }
   break;
  case T_CommonTableExpr:
   {
    CommonTableExpr *cte = (CommonTableExpr *) node;

    /*
     * Invoke the walker on the CTE's Query node, so it can
     * recurse into the sub-query if it wants to.
 */
    if (WALK(cte->ctequery))
     return true;

    if (WALK(cte->search_clause))
     return true;
    if (WALK(cte->cycle_clause))
     return true;
   }
   break;
  case T_JsonKeyValue:
   {
    JsonKeyValue *kv = (JsonKeyValue *) node;

    if (WALK(kv->key))
     return true;
    if (WALK(kv->value))
     return true;
   }
   break;
  case T_JsonObjectConstructor:
   {
    JsonObjectConstructor *ctor = (JsonObjectConstructor *) node;

    if (LIST_WALK(ctor->exprs))
     return true;
   }
   break;
  case T_JsonArrayConstructor:
   {
    JsonArrayConstructor *ctor = (JsonArrayConstructor *) node;

    if (LIST_WALK(ctor->exprs))
     return true;
   }
   break;
  case T_JsonArrayQueryConstructor:
   {
    JsonArrayQueryConstructor *ctor = (JsonArrayQueryConstructor *) node;

    if (WALK(ctor->query))
     return true;
   }
   break;
  case T_JsonAggConstructor:
   {
    JsonAggConstructor *ctor = (JsonAggConstructor *) node;

    if (WALK(ctor->agg_filter))
     return true;
    if (WALK(ctor->agg_order))
     return true;
    if (WALK(ctor->over))
     return true;
   }
   break;
  case T_JsonObjectAgg:
   {
    JsonObjectAgg *ctor = (JsonObjectAgg *) node;

    if (WALK(ctor->constructor))
     return true;
    if (WALK(ctor->arg))
     return true;
   }
   break;
  case T_JsonArrayAgg:
   {
    JsonArrayAgg *ctor = (JsonArrayAgg *) node;

    if (WALK(ctor->constructor))
     return true;
    if (WALK(ctor->arg))
     return true;
   }
   break;

  case T_PartitionBoundSpec:
   {
    PartitionBoundSpec *pbs = (PartitionBoundSpec *) node;

    if (WALK(pbs->listdatums))
     return true;
    if (WALK(pbs->lowerdatums))
     return true;
    if (WALK(pbs->upperdatums))
     return true;
   }
   break;
  case T_PartitionRangeDatum:
   {
    PartitionRangeDatum *prd = (PartitionRangeDatum *) node;

    if (WALK(prd->value))
     return true;
   }
   break;
  case T_List:
   foreach(temp, (List *) node)
   {
    if (WALK(lfirst(temp)))
     return true;
   }
   break;
  case T_FromExpr:
   {
    FromExpr   *from = (FromExpr *) node;

    if (LIST_WALK(from->fromlist))
     return true;
    if (WALK(from->quals))
     return true;
   }
   break;
  case T_OnConflictExpr:
   {
    OnConflictExpr *onconflict = (OnConflictExpr *) node;

    if (WALK(onconflict->arbiterElems))
     return true;
    if (WALK(onconflict->arbiterWhere))
     return true;
    if (WALK(onconflict->onConflictSet))
     return true;
    if (WALK(onconflict->onConflictWhere))
     return true;
    if (WALK(onconflict->exclRelTlist))
     return true;
   }
   break;
  case T_MergeAction:
   {
    MergeAction *action = (MergeAction *) node;

    if (WALK(action->qual))
     return true;
    if (WALK(action->targetList))
     return true;
   }
   break;
  case T_PartitionPruneStepOp:
   {
    PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;

    if (WALK(opstep->exprs))
     return true;
   }
   break;
  case T_PartitionPruneStepCombine:
   /* no expression subnodes */
   break;
  case T_JoinExpr:
   {
    JoinExpr   *join = (JoinExpr *) node;

    if (WALK(join->larg))
     return true;
    if (WALK(join->rarg))
     return true;
    if (WALK(join->quals))
     return true;

    /*
     * alias clause, using list are deemed uninteresting.
 */
   }
   break;
  case T_SetOperationStmt:
   {
    SetOperationStmt *setop = (SetOperationStmt *) node;

    if (WALK(setop->larg))
     return true;
    if (WALK(setop->rarg))
     return true;

    /* groupClauses are deemed uninteresting */
   }
   break;
  case T_IndexClause:
   {
    IndexClause *iclause = (IndexClause *) node;

    if (WALK(iclause->rinfo))
     return true;
    if (LIST_WALK(iclause->indexquals))
     return true;
   }
   break;
  case T_PlaceHolderVar:
   return WALK(((PlaceHolderVar *) node)->phexpr);
  case T_InferenceElem:
   return WALK(((InferenceElem *) node)->expr);
  case T_ReturningExpr:
   return WALK(((ReturningExpr *) node)->retexpr);
  case T_AppendRelInfo:
   {
    AppendRelInfo *appinfo = (AppendRelInfo *) node;

    if (LIST_WALK(appinfo->translated_vars))
     return true;
   }
   break;
  case T_PlaceHolderInfo:
   return WALK(((PlaceHolderInfo *) node)->ph_var);
  case T_RangeTblFunction:
   return WALK(((RangeTblFunction *) node)->funcexpr);
  case T_TableSampleClause:
   {
    TableSampleClause *tsc = (TableSampleClause *) node;

    if (LIST_WALK(tsc->args))
     return true;
    if (WALK(tsc->repeatable))
     return true;
   }
   break;
  case T_TableFunc:
   {
    TableFunc  *tf = (TableFunc *) node;

    if (WALK(tf->ns_uris))
     return true;
    if (WALK(tf->docexpr))
     return true;
    if (WALK(tf->rowexpr))
     return true;
    if (WALK(tf->colexprs))
     return true;
    if (WALK(tf->coldefexprs))
     return true;
    if (WALK(tf->colvalexprs))
     return true;
    if (WALK(tf->passingvalexprs))
     return true;
   }
   break;
  default:
   elog(ERROR, "unrecognized node type: %d",
     (int) nodeTag(node));
   break;
 }
 return false;

 /* The WALK() macro can be re-used below, but LIST_WALK() not so much */
#undef LIST_WALK
}

/*
 * query_tree_walker --- initiate a walk of a Query's expressions
 *
 * This routine exists just to reduce the number of places that need to know
 * where all the expression subtrees of a Query are.  Note it can be used
 * for starting a walk at top level of a Query regardless of whether the
 * walker intends to descend into subqueries.  It is also useful for
 * descending into subqueries within a walker.
 *
 * Some callers want to suppress visitation of certain items in the sub-Query,
 * typically because they need to process them specially, or don't actually
 * want to recurse into subqueries.  This is supported by the flags argument,
 * which is the bitwise OR of flag values to add or suppress visitation of
 * indicated items.  (More flag bits may be added as needed.)
 */
bool
query_tree_walker_impl(Query *query,
        tree_walker_callback walker,
        void *context,
        int flags)
{
 Assert(query != NULL && IsA(query, Query));

 /*
  * We don't walk any utilityStmt here. However, we can't easily assert
  * that it is absent, since there are at least two code paths by which
  * action statements from CREATE RULE end up here, and NOTIFY is allowed
  * in a rule action.
 */

 if (WALK(query->targetList))
  return true;
 if (WALK(query->withCheckOptions))
  return true;
 if (WALK(query->onConflict))
  return true;
 if (WALK(query->mergeActionList))
  return true;
 if (WALK(query->mergeJoinCondition))
  return true;
 if (WALK(query->returningList))
  return true;
 if (WALK(query->jointree))
  return true;
 if (WALK(query->setOperations))
  return true;
 if (WALK(query->havingQual))
  return true;
 if (WALK(query->limitOffset))
  return true;
 if (WALK(query->limitCount))
  return true;

 /*
  * Most callers aren't interested in SortGroupClause nodes since those
  * don't contain actual expressions. However they do contain OIDs which
  * may be needed by dependency walkers etc.
 */
 if ((flags & QTW_EXAMINE_SORTGROUP))
 {
  if (WALK(query->groupClause))
   return true;
  if (WALK(query->windowClause))
   return true;
  if (WALK(query->sortClause))
   return true;
  if (WALK(query->distinctClause))
   return true;
 }
 else
 {
  /*
   * But we need to walk the expressions under WindowClause nodes even
   * if we're not interested in SortGroupClause nodes.
 */
  ListCell   *lc;

  foreach(lc, query->windowClause)
  {
   WindowClause *wc = lfirst_node(WindowClause, lc);

   if (WALK(wc->startOffset))
    return true;
   if (WALK(wc->endOffset))
    return true;
  }
 }

 /*
  * groupingSets and rowMarks are not walked:
  *
  * groupingSets contain only ressortgrouprefs (integers) which are
  * meaningless without the corresponding groupClause or tlist.
  * Accordingly, any walker that needs to care about them needs to handle
  * them itself in its Query processing.
  *
  * rowMarks is not walked because it contains only rangetable indexes (and
  * flags etc.) and therefore should be handled at Query level similarly.
 */

 if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
 {
  if (WALK(query->cteList))
   return true;
 }
 if (!(flags & QTW_IGNORE_RANGE_TABLE))
 {
  if (range_table_walker(query->rtable, walker, context, flags))
   return true;
 }
 return false;
}

/*
 * range_table_walker is just the part of query_tree_walker that scans
 * a query's rangetable.  This is split out since it can be useful on
 * its own.
 */
bool
range_table_walker_impl(List *rtable,
      tree_walker_callback walker,
      void *context,
      int flags)
{
 ListCell   *rt;

 foreach(rt, rtable)
 {
  RangeTblEntry *rte = lfirst_node(RangeTblEntry, rt);

  if (range_table_entry_walker(rte, walker, context, flags))
   return true;
 }
 return false;
}

/*
 * Some callers even want to scan the expressions in individual RTEs.
 */
bool
range_table_entry_walker_impl(RangeTblEntry *rte,
         tree_walker_callback walker,
         void *context,
         int flags)
{
 /*
  * Walkers might need to examine the RTE node itself either before or
  * after visiting its contents (or, conceivably, both).  Note that if you
  * specify neither flag, the walker won't be called on the RTE at all.
 */
 if (flags & QTW_EXAMINE_RTES_BEFORE)
  if (WALK(rte))
   return true;

 switch (rte->rtekind)
 {
  case RTE_RELATION:
   if (WALK(rte->tablesample))
    return true;
   break;
  case RTE_SUBQUERY:
   if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
    if (WALK(rte->subquery))
     return true;
   break;
  case RTE_JOIN:
   if (!(flags & QTW_IGNORE_JOINALIASES))
    if (WALK(rte->joinaliasvars))
     return true;
   break;
  case RTE_FUNCTION:
   if (WALK(rte->functions))
    return true;
   break;
  case RTE_TABLEFUNC:
   if (WALK(rte->tablefunc))
    return true;
   break;
  case RTE_VALUES:
   if (WALK(rte->values_lists))
    return true;
   break;
  case RTE_CTE:
  case RTE_NAMEDTUPLESTORE:
  case RTE_RESULT:
   /* nothing to do */
   break;
  case RTE_GROUP:
   if (!(flags & QTW_IGNORE_GROUPEXPRS))
    if (WALK(rte->groupexprs))
     return true;
   break;
 }

 if (WALK(rte->securityQuals))
  return true;

 if (flags & QTW_EXAMINE_RTES_AFTER)
  if (WALK(rte))
   return true;

 return false;
}


/*
 * expression_tree_mutator() is designed to support routines that make a
 * modified copy of an expression tree, with some nodes being added,
 * removed, or replaced by new subtrees.  The original tree is (normally)
 * not changed.  Each recursion level is responsible for returning a copy of
 * (or appropriately modified substitute for) the subtree it is handed.
 * A mutator routine should look like this:
 *
 * Node * my_mutator (Node *node, my_struct *context)
 * {
 *  if (node == NULL)
 *   return NULL;
 *  // check for nodes that special work is required for, eg:
 *  if (IsA(node, Var))
 *  {
 *   ... create and return modified copy of Var node
 *  }
 *  else if (IsA(node, ...))
 *  {
 *   ... do special transformations of other node types
 *  }
 *  // for any node type not specially processed, do:
 *  return expression_tree_mutator(node, my_mutator, context);
 * }
 *
 * The "context" argument points to a struct that holds whatever context
 * information the mutator routine needs --- it can be used to return extra
 * data gathered by the mutator, too.  This argument is not touched by
 * expression_tree_mutator, but it is passed down to recursive sub-invocations
 * of my_mutator.  The tree walk is started from a setup routine that
 * fills in the appropriate context struct, calls my_mutator with the
 * top-level node of the tree, and does any required post-processing.
 *
 * Each level of recursion must return an appropriately modified Node.
 * If expression_tree_mutator() is called, it will make an exact copy
 * of the given Node, but invoke my_mutator() to copy the sub-node(s)
 * of that Node.  In this way, my_mutator() has full control over the
 * copying process but need not directly deal with expression trees
 * that it has no interest in.
 *
 * Just as for expression_tree_walker, the node types handled by
 * expression_tree_mutator include all those normally found in target lists
 * and qualifier clauses during the planning stage.
 *
 * expression_tree_mutator will handle SubLink nodes by recursing normally
 * into the "testexpr" subtree (which is an expression belonging to the outer
 * plan).  It will also call the mutator on the sub-Query node; however, when
 * expression_tree_mutator itself is called on a Query node, it does nothing
 * and returns the unmodified Query node.  The net effect is that unless the
 * mutator does something special at a Query node, sub-selects will not be
 * visited or modified; the original sub-select will be linked to by the new
 * SubLink node.  Mutators that want to descend into sub-selects will usually
 * do so by recognizing Query nodes and calling query_tree_mutator (below).
 *
 * expression_tree_mutator will handle a SubPlan node by recursing into the
 * "testexpr" and the "args" list (which belong to the outer plan), but it
 * will simply copy the link to the inner plan, since that's typically what
 * expression tree mutators want.  A mutator that wants to modify the subplan
 * can force appropriate behavior by recognizing SubPlan expression nodes
 * and doing the right thing.
 */

Node *
expression_tree_mutator_impl(Node *node,
        tree_mutator_callback mutator,
        void *context)
{
 /*
  * The mutator has already decided not to modify the current node, but we
  * must call the mutator for any sub-nodes.
 */

#define FLATCOPY(newnode, node, nodetype)  \
 ( (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
   memcpy((newnode), (node), sizeof(nodetype)) )

#define MUTATE(newfield, oldfield, fieldtype)  \
  ( (newfield) = (fieldtype) mutator((Node *) (oldfield), context) )

 if (node == NULL)
  return NULL;

 /* Guard against stack overflow due to overly complex expressions */
 check_stack_depth();

 switch (nodeTag(node))
 {
   /*
    * Primitive node types with no expression subnodes.  Var and
    * Const are frequent enough to deserve special cases, the others
    * we just use copyObject for.
 */
  case T_Var:
   {
    Var     *var = (Var *) node;
    Var     *newnode;

    FLATCOPY(newnode, var, Var);
    /* Assume we need not copy the varnullingrels bitmapset */
    return (Node *) newnode;
   }
   break;
  case T_Const:
   {
    Const    *oldnode = (Const *) node;
    Const    *newnode;

    FLATCOPY(newnode, oldnode, Const);
    /* XXX we don't bother with datumCopy; should we? */
    return (Node *) newnode;
   }
   break;
  case T_Param:
  case T_CaseTestExpr:
  case T_SQLValueFunction:
  case T_JsonFormat:
  case T_CoerceToDomainValue:
  case T_SetToDefault:
  case T_CurrentOfExpr:
  case T_NextValueExpr:
  case T_RangeTblRef:
  case T_SortGroupClause:
  case T_CTESearchClause:
  case T_MergeSupportFunc:
   return copyObject(node);
  case T_WithCheckOption:
   {
    WithCheckOption *wco = (WithCheckOption *) node;
    WithCheckOption *newnode;

    FLATCOPY(newnode, wco, WithCheckOption);
    MUTATE(newnode->qual, wco->qual, Node *);
    return (Node *) newnode;
   }
  case T_Aggref:
   {
    Aggref    *aggref = (Aggref *) node;
    Aggref    *newnode;

    FLATCOPY(newnode, aggref, Aggref);
    /* assume mutation doesn't change types of arguments */
    newnode->aggargtypes = list_copy(aggref->aggargtypes);
    MUTATE(newnode->aggdirectargs, aggref->aggdirectargs, List *);
    MUTATE(newnode->args, aggref->args, List *);
    MUTATE(newnode->aggorder, aggref->aggorder, List *);
    MUTATE(newnode->aggdistinct, aggref->aggdistinct, List *);
    MUTATE(newnode->aggfilter, aggref->aggfilter, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_GroupingFunc:
   {
    GroupingFunc *grouping = (GroupingFunc *) node;
    GroupingFunc *newnode;

    FLATCOPY(newnode, grouping, GroupingFunc);
    MUTATE(newnode->args, grouping->args, List *);

    /*
     * We assume here that mutating the arguments does not change
     * the semantics, i.e. that the arguments are not mutated in a
     * way that makes them semantically different from their
     * previously matching expressions in the GROUP BY clause.
     *
     * If a mutator somehow wanted to do this, it would have to
     * handle the refs and cols lists itself as appropriate.
 */
    newnode->refs = list_copy(grouping->refs);
    newnode->cols = list_copy(grouping->cols);

    return (Node *) newnode;
   }
   break;
  case T_WindowFunc:
   {
    WindowFunc *wfunc = (WindowFunc *) node;
    WindowFunc *newnode;

    FLATCOPY(newnode, wfunc, WindowFunc);
    MUTATE(newnode->args, wfunc->args, List *);
    MUTATE(newnode->aggfilter, wfunc->aggfilter, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_WindowFuncRunCondition:
   {
    WindowFuncRunCondition *wfuncrc = (WindowFuncRunCondition *) node;
    WindowFuncRunCondition *newnode;

    FLATCOPY(newnode, wfuncrc, WindowFuncRunCondition);
    MUTATE(newnode->arg, wfuncrc->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_SubscriptingRef:
   {
    SubscriptingRef *sbsref = (SubscriptingRef *) node;
    SubscriptingRef *newnode;

    FLATCOPY(newnode, sbsref, SubscriptingRef);
    MUTATE(newnode->refupperindexpr, sbsref->refupperindexpr,
        List *);
    MUTATE(newnode->reflowerindexpr, sbsref->reflowerindexpr,
        List *);
    MUTATE(newnode->refexpr, sbsref->refexpr,
        Expr *);
    MUTATE(newnode->refassgnexpr, sbsref->refassgnexpr,
        Expr *);

    return (Node *) newnode;
   }
   break;
  case T_FuncExpr:
   {
    FuncExpr   *expr = (FuncExpr *) node;
    FuncExpr   *newnode;

    FLATCOPY(newnode, expr, FuncExpr);
    MUTATE(newnode->args, expr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_NamedArgExpr:
   {
    NamedArgExpr *nexpr = (NamedArgExpr *) node;
    NamedArgExpr *newnode;

    FLATCOPY(newnode, nexpr, NamedArgExpr);
    MUTATE(newnode->arg, nexpr->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_OpExpr:
   {
    OpExpr    *expr = (OpExpr *) node;
    OpExpr    *newnode;

    FLATCOPY(newnode, expr, OpExpr);
    MUTATE(newnode->args, expr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_DistinctExpr:
   {
    DistinctExpr *expr = (DistinctExpr *) node;
    DistinctExpr *newnode;

    FLATCOPY(newnode, expr, DistinctExpr);
    MUTATE(newnode->args, expr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_NullIfExpr:
   {
    NullIfExpr *expr = (NullIfExpr *) node;
    NullIfExpr *newnode;

    FLATCOPY(newnode, expr, NullIfExpr);
    MUTATE(newnode->args, expr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_ScalarArrayOpExpr:
   {
    ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
    ScalarArrayOpExpr *newnode;

    FLATCOPY(newnode, expr, ScalarArrayOpExpr);
    MUTATE(newnode->args, expr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_BoolExpr:
   {
    BoolExpr   *expr = (BoolExpr *) node;
    BoolExpr   *newnode;

    FLATCOPY(newnode, expr, BoolExpr);
    MUTATE(newnode->args, expr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_SubLink:
   {
    SubLink    *sublink = (SubLink *) node;
    SubLink    *newnode;

    FLATCOPY(newnode, sublink, SubLink);
    MUTATE(newnode->testexpr, sublink->testexpr, Node *);

    /*
     * Also invoke the mutator on the sublink's Query node, so it
     * can recurse into the sub-query if it wants to.
 */
    MUTATE(newnode->subselect, sublink->subselect, Node *);
    return (Node *) newnode;
   }
   break;
  case T_SubPlan:
   {
    SubPlan    *subplan = (SubPlan *) node;
    SubPlan    *newnode;

    FLATCOPY(newnode, subplan, SubPlan);
    /* transform testexpr */
    MUTATE(newnode->testexpr, subplan->testexpr, Node *);
    /* transform args list (params to be passed to subplan) */
    MUTATE(newnode->args, subplan->args, List *);
    /* but not the sub-Plan itself, which is referenced as-is */
    return (Node *) newnode;
   }
   break;
  case T_AlternativeSubPlan:
   {
    AlternativeSubPlan *asplan = (AlternativeSubPlan *) node;
    AlternativeSubPlan *newnode;

    FLATCOPY(newnode, asplan, AlternativeSubPlan);
    MUTATE(newnode->subplans, asplan->subplans, List *);
    return (Node *) newnode;
   }
   break;
  case T_FieldSelect:
   {
    FieldSelect *fselect = (FieldSelect *) node;
    FieldSelect *newnode;

    FLATCOPY(newnode, fselect, FieldSelect);
    MUTATE(newnode->arg, fselect->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_FieldStore:
   {
    FieldStore *fstore = (FieldStore *) node;
    FieldStore *newnode;

    FLATCOPY(newnode, fstore, FieldStore);
    MUTATE(newnode->arg, fstore->arg, Expr *);
    MUTATE(newnode->newvals, fstore->newvals, List *);
    newnode->fieldnums = list_copy(fstore->fieldnums);
    return (Node *) newnode;
   }
   break;
  case T_RelabelType:
   {
    RelabelType *relabel = (RelabelType *) node;
    RelabelType *newnode;

    FLATCOPY(newnode, relabel, RelabelType);
    MUTATE(newnode->arg, relabel->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_CoerceViaIO:
   {
    CoerceViaIO *iocoerce = (CoerceViaIO *) node;
    CoerceViaIO *newnode;

    FLATCOPY(newnode, iocoerce, CoerceViaIO);
    MUTATE(newnode->arg, iocoerce->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_ArrayCoerceExpr:
   {
    ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
    ArrayCoerceExpr *newnode;

    FLATCOPY(newnode, acoerce, ArrayCoerceExpr);
    MUTATE(newnode->arg, acoerce->arg, Expr *);
    MUTATE(newnode->elemexpr, acoerce->elemexpr, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_ConvertRowtypeExpr:
   {
    ConvertRowtypeExpr *convexpr = (ConvertRowtypeExpr *) node;
    ConvertRowtypeExpr *newnode;

    FLATCOPY(newnode, convexpr, ConvertRowtypeExpr);
    MUTATE(newnode->arg, convexpr->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_CollateExpr:
   {
    CollateExpr *collate = (CollateExpr *) node;
    CollateExpr *newnode;

    FLATCOPY(newnode, collate, CollateExpr);
    MUTATE(newnode->arg, collate->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_CaseExpr:
   {
    CaseExpr   *caseexpr = (CaseExpr *) node;
    CaseExpr   *newnode;

    FLATCOPY(newnode, caseexpr, CaseExpr);
    MUTATE(newnode->arg, caseexpr->arg, Expr *);
    MUTATE(newnode->args, caseexpr->args, List *);
    MUTATE(newnode->defresult, caseexpr->defresult, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_CaseWhen:
   {
    CaseWhen   *casewhen = (CaseWhen *) node;
    CaseWhen   *newnode;

    FLATCOPY(newnode, casewhen, CaseWhen);
    MUTATE(newnode->expr, casewhen->expr, Expr *);
    MUTATE(newnode->result, casewhen->result, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_ArrayExpr:
   {
    ArrayExpr  *arrayexpr = (ArrayExpr *) node;
    ArrayExpr  *newnode;

    FLATCOPY(newnode, arrayexpr, ArrayExpr);
    MUTATE(newnode->elements, arrayexpr->elements, List *);
    return (Node *) newnode;
   }
   break;
  case T_RowExpr:
   {
    RowExpr    *rowexpr = (RowExpr *) node;
    RowExpr    *newnode;

    FLATCOPY(newnode, rowexpr, RowExpr);
    MUTATE(newnode->args, rowexpr->args, List *);
    /* Assume colnames needn't be duplicated */
    return (Node *) newnode;
   }
   break;
  case T_RowCompareExpr:
   {
    RowCompareExpr *rcexpr = (RowCompareExpr *) node;
    RowCompareExpr *newnode;

    FLATCOPY(newnode, rcexpr, RowCompareExpr);
    MUTATE(newnode->largs, rcexpr->largs, List *);
    MUTATE(newnode->rargs, rcexpr->rargs, List *);
    return (Node *) newnode;
   }
   break;
  case T_CoalesceExpr:
   {
    CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
    CoalesceExpr *newnode;

    FLATCOPY(newnode, coalesceexpr, CoalesceExpr);
    MUTATE(newnode->args, coalesceexpr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_MinMaxExpr:
   {
    MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
    MinMaxExpr *newnode;

    FLATCOPY(newnode, minmaxexpr, MinMaxExpr);
    MUTATE(newnode->args, minmaxexpr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_XmlExpr:
   {
    XmlExpr    *xexpr = (XmlExpr *) node;
    XmlExpr    *newnode;

    FLATCOPY(newnode, xexpr, XmlExpr);
    MUTATE(newnode->named_args, xexpr->named_args, List *);
    /* assume mutator does not care about arg_names */
    MUTATE(newnode->args, xexpr->args, List *);
    return (Node *) newnode;
   }
   break;
  case T_JsonReturning:
   {
    JsonReturning *jr = (JsonReturning *) node;
    JsonReturning *newnode;

    FLATCOPY(newnode, jr, JsonReturning);
    MUTATE(newnode->format, jr->format, JsonFormat *);

    return (Node *) newnode;
   }
  case T_JsonValueExpr:
   {
    JsonValueExpr *jve = (JsonValueExpr *) node;
    JsonValueExpr *newnode;

    FLATCOPY(newnode, jve, JsonValueExpr);
    MUTATE(newnode->raw_expr, jve->raw_expr, Expr *);
    MUTATE(newnode->formatted_expr, jve->formatted_expr, Expr *);
    MUTATE(newnode->format, jve->format, JsonFormat *);

    return (Node *) newnode;
   }
  case T_JsonConstructorExpr:
   {
    JsonConstructorExpr *jce = (JsonConstructorExpr *) node;
    JsonConstructorExpr *newnode;

    FLATCOPY(newnode, jce, JsonConstructorExpr);
    MUTATE(newnode->args, jce->args, List *);
    MUTATE(newnode->func, jce->func, Expr *);
    MUTATE(newnode->coercion, jce->coercion, Expr *);
    MUTATE(newnode->returning, jce->returning, JsonReturning *);

    return (Node *) newnode;
   }
  case T_JsonIsPredicate:
   {
    JsonIsPredicate *pred = (JsonIsPredicate *) node;
    JsonIsPredicate *newnode;

    FLATCOPY(newnode, pred, JsonIsPredicate);
    MUTATE(newnode->expr, pred->expr, Node *);
    MUTATE(newnode->format, pred->format, JsonFormat *);

    return (Node *) newnode;
   }
  case T_JsonExpr:
   {
    JsonExpr   *jexpr = (JsonExpr *) node;
    JsonExpr   *newnode;

    FLATCOPY(newnode, jexpr, JsonExpr);
    MUTATE(newnode->formatted_expr, jexpr->formatted_expr, Node *);
    MUTATE(newnode->path_spec, jexpr->path_spec, Node *);
    MUTATE(newnode->passing_values, jexpr->passing_values, List *);
    /* assume mutator does not care about passing_names */
    MUTATE(newnode->on_empty, jexpr->on_empty, JsonBehavior *);
    MUTATE(newnode->on_error, jexpr->on_error, JsonBehavior *);
    return (Node *) newnode;
   }
   break;
  case T_JsonBehavior:
   {
    JsonBehavior *behavior = (JsonBehavior *) node;
    JsonBehavior *newnode;

    FLATCOPY(newnode, behavior, JsonBehavior);
    MUTATE(newnode->expr, behavior->expr, Node *);
    return (Node *) newnode;
   }
   break;
  case T_NullTest:
   {
    NullTest   *ntest = (NullTest *) node;
    NullTest   *newnode;

    FLATCOPY(newnode, ntest, NullTest);
    MUTATE(newnode->arg, ntest->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_BooleanTest:
   {
    BooleanTest *btest = (BooleanTest *) node;
    BooleanTest *newnode;

    FLATCOPY(newnode, btest, BooleanTest);
    MUTATE(newnode->arg, btest->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_CoerceToDomain:
   {
    CoerceToDomain *ctest = (CoerceToDomain *) node;
    CoerceToDomain *newnode;

    FLATCOPY(newnode, ctest, CoerceToDomain);
    MUTATE(newnode->arg, ctest->arg, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_ReturningExpr:
   {
    ReturningExpr *rexpr = (ReturningExpr *) node;
    ReturningExpr *newnode;

    FLATCOPY(newnode, rexpr, ReturningExpr);
    MUTATE(newnode->retexpr, rexpr->retexpr, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_TargetEntry:
   {
    TargetEntry *targetentry = (TargetEntry *) node;
    TargetEntry *newnode;

    FLATCOPY(newnode, targetentry, TargetEntry);
    MUTATE(newnode->expr, targetentry->expr, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_Query:
   /* Do nothing with a sub-Query, per discussion above */
   return node;
  case T_WindowClause:
   {
    WindowClause *wc = (WindowClause *) node;
    WindowClause *newnode;

    FLATCOPY(newnode, wc, WindowClause);
    MUTATE(newnode->partitionClause, wc->partitionClause, List *);
    MUTATE(newnode->orderClause, wc->orderClause, List *);
    MUTATE(newnode->startOffset, wc->startOffset, Node *);
    MUTATE(newnode->endOffset, wc->endOffset, Node *);
    return (Node *) newnode;
   }
   break;
  case T_CTECycleClause:
   {
    CTECycleClause *cc = (CTECycleClause *) node;
    CTECycleClause *newnode;

    FLATCOPY(newnode, cc, CTECycleClause);
    MUTATE(newnode->cycle_mark_value, cc->cycle_mark_value, Node *);
    MUTATE(newnode->cycle_mark_default, cc->cycle_mark_default, Node *);
    return (Node *) newnode;
   }
   break;
  case T_CommonTableExpr:
   {
    CommonTableExpr *cte = (CommonTableExpr *) node;
    CommonTableExpr *newnode;

    FLATCOPY(newnode, cte, CommonTableExpr);

    /*
     * Also invoke the mutator on the CTE's Query node, so it can
     * recurse into the sub-query if it wants to.
 */
    MUTATE(newnode->ctequery, cte->ctequery, Node *);

    MUTATE(newnode->search_clause, cte->search_clause, CTESearchClause *);
    MUTATE(newnode->cycle_clause, cte->cycle_clause, CTECycleClause *);

    return (Node *) newnode;
   }
   break;
  case T_PartitionBoundSpec:
   {
    PartitionBoundSpec *pbs = (PartitionBoundSpec *) node;
    PartitionBoundSpec *newnode;

    FLATCOPY(newnode, pbs, PartitionBoundSpec);
    MUTATE(newnode->listdatums, pbs->listdatums, List *);
    MUTATE(newnode->lowerdatums, pbs->lowerdatums, List *);
    MUTATE(newnode->upperdatums, pbs->upperdatums, List *);
    return (Node *) newnode;
   }
   break;
  case T_PartitionRangeDatum:
   {
    PartitionRangeDatum *prd = (PartitionRangeDatum *) node;
    PartitionRangeDatum *newnode;

    FLATCOPY(newnode, prd, PartitionRangeDatum);
    MUTATE(newnode->value, prd->value, Node *);
    return (Node *) newnode;
   }
   break;
  case T_List:
   {
    /*
     * We assume the mutator isn't interested in the list nodes
     * per se, so just invoke it on each list element. NOTE: this
     * would fail badly on a list with integer elements!
 */
    List    *resultlist;
    ListCell   *temp;

    resultlist = NIL;
    foreach(temp, (List *) node)
    {
     resultlist = lappend(resultlist,
           mutator((Node *) lfirst(temp),
             context));
    }
    return (Node *) resultlist;
   }
   break;
  case T_FromExpr:
   {
    FromExpr   *from = (FromExpr *) node;
    FromExpr   *newnode;

    FLATCOPY(newnode, from, FromExpr);
    MUTATE(newnode->fromlist, from->fromlist, List *);
    MUTATE(newnode->quals, from->quals, Node *);
    return (Node *) newnode;
   }
   break;
  case T_OnConflictExpr:
   {
    OnConflictExpr *oc = (OnConflictExpr *) node;
    OnConflictExpr *newnode;

    FLATCOPY(newnode, oc, OnConflictExpr);
    MUTATE(newnode->arbiterElems, oc->arbiterElems, List *);
    MUTATE(newnode->arbiterWhere, oc->arbiterWhere, Node *);
    MUTATE(newnode->onConflictSet, oc->onConflictSet, List *);
    MUTATE(newnode->onConflictWhere, oc->onConflictWhere, Node *);
    MUTATE(newnode->exclRelTlist, oc->exclRelTlist, List *);

    return (Node *) newnode;
   }
   break;
  case T_MergeAction:
   {
    MergeAction *action = (MergeAction *) node;
    MergeAction *newnode;

    FLATCOPY(newnode, action, MergeAction);
    MUTATE(newnode->qual, action->qual, Node *);
    MUTATE(newnode->targetList, action->targetList, List *);

    return (Node *) newnode;
   }
   break;
  case T_PartitionPruneStepOp:
   {
    PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;
    PartitionPruneStepOp *newnode;

    FLATCOPY(newnode, opstep, PartitionPruneStepOp);
    MUTATE(newnode->exprs, opstep->exprs, List *);

    return (Node *) newnode;
   }
   break;
  case T_PartitionPruneStepCombine:
   /* no expression sub-nodes */
   return copyObject(node);
  case T_JoinExpr:
   {
    JoinExpr   *join = (JoinExpr *) node;
    JoinExpr   *newnode;

    FLATCOPY(newnode, join, JoinExpr);
    MUTATE(newnode->larg, join->larg, Node *);
    MUTATE(newnode->rarg, join->rarg, Node *);
    MUTATE(newnode->quals, join->quals, Node *);
    /* We do not mutate alias or using by default */
    return (Node *) newnode;
   }
   break;
  case T_SetOperationStmt:
   {
    SetOperationStmt *setop = (SetOperationStmt *) node;
    SetOperationStmt *newnode;

    FLATCOPY(newnode, setop, SetOperationStmt);
    MUTATE(newnode->larg, setop->larg, Node *);
    MUTATE(newnode->rarg, setop->rarg, Node *);
    /* We do not mutate groupClauses by default */
    return (Node *) newnode;
   }
   break;
  case T_IndexClause:
   {
    IndexClause *iclause = (IndexClause *) node;
    IndexClause *newnode;

    FLATCOPY(newnode, iclause, IndexClause);
    MUTATE(newnode->rinfo, iclause->rinfo, RestrictInfo *);
    MUTATE(newnode->indexquals, iclause->indexquals, List *);
    return (Node *) newnode;
   }
   break;
  case T_PlaceHolderVar:
   {
    PlaceHolderVar *phv = (PlaceHolderVar *) node;
    PlaceHolderVar *newnode;

    FLATCOPY(newnode, phv, PlaceHolderVar);
    MUTATE(newnode->phexpr, phv->phexpr, Expr *);
    /* Assume we need not copy the relids bitmapsets */
    return (Node *) newnode;
   }
   break;
  case T_InferenceElem:
   {
    InferenceElem *inferenceelemdexpr = (InferenceElem *) node;
    InferenceElem *newnode;

    FLATCOPY(newnode, inferenceelemdexpr, InferenceElem);
    MUTATE(newnode->expr, newnode->expr, Node *);
    return (Node *) newnode;
   }
   break;
  case T_AppendRelInfo:
   {
    AppendRelInfo *appinfo = (AppendRelInfo *) node;
    AppendRelInfo *newnode;

    FLATCOPY(newnode, appinfo, AppendRelInfo);
    MUTATE(newnode->translated_vars, appinfo->translated_vars, List *);
    /* Assume nothing need be done with parent_colnos[] */
    return (Node *) newnode;
   }
   break;
  case T_PlaceHolderInfo:
   {
    PlaceHolderInfo *phinfo = (PlaceHolderInfo *) node;
    PlaceHolderInfo *newnode;

    FLATCOPY(newnode, phinfo, PlaceHolderInfo);
    MUTATE(newnode->ph_var, phinfo->ph_var, PlaceHolderVar *);
    /* Assume we need not copy the relids bitmapsets */
    return (Node *) newnode;
   }
   break;
  case T_RangeTblFunction:
   {
    RangeTblFunction *rtfunc = (RangeTblFunction *) node;
    RangeTblFunction *newnode;

    FLATCOPY(newnode, rtfunc, RangeTblFunction);
    MUTATE(newnode->funcexpr, rtfunc->funcexpr, Node *);
    /* Assume we need not copy the coldef info lists */
    return (Node *) newnode;
   }
   break;
  case T_TableSampleClause:
   {
    TableSampleClause *tsc = (TableSampleClause *) node;
    TableSampleClause *newnode;

    FLATCOPY(newnode, tsc, TableSampleClause);
    MUTATE(newnode->args, tsc->args, List *);
    MUTATE(newnode->repeatable, tsc->repeatable, Expr *);
    return (Node *) newnode;
   }
   break;
  case T_TableFunc:
   {
    TableFunc  *tf = (TableFunc *) node;
    TableFunc  *newnode;

    FLATCOPY(newnode, tf, TableFunc);
    MUTATE(newnode->ns_uris, tf->ns_uris, List *);
    MUTATE(newnode->docexpr, tf->docexpr, Node *);
    MUTATE(newnode->rowexpr, tf->rowexpr, Node *);
    MUTATE(newnode->colexprs, tf->colexprs, List *);
    MUTATE(newnode->coldefexprs, tf->coldefexprs, List *);
    MUTATE(newnode->colvalexprs, tf->colvalexprs, List *);
    MUTATE(newnode->passingvalexprs, tf->passingvalexprs, List *);
    return (Node *) newnode;
   }
   break;
  default:
   elog(ERROR, "unrecognized node type: %d",
     (int) nodeTag(node));
   break;
 }
 /* can't get here, but keep compiler happy */
 return NULL;
}


/*
 * query_tree_mutator --- initiate modification of a Query's expressions
 *
 * This routine exists just to reduce the number of places that need to know
 * where all the expression subtrees of a Query are.  Note it can be used
 * for starting a walk at top level of a Query regardless of whether the
 * mutator intends to descend into subqueries.  It is also useful for
 * descending into subqueries within a mutator.
 *
 * Some callers want to suppress mutating of certain items in the Query,
 * typically because they need to process them specially, or don't actually
 * want to recurse into subqueries.  This is supported by the flags argument,
 * which is the bitwise OR of flag values to suppress mutating of
 * indicated items.  (More flag bits may be added as needed.)
 *
 * Normally the top-level Query node itself is copied, but some callers want
 * it to be modified in-place; they must pass QTW_DONT_COPY_QUERY in flags.
 * All modified substructure is safely copied in any case.
 */
Query *
query_tree_mutator_impl(Query *query,
      tree_mutator_callback mutator,
      void *context,
      int flags)
{
 Assert(query != NULL && IsA(query, Query));

 if (!(flags & QTW_DONT_COPY_QUERY))
 {
  Query    *newquery;

  FLATCOPY(newquery, query, Query);
  query = newquery;
 }

 MUTATE(query->targetList, query->targetList, List *);
 MUTATE(query->withCheckOptions, query->withCheckOptions, List *);
 MUTATE(query->onConflict, query->onConflict, OnConflictExpr *);
 MUTATE(query->mergeActionList, query->mergeActionList, List *);
 MUTATE(query->mergeJoinCondition, query->mergeJoinCondition, Node *);
 MUTATE(query->returningList, query->returningList, List *);
 MUTATE(query->jointree, query->jointree, FromExpr *);
 MUTATE(query->setOperations, query->setOperations, Node *);
 MUTATE(query->havingQual, query->havingQual, Node *);
 MUTATE(query->limitOffset, query->limitOffset, Node *);
 MUTATE(query->limitCount, query->limitCount, Node *);

 /*
  * Most callers aren't interested in SortGroupClause nodes since those
  * don't contain actual expressions. However they do contain OIDs, which
  * may be of interest to some mutators.
 */

 if ((flags & QTW_EXAMINE_SORTGROUP))
 {
  MUTATE(query->groupClause, query->groupClause, List *);
  MUTATE(query->windowClause, query->windowClause, List *);
  MUTATE(query->sortClause, query->sortClause, List *);
  MUTATE(query->distinctClause, query->distinctClause, List *);
 }
 else
 {
  /*
   * But we need to mutate the expressions under WindowClause nodes even
   * if we're not interested in SortGroupClause nodes.
 */
  List    *resultlist;
  ListCell   *temp;

  resultlist = NIL;
  foreach(temp, query->windowClause)
  {
   WindowClause *wc = lfirst_node(WindowClause, temp);
   WindowClause *newnode;

   FLATCOPY(newnode, wc, WindowClause);
   MUTATE(newnode->startOffset, wc->startOffset, Node *);
   MUTATE(newnode->endOffset, wc->endOffset, Node *);

   resultlist = lappend(resultlist, (Node *) newnode);
  }
  query->windowClause = resultlist;
 }

 /*
  * groupingSets and rowMarks are not mutated:
  *
  * groupingSets contain only ressortgroup refs (integers) which are
  * meaningless without the groupClause or tlist. Accordingly, any mutator
  * that needs to care about them needs to handle them itself in its Query
  * processing.
  *
  * rowMarks contains only rangetable indexes (and flags etc.) and
  * therefore should be handled at Query level similarly.
 */

 if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
  MUTATE(query->cteList, query->cteList, List *);
 else      /* else copy CTE list as-is */
  query->cteList = copyObject(query->cteList);
 query->rtable = range_table_mutator(query->rtable,
          mutator, context, flags);
 return query;
}

/*
 * range_table_mutator is just the part of query_tree_mutator that processes
 * a query's rangetable.  This is split out since it can be useful on
 * its own.
 */
List *
range_table_mutator_impl(List *rtable,
       tree_mutator_callback mutator,
       void *context,
       int flags)
{
 List    *newrt = NIL;
 ListCell   *rt;

 foreach(rt, rtable)
 {
  RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
  RangeTblEntry *newrte;

  FLATCOPY(newrte, rte, RangeTblEntry);
  switch (rte->rtekind)
  {
   case RTE_RELATION:
    MUTATE(newrte->tablesample, rte->tablesample,
        TableSampleClause *);
    /* we don't bother to copy eref, aliases, etc; OK? */
    break;
   case RTE_SUBQUERY:
    if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
     MUTATE(newrte->subquery, rte->subquery, Query *);
    else
    {
     /* else, copy RT subqueries as-is */
     newrte->subquery = copyObject(rte->subquery);
    }
    break;
   case RTE_JOIN:
    if (!(flags & QTW_IGNORE_JOINALIASES))
     MUTATE(newrte->joinaliasvars, rte->joinaliasvars, List *);
    else
    {
     /* else, copy join aliases as-is */
     newrte->joinaliasvars = copyObject(rte->joinaliasvars);
    }
    break;
   case RTE_FUNCTION:
    MUTATE(newrte->functions, rte->functions, List *);
    break;
   case RTE_TABLEFUNC:
    MUTATE(newrte->tablefunc, rte->tablefunc, TableFunc *);
    break;
   case RTE_VALUES:
    MUTATE(newrte->values_lists, rte->values_lists, List *);
    break;
   case RTE_CTE:
   case RTE_NAMEDTUPLESTORE:
   case RTE_RESULT:
    /* nothing to do */
    break;
   case RTE_GROUP:
    if (!(flags & QTW_IGNORE_GROUPEXPRS))
     MUTATE(newrte->groupexprs, rte->groupexprs, List *);
    else
    {
     /* else, copy grouping exprs as-is */
     newrte->groupexprs = copyObject(rte->groupexprs);
    }
    break;
  }
  MUTATE(newrte->securityQuals, rte->securityQuals, List *);
  newrt = lappend(newrt, newrte);
 }
 return newrt;
}

/*
 * query_or_expression_tree_walker --- hybrid form
 *
 * This routine will invoke query_tree_walker if called on a Query node,
 * else will invoke the walker directly.  This is a useful way of starting
 * the recursion when the walker's normal change of state is not appropriate
 * for the outermost Query node.
 */
bool
query_or_expression_tree_walker_impl(Node *node,
          tree_walker_callback walker,
          void *context,
          int flags)
{
 if (node && IsA(node, Query))
  return query_tree_walker((Query *) node,
         walker,
         context,
         flags);
 else
  return WALK(node);
}

/*
 * query_or_expression_tree_mutator --- hybrid form
 *
 * This routine will invoke query_tree_mutator if called on a Query node,
 * else will invoke the mutator directly.  This is a useful way of starting
 * the recursion when the mutator's normal change of state is not appropriate
 * for the outermost Query node.
 */
Node *
query_or_expression_tree_mutator_impl(Node *node,
           tree_mutator_callback mutator,
           void *context,
           int flags)
{
 if (node && IsA(node, Query))
  return (Node *) query_tree_mutator((Query *) node,
             mutator,
             context,
             flags);
 else
  return mutator(node, context);
}


/*
 * raw_expression_tree_walker --- walk raw parse trees
 *
 * This has exactly the same API as expression_tree_walker, but instead of
 * walking post-analysis parse trees, it knows how to walk the node types
 * found in raw grammar output.  (There is not currently any need for a
 * combined walker, so we keep them separate in the name of efficiency.)
 * Unlike expression_tree_walker, there is no special rule about query
 * boundaries: we descend to everything that's possibly interesting.
 *
 * Currently, the node type coverage here extends only to DML statements
 * (SELECT/INSERT/UPDATE/DELETE/MERGE) and nodes that can appear in them,
 * because this is used mainly during analysis of CTEs, and only DML
 * statements can appear in CTEs.
 */
bool
raw_expression_tree_walker_impl(Node *node,
        tree_walker_callback walker,
        void *context)
{
 ListCell   *temp;

 /*
  * The walker has already visited the current node, and so we need only
  * recurse into any sub-nodes it has.
 */
 if (node == NULL)
  return false;

 /* Guard against stack overflow due to overly complex expressions */
 check_stack_depth();

 switch (nodeTag(node))
 {
  case T_JsonFormat:
  case T_SetToDefault:
  case T_CurrentOfExpr:
  case T_SQLValueFunction:
  case T_Integer:
  case T_Float:
  case T_Boolean:
  case T_String:
  case T_BitString:
  case T_ParamRef:
  case T_A_Const:
  case T_A_Star:
  case T_MergeSupportFunc:
  case T_ReturningOption:
   /* primitive node types with no subnodes */
   break;
  case T_Alias:
   /* we assume the colnames list isn't interesting */
   break;
  case T_RangeVar:
   return WALK(((RangeVar *) node)->alias);
  case T_GroupingFunc:
   return WALK(((GroupingFunc *) node)->args);
  case T_SubLink:
   {
    SubLink    *sublink = (SubLink *) node;

    if (WALK(sublink->testexpr))
     return true;
    /* we assume the operName is not interesting */
    if (WALK(sublink->subselect))
     return true;
   }
   break;
  case T_CaseExpr:
   {
    CaseExpr   *caseexpr = (CaseExpr *) node;

    if (WALK(caseexpr->arg))
     return true;
    /* we assume walker doesn't care about CaseWhens, either */
    foreach(temp, caseexpr->args)
    {
     CaseWhen   *when = lfirst_node(CaseWhen, temp);

     if (WALK(when->expr))
      return true;
     if (WALK(when->result))
      return true;
    }
    if (WALK(caseexpr->defresult))
     return true;
   }
   break;
  case T_RowExpr:
   /* Assume colnames isn't interesting */
   return WALK(((RowExpr *) node)->args);
  case T_CoalesceExpr:
   return WALK(((CoalesceExpr *) node)->args);
  case T_MinMaxExpr:
   return WALK(((MinMaxExpr *) node)->args);
  case T_XmlExpr:
   {
    XmlExpr    *xexpr = (XmlExpr *) node;

    if (WALK(xexpr->named_args))
     return true;
    /* we assume walker doesn't care about arg_names */
    if (WALK(xexpr->args))
     return true;
   }
   break;
  case T_JsonReturning:
   return WALK(((JsonReturning *) node)->format);
  case T_JsonValueExpr:
   {
    JsonValueExpr *jve = (JsonValueExpr *) node;

    if (WALK(jve->raw_expr))
     return true;
    if (WALK(jve->formatted_expr))
     return true;
    if (WALK(jve->format))
     return true;
   }
   break;
  case T_JsonParseExpr:
   {
    JsonParseExpr *jpe = (JsonParseExpr *) node;

    if (WALK(jpe->expr))
     return true;
    if (WALK(jpe->output))
     return true;
   }
   break;
  case T_JsonScalarExpr:
   {
    JsonScalarExpr *jse = (JsonScalarExpr *) node;

    if (WALK(jse->expr))
     return true;
    if (WALK(jse->output))
     return true;
   }
   break;
  case T_JsonSerializeExpr:
   {
    JsonSerializeExpr *jse = (JsonSerializeExpr *) node;

    if (WALK(jse->expr))
     return true;
    if (WALK(jse->output))
     return true;
   }
   break;
  case T_JsonConstructorExpr:
   {
    JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;

    if (WALK(ctor->args))
     return true;
    if (WALK(ctor->func))
     return true;
    if (WALK(ctor->coercion))
     return true;
    if (WALK(ctor->returning))
     return true;
   }
   break;
  case T_JsonIsPredicate:
   return WALK(((JsonIsPredicate *) node)->expr);
  case T_JsonArgument:
   return WALK(((JsonArgument *) node)->val);
  case T_JsonFuncExpr:
   {
    JsonFuncExpr *jfe = (JsonFuncExpr *) node;

    if (WALK(jfe->context_item))
     return true;
    if (WALK(jfe->pathspec))
     return true;
    if (WALK(jfe->passing))
     return true;
    if (WALK(jfe->output))
     return true;
    if (WALK(jfe->on_empty))
     return true;
    if (WALK(jfe->on_error))
     return true;
   }
   break;
  case T_JsonBehavior:
   {
    JsonBehavior *jb = (JsonBehavior *) node;

    if (WALK(jb->expr))
     return true;
   }
   break;
  case T_JsonTable:
   {
    JsonTable  *jt = (JsonTable *) node;

    if (WALK(jt->context_item))
     return true;
    if (WALK(jt->pathspec))
     return true;
    if (WALK(jt->passing))
     return true;
    if (WALK(jt->columns))
     return true;
    if (WALK(jt->on_error))
     return true;
   }
   break;
  case T_JsonTableColumn:
   {
    JsonTableColumn *jtc = (JsonTableColumn *) node;

    if (WALK(jtc->typeName))
     return true;
    if (WALK(jtc->on_empty))
     return true;
    if (WALK(jtc->on_error))
     return true;
    if (WALK(jtc->columns))
     return true;
   }
   break;
  case T_JsonTablePathSpec:
   return WALK(((JsonTablePathSpec *) node)->string);
  case T_NullTest:
   return WALK(((NullTest *) node)->arg);
  case T_BooleanTest:
   return WALK(((BooleanTest *) node)->arg);
  case T_JoinExpr:
   {
    JoinExpr   *join = (JoinExpr *) node;

    if (WALK(join->larg))
     return true;
    if (WALK(join->rarg))
     return true;
    if (WALK(join->quals))
     return true;
    if (WALK(join->alias))
     return true;
    /* using list is deemed uninteresting */
   }
   break;
  case T_IntoClause:
   {
    IntoClause *into = (IntoClause *) node;

    if (WALK(into->rel))
     return true;
    /* colNames, options are deemed uninteresting */
    /* viewQuery should be null in raw parsetree, but check it */
    if (WALK(into->viewQuery))
     return true;
   }
   break;
  case T_List:
   foreach(temp, (List *) node)
   {
    if (WALK((Node *) lfirst(temp)))
     return true;
   }
   break;
  case T_InsertStmt:
   {
    InsertStmt *stmt = (InsertStmt *) node;

    if (WALK(stmt->relation))
     return true;
    if (WALK(stmt->cols))
     return true;
    if (WALK(stmt->selectStmt))
     return true;
    if (WALK(stmt->onConflictClause))
     return true;
    if (WALK(stmt->returningClause))
     return true;
    if (WALK(stmt->withClause))
     return true;
   }
   break;
  case T_DeleteStmt:
   {
    DeleteStmt *stmt = (DeleteStmt *) node;

    if (WALK(stmt->relation))
     return true;
    if (WALK(stmt->usingClause))
     return true;
    if (WALK(stmt->whereClause))
     return true;
    if (WALK(stmt->returningClause))
     return true;
    if (WALK(stmt->withClause))
     return true;
   }
   break;
  case T_UpdateStmt:
   {
    UpdateStmt *stmt = (UpdateStmt *) node;

    if (WALK(stmt->relation))
     return true;
    if (WALK(stmt->targetList))
     return true;
    if (WALK(stmt->whereClause))
     return true;
    if (WALK(stmt->fromClause))
     return true;
    if (WALK(stmt->returningClause))
     return true;
    if (WALK(stmt->withClause))
     return true;
   }
   break;
  case T_MergeStmt:
   {
    MergeStmt  *stmt = (MergeStmt *) node;

    if (WALK(stmt->relation))
     return true;
    if (WALK(stmt->sourceRelation))
     return true;
    if (WALK(stmt->joinCondition))
     return true;
    if (WALK(stmt->mergeWhenClauses))
     return true;
    if (WALK(stmt->returningClause))
     return true;
    if (WALK(stmt->withClause))
     return true;
   }
   break;
  case T_MergeWhenClause:
   {
    MergeWhenClause *mergeWhenClause = (MergeWhenClause *) node;

    if (WALK(mergeWhenClause->condition))
     return true;
    if (WALK(mergeWhenClause->targetList))
     return true;
    if (WALK(mergeWhenClause->values))
     return true;
   }
   break;
  case T_ReturningClause:
   {
    ReturningClause *returning = (ReturningClause *) node;

    if (WALK(returning->options))
     return true;
    if (WALK(returning->exprs))
     return true;
   }
   break;
  case T_SelectStmt:
   {
    SelectStmt *stmt = (SelectStmt *) node;

    if (WALK(stmt->distinctClause))
     return true;
    if (WALK(stmt->intoClause))
     return true;
    if (WALK(stmt->targetList))
     return true;
    if (WALK(stmt->fromClause))
     return true;
    if (WALK(stmt->whereClause))
     return true;
    if (WALK(stmt->groupClause))
     return true;
    if (WALK(stmt->havingClause))
     return true;
    if (WALK(stmt->windowClause))
     return true;
    if (WALK(stmt->valuesLists))
     return true;
    if (WALK(stmt->sortClause))
     return true;
    if (WALK(stmt->limitOffset))
     return true;
    if (WALK(stmt->limitCount))
     return true;
    if (WALK(stmt->lockingClause))
     return true;
    if (WALK(stmt->withClause))
     return true;
    if (WALK(stmt->larg))
     return true;
    if (WALK(stmt->rarg))
     return true;
   }
   break;
  case T_PLAssignStmt:
   {
    PLAssignStmt *stmt = (PLAssignStmt *) node;

    if (WALK(stmt->indirection))
     return true;
    if (WALK(stmt->val))
     return true;
   }
   break;
  case T_A_Expr:
   {
    A_Expr    *expr = (A_Expr *) node;

    if (WALK(expr->lexpr))
     return true;
    if (WALK(expr->rexpr))
     return true;
    /* operator name is deemed uninteresting */
   }
   break;
  case T_BoolExpr:
   {
    BoolExpr   *expr = (BoolExpr *) node;

    if (WALK(expr->args))
     return true;
   }
   break;
  case T_ColumnRef:
   /* we assume the fields contain nothing interesting */
   break;
  case T_FuncCall:
   {
    FuncCall   *fcall = (FuncCall *) node;

    if (WALK(fcall->args))
     return true;
    if (WALK(fcall->agg_order))
     return true;
    if (WALK(fcall->agg_filter))
     return true;
    if (WALK(fcall->over))
     return true;
    /* function name is deemed uninteresting */
   }
   break;
  case T_NamedArgExpr:
   return WALK(((NamedArgExpr *) node)->arg);
  case T_A_Indices:
   {
    A_Indices  *indices = (A_Indices *) node;

    if (WALK(indices->lidx))
     return true;
    if (WALK(indices->uidx))
     return true;
   }
   break;
  case T_A_Indirection:
   {
    A_Indirection *indir = (A_Indirection *) node;

    if (WALK(indir->arg))
     return true;
    if (WALK(indir->indirection))
     return true;
   }
   break;
  case T_A_ArrayExpr:
   return WALK(((A_ArrayExpr *) node)->elements);
  case T_ResTarget:
   {
    ResTarget  *rt = (ResTarget *) node;

    if (WALK(rt->indirection))
     return true;
    if (WALK(rt->val))
     return true;
   }
   break;
  case T_MultiAssignRef:
   return WALK(((MultiAssignRef *) node)->source);
  case T_TypeCast:
   {
    TypeCast   *tc = (TypeCast *) node;

    if (WALK(tc->arg))
     return true;
    if (WALK(tc->typeName))
     return true;
   }
   break;
  case T_CollateClause:
   return WALK(((CollateClause *) node)->arg);
  case T_SortBy:
   return WALK(((SortBy *) node)->node);
  case T_WindowDef:
   {
    WindowDef  *wd = (WindowDef *) node;

    if (WALK(wd->partitionClause))
     return true;
    if (WALK(wd->orderClause))
     return true;
    if (WALK(wd->startOffset))
     return true;
    if (WALK(wd->endOffset))
     return true;
   }
   break;
  case T_RangeSubselect:
   {
    RangeSubselect *rs = (RangeSubselect *) node;

    if (WALK(rs->subquery))
     return true;
    if (WALK(rs->alias))
     return true;
   }
   break;
  case T_RangeFunction:
   {
    RangeFunction *rf = (RangeFunction *) node;

    if (WALK(rf->functions))
     return true;
    if (WALK(rf->alias))
     return true;
    if (WALK(rf->coldeflist))
     return true;
   }
   break;
  case T_RangeTableSample:
   {
    RangeTableSample *rts = (RangeTableSample *) node;

    if (WALK(rts->relation))
     return true;
    /* method name is deemed uninteresting */
    if (WALK(rts->args))
     return true;
    if (WALK(rts->repeatable))
     return true;
   }
   break;
  case T_RangeTableFunc:
   {
    RangeTableFunc *rtf = (RangeTableFunc *) node;

    if (WALK(rtf->docexpr))
     return true;
    if (WALK(rtf->rowexpr))
     return true;
    if (WALK(rtf->namespaces))
     return true;
    if (WALK(rtf->columns))
     return true;
    if (WALK(rtf->alias))
     return true;
   }
   break;
  case T_RangeTableFuncCol:
   {
    RangeTableFuncCol *rtfc = (RangeTableFuncCol *) node;

    if (WALK(rtfc->colexpr))
     return true;
    if (WALK(rtfc->coldefexpr))
     return true;
   }
   break;
  case T_TypeName:
   {
    TypeName   *tn = (TypeName *) node;

    if (WALK(tn->typmods))
     return true;
    if (WALK(tn->arrayBounds))
     return true;
    /* type name itself is deemed uninteresting */
   }
   break;
  case T_ColumnDef:
   {
    ColumnDef  *coldef = (ColumnDef *) node;

    if (WALK(coldef->typeName))
     return true;
    if (WALK(coldef->raw_default))
     return true;
    if (WALK(coldef->collClause))
     return true;
    /* for now, constraints are ignored */
   }
   break;
  case T_IndexElem:
   {
    IndexElem  *indelem = (IndexElem *) node;

    if (WALK(indelem->expr))
     return true;
    /* collation and opclass names are deemed uninteresting */
   }
   break;
  case T_GroupingSet:
   return WALK(((GroupingSet *) node)->content);
  case T_LockingClause:
   return WALK(((LockingClause *) node)->lockedRels);
  case T_XmlSerialize:
   {
    XmlSerialize *xs = (XmlSerialize *) node;

    if (WALK(xs->expr))
     return true;
    if (WALK(xs->typeName))
     return true;
   }
   break;
  case T_WithClause:
   return WALK(((WithClause *) node)->ctes);
  case T_InferClause:
   {
    InferClause *stmt = (InferClause *) node;

    if (WALK(stmt->indexElems))
     return true;
    if (WALK(stmt->whereClause))
     return true;
   }
   break;
  case T_OnConflictClause:
   {
    OnConflictClause *stmt = (OnConflictClause *) node;

    if (WALK(stmt->infer))
     return true;
    if (WALK(stmt->targetList))
     return true;
    if (WALK(stmt->whereClause))
     return true;
   }
   break;
  case T_CommonTableExpr:
   /* search_clause and cycle_clause are not interesting here */
   return WALK(((CommonTableExpr *) node)->ctequery);
  case T_JsonOutput:
   {
    JsonOutput *out = (JsonOutput *) node;

    if (WALK(out->typeName))
     return true;
    if (WALK(out->returning))
     return true;
   }
   break;
  case T_JsonKeyValue:
   {
    JsonKeyValue *jkv = (JsonKeyValue *) node;

    if (WALK(jkv->key))
     return true;
    if (WALK(jkv->value))
     return true;
   }
   break;
  case T_JsonObjectConstructor:
   {
    JsonObjectConstructor *joc = (JsonObjectConstructor *) node;

    if (WALK(joc->output))
     return true;
    if (WALK(joc->exprs))
     return true;
   }
   break;
  case T_JsonArrayConstructor:
   {
    JsonArrayConstructor *jac = (JsonArrayConstructor *) node;

    if (WALK(jac->output))
     return true;
    if (WALK(jac->exprs))
     return true;
   }
   break;
  case T_JsonAggConstructor:
   {
    JsonAggConstructor *ctor = (JsonAggConstructor *) node;

    if (WALK(ctor->output))
     return true;
    if (WALK(ctor->agg_order))
     return true;
    if (WALK(ctor->agg_filter))
     return true;
    if (WALK(ctor->over))
     return true;
   }
   break;
  case T_JsonObjectAgg:
   {
    JsonObjectAgg *joa = (JsonObjectAgg *) node;

    if (WALK(joa->constructor))
     return true;
    if (WALK(joa->arg))
     return true;
   }
   break;
  case T_JsonArrayAgg:
   {
    JsonArrayAgg *jaa = (JsonArrayAgg *) node;

    if (WALK(jaa->constructor))
     return true;
    if (WALK(jaa->arg))
     return true;
   }
   break;
  case T_JsonArrayQueryConstructor:
   {
    JsonArrayQueryConstructor *jaqc = (JsonArrayQueryConstructor *) node;

    if (WALK(jaqc->output))
     return true;
    if (WALK(jaqc->query))
     return true;
   }
   break;
  default:
   elog(ERROR, "unrecognized node type: %d",
     (int) nodeTag(node));
   break;
 }
 return false;
}

/*
 * planstate_tree_walker --- walk plan state trees
 *
 * The walker has already visited the current node, and so we need only
 * recurse into any sub-nodes it has.
 */
bool
planstate_tree_walker_impl(PlanState *planstate,
         planstate_tree_walker_callback walker,
         void *context)
{
 Plan    *plan = planstate->plan;
 ListCell   *lc;

 /* We don't need implicit coercions to Node here */
#define PSWALK(n) walker(n, context)

 /* Guard against stack overflow due to overly complex plan trees */
 check_stack_depth();

 /* initPlan-s */
 if (planstate_walk_subplans(planstate->initPlan, walker, context))
  return true;

 /* lefttree */
 if (outerPlanState(planstate))
 {
  if (PSWALK(outerPlanState(planstate)))
   return true;
 }

 /* righttree */
 if (innerPlanState(planstate))
 {
  if (PSWALK(innerPlanState(planstate)))
   return true;
 }

 /* special child plans */
 switch (nodeTag(plan))
 {
  case T_Append:
   if (planstate_walk_members(((AppendState *) planstate)->appendplans,
            ((AppendState *) planstate)->as_nplans,
            walker, context))
    return true;
   break;
  case T_MergeAppend:
   if (planstate_walk_members(((MergeAppendState *) planstate)->mergeplans,
            ((MergeAppendState *) planstate)->ms_nplans,
            walker, context))
    return true;
   break;
  case T_BitmapAnd:
   if (planstate_walk_members(((BitmapAndState *) planstate)->bitmapplans,
            ((BitmapAndState *) planstate)->nplans,
            walker, context))
    return true;
   break;
  case T_BitmapOr:
   if (planstate_walk_members(((BitmapOrState *) planstate)->bitmapplans,
            ((BitmapOrState *) planstate)->nplans,
            walker, context))
    return true;
   break;
  case T_SubqueryScan:
   if (PSWALK(((SubqueryScanState *) planstate)->subplan))
    return true;
   break;
  case T_CustomScan:
   foreach(lc, ((CustomScanState *) planstate)->custom_ps)
   {
    if (PSWALK(lfirst(lc)))
     return true;
   }
   break;
  default:
   break;
 }

 /* subPlan-s */
 if (planstate_walk_subplans(planstate->subPlan, walker, context))
  return true;

 return false;
}

/*
 * Walk a list of SubPlans (or initPlans, which also use SubPlan nodes).
 */
static bool
planstate_walk_subplans(List *plans,
      planstate_tree_walker_callback walker,
      void *context)
{
 ListCell   *lc;

 foreach(lc, plans)
 {
  SubPlanState *sps = lfirst_node(SubPlanState, lc);

  if (PSWALK(sps->planstate))
   return true;
 }

 return false;
}

/*
 * Walk the constituent plans of a ModifyTable, Append, MergeAppend,
 * BitmapAnd, or BitmapOr node.
 */
static bool
planstate_walk_members(PlanState **planstates, int nplans,
        planstate_tree_walker_callback walker,
        void *context)
{
 int   j;

 for (j = 0; j < nplans; j++)
 {
  if (PSWALK(planstates[j]))
   return true;
 }

 return false;
}