/src/postgres/src/backend/nodes/nodeFuncs.c

Source
/*-------------------------------------------------------------------------
 *
 * nodeFuncs.c
 *    Various general-purpose manipulations of Node trees
 *
 * Portions Copyright (c) 1996-2026, 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;

        /*
         * Collation comes from coercion if present, otherwise from
         * func.  The func fallback is needed in cases where func
         * already produces the final output type and no coercion is
         * needed (cf. the JSCTOR_JSON_ARRAY_QUERY case).
         */
        if (ctor->coercion)
          coll = exprCollation((Node *) ctor->coercion);
        else if (ctor->func)
          coll = exprCollation((Node *) ctor->func);
        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 = (const JsonExpr *) expr;

        coll = jsexpr->collation;
      }
      break;
    case T_JsonBehavior:
      {
        const JsonBehavior *behavior = (const 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;

        /* See comment in exprCollation() */
        if (ctor->coercion)
          exprSetCollation((Node *) ctor->coercion, collation);
        else if (ctor->func)
          exprSetCollation((Node *) ctor->func, 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(((const 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_IndexElem:
      loc = ((const IndexElem *) 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.
 */

pg_attribute_no_sanitize_function()
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.)
 */
pg_attribute_no_sanitize_function()
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.
 */
pg_attribute_no_sanitize_function()
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.
 */

pg_attribute_no_sanitize_function()
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) = palloc_object(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.
 */
pg_attribute_no_sanitize_function()
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.
 */
pg_attribute_no_sanitize_function()
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.
 */
pg_attribute_no_sanitize_function()
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.
 */
pg_attribute_no_sanitize_function()
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.
 */
pg_attribute_no_sanitize_function()
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.
 */
pg_attribute_no_sanitize_function()
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).
 */
pg_attribute_no_sanitize_function()
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.
 */
pg_attribute_no_sanitize_function()
static bool
planstate_walk_members(PlanState **planstates, int nplans,
             planstate_tree_walker_callback walker,
             void *context)
{
  for (int j = 0; j < nplans; j++)
  {
    if (PSWALK(planstates[j]))
      return true;
  }

  return false;
}

Coverage Report

Created: 2026-11-09 07:20