nodeFuncs.c File Reference

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

Include dependency graph for nodeFuncs.c:

Go to the source code of this file.

Macros
#define	FLATCOPY(newnode, node, nodetype)
#define	CHECKFLATCOPY(newnode, node, nodetype)
#define	MUTATE(newfield, oldfield, fieldtype)    ( (newfield) = (fieldtype) mutator((Node *) (oldfield), context) )

Functions
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, bool(*walker)(), void *context)
static bool	planstate_walk_members (PlanState **planstates, int nplans, bool(*walker)(), void *context)
Oid	exprType (const Node *expr)
int32	exprTypmod (const Node *expr)
bool	exprIsLengthCoercion (const Node *expr, int32 *coercedTypmod)
Node *	applyRelabelType (Node *arg, Oid rtype, int32 rtypmod, Oid rcollid, CoercionForm rformat, int rlocation, bool overwrite_ok)
Node *	relabel_to_typmod (Node *expr, int32 typmod)
Node *	strip_implicit_coercions (Node *node)
bool	expression_returns_set (Node *clause)
Oid	exprCollation (const Node *expr)
Oid	exprInputCollation (const Node *expr)
void	exprSetCollation (Node *expr, Oid collation)
void	exprSetInputCollation (Node *expr, Oid inputcollation)
int	exprLocation (const Node *expr)
void	fix_opfuncids (Node *node)
void	set_opfuncid (OpExpr *opexpr)
void	set_sa_opfuncid (ScalarArrayOpExpr *opexpr)
bool	check_functions_in_node (Node *node, check_function_callback checker, void *context)
bool	expression_tree_walker (Node *node, bool(*walker)(), void *context)
bool	query_tree_walker (Query *query, bool(*walker)(), void *context, int flags)
bool	range_table_walker (List *rtable, bool(*walker)(), void *context, int flags)
bool	range_table_entry_walker (RangeTblEntry *rte, bool(*walker)(), void *context, int flags)
Node *	expression_tree_mutator (Node *node, Node *(*mutator)(), void *context)
Query *	query_tree_mutator (Query *query, Node *(*mutator)(), void *context, int flags)
List *	range_table_mutator (List *rtable, Node *(*mutator)(), void *context, int flags)
bool	query_or_expression_tree_walker (Node *node, bool(*walker)(), void *context, int flags)
Node *	query_or_expression_tree_mutator (Node *node, Node *(*mutator)(), void *context, int flags)
bool	raw_expression_tree_walker (Node *node, bool(*walker)(), void *context)
bool	planstate_tree_walker (PlanState *planstate, bool(*walker)(), void *context)

Macro Definition Documentation

CHECKFLATCOPY

#define CHECKFLATCOPY	(		newnode,
			node,
			nodetype
	)

Value:

    ( AssertMacro(IsA((node), nodetype)), \
      (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
      memcpy((newnode), (node), sizeof(nodetype)) )

FLATCOPY

#define FLATCOPY	(		newnode,
			node,
			nodetype
	)

Value:

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

MUTATE

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

Function Documentation

applyRelabelType()

Node* applyRelabelType	(	Node *	arg,
		Oid	rtype,
		int32	rtypmod,
		Oid	rcollid,
		CoercionForm	rformat,
		int	rlocation,
		bool	overwrite_ok
	)

Definition at line 582 of file nodeFuncs.c.

{
    /*
     * 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;
    }
}

References arg, RelabelType::arg, Const::constcollid, Const::consttype, Const::consttypmod, copyObject, exprCollation(), exprType(), exprTypmod(), IsA, RelabelType::location, makeNode, RelabelType::relabelformat, RelabelType::resultcollid, RelabelType::resulttype, and RelabelType::resulttypmod.

Referenced by canonicalize_ec_expression(), coerce_type_typmod(), eval_const_expressions_mutator(), generate_setop_tlist(), and relabel_to_typmod().

check_functions_in_node()

bool check_functions_in_node	(	Node *	node,
		check_function_callback	checker,
		void *	context
	)

Definition at line 1721 of file nodeFuncs.c.

{
    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;
}

References Aggref::aggfnoid, CoerceViaIO::arg, exprType(), FuncExpr::funcid, get_opcode(), getTypeInputInfo(), getTypeOutputInfo(), lfirst_oid, nodeTag, OpExpr::opfuncid, ScalarArrayOpExpr::opfuncid, RowCompareExpr::opnos, CoerceViaIO::resulttype, set_opfuncid(), set_sa_opfuncid(), T_Aggref, T_CoerceViaIO, T_DistinctExpr, T_FuncExpr, T_NullIfExpr, T_OpExpr, T_RowCompareExpr, T_ScalarArrayOpExpr, T_WindowFunc, and WindowFunc::winfnoid.

Referenced by contain_leaked_vars_walker(), contain_mutable_functions_walker(), contain_nonstrict_functions_walker(), contain_volatile_functions_not_nextval_walker(), contain_volatile_functions_walker(), and max_parallel_hazard_walker().

exprCollation()

Oid exprCollation

(

const Node *

expr

)

Definition at line 759 of file nodeFuncs.c.

{
    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_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_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_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;
}

References arg, ARRAY_SUBLINK, Assert(), elog, ERROR, EXPR_SUBLINK, SubPlan::firstColCollation, if(), InvalidOid, IS_XMLSERIALIZE, IsA, linitial, linitial_node, nodeTag, SubLink::subLinkType, SubPlan::subLinkType, AlternativeSubPlan::subplans, SubLink::subselect, T_Aggref, T_AlternativeSubPlan, T_ArrayCoerceExpr, T_ArrayExpr, T_BooleanTest, T_BoolExpr, T_CaseExpr, T_CaseTestExpr, T_CoalesceExpr, T_CoerceToDomain, T_CoerceToDomainValue, T_CoerceViaIO, T_CollateExpr, T_Const, T_ConvertRowtypeExpr, T_CurrentOfExpr, T_DistinctExpr, T_FieldSelect, T_FieldStore, T_FuncExpr, T_GroupingFunc, T_InferenceElem, T_MinMaxExpr, T_NamedArgExpr, T_NextValueExpr, T_NullIfExpr, T_NullTest, T_OpExpr, T_Param, T_PlaceHolderVar, T_RelabelType, T_RowCompareExpr, T_RowExpr, T_ScalarArrayOpExpr, T_SetToDefault, T_SQLValueFunction, T_SubLink, T_SubPlan, T_SubscriptingRef, T_Var, T_WindowFunc, T_XmlExpr, Query::targetList, and generate_unaccent_rules::type.

Referenced by addRangeTableEntryForFunction(), addRangeTableEntryForSubquery(), analyzeCTE(), analyzeCTETargetList(), applyRelabelType(), assign_collations_walker(), assign_hypothetical_collations(), build_expression_pathkey(), build_pertrans_for_aggref(), build_subplan(), canonicalize_ec_expression(), coerce_type_typmod(), ComputeIndexAttrs(), ComputePartitionAttrs(), convert_EXISTS_to_ANY(), create_ctas_nodata(), create_limit_plan(), create_memoize_plan(), create_unique_plan(), create_windowagg_plan(), DefineVirtualRelation(), eval_const_expressions_mutator(), examine_attribute(), examine_expression(), ExecInitFunctionScan(), ExecInitIndexScan(), ExecTypeFromExprList(), ExecTypeFromTLInternal(), expandRecordVariable(), expandRTE(), exprSetCollation(), extract_grouping_collations(), fix_indexqual_operand(), generate_setop_tlist(), generate_subquery_params(), get_expr_result_type(), get_first_col_type(), inline_function(), make_pathkey_from_sortop(), make_recursive_union(), make_setop(), make_sort_from_groupcols(), make_sort_from_sortclauses(), make_unique_from_sortclauses(), makeVarFromTargetEntry(), makeWholeRowVar(), mcv_match_expression(), ordered_set_startup(), pg_get_indexdef_worker(), pg_get_partkeydef_worker(), preprocess_minmax_aggregates(), relabel_to_typmod(), RelationBuildPartitionKey(), RelationGetDummyIndexExpressions(), remove_unused_subquery_outputs(), replace_nestloop_param_placeholdervar(), replace_outer_placeholdervar(), scalararraysel(), set_dummy_tlist_references(), set_joinrel_partition_key_exprs(), tlist_same_collations(), transformCaseExpr(), transformFromClauseItem(), transformMultiAssignRef(), transformPLAssignStmt(), transformSubLink(), and transformWindowDefinitions().

expression_returns_set()

bool expression_returns_set

(

Node *

clause

)

Definition at line 709 of file nodeFuncs.c.

{
    return expression_returns_set_walker(clause, NULL);
}

References expression_returns_set_walker().

Referenced by check_output_expressions(), coerce_to_boolean(), coerce_to_specific_type_typmod(), ExecInitProjectSet(), get_eclass_for_sort_expr(), is_simple_values(), make_row_comparison_op(), make_sort_input_target(), remove_unused_subquery_outputs(), and subquery_planner().

expression_returns_set_walker()

static bool expression_returns_set_walker ( Node *  node, void *  context  )

static

Definition at line 715 of file nodeFuncs.c.

{
    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 */
    }
 
    /* Avoid recursion for some cases that parser checks not to return a set */
    if (IsA(node, Aggref))
        return false;
    if (IsA(node, WindowFunc))
        return false;
 
    return expression_tree_walker(node, expression_returns_set_walker,
                                  context);
}

References expression_tree_walker(), FuncExpr::funcretset, IsA, and OpExpr::opretset.

Referenced by expression_returns_set().

expression_tree_mutator()

Node* expression_tree_mutator	(	Node *	node,
		Node *(*)()	mutator,
		void *	context
	)

Definition at line 2618 of file nodeFuncs.c.

{
    /*
     * The mutator has already decided not to modify the current node, but we
     * must call the mutator for any sub-nodes.
     */
 
#define FLATCOPY(newnode, node, nodetype)  \
    ( (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
      memcpy((newnode), (node), sizeof(nodetype)) )
 
#define CHECKFLATCOPY(newnode, node, nodetype)  \
    ( AssertMacro(IsA((node), nodetype)), \
      (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
      memcpy((newnode), (node), sizeof(nodetype)) )
 
#define MUTATE(newfield, oldfield, fieldtype)  \
        ( (newfield) = (fieldtype) mutator((Node *) (oldfield), context) )
 
    if (node == NULL)
        return NULL;
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    switch (nodeTag(node))
    {
            /*
             * Primitive node types with no expression subnodes.  Var and
             * Const are frequent enough to deserve special cases, the others
             * we just use copyObject for.
             */
        case T_Var:
            {
                Var        *var = (Var *) node;
                Var        *newnode;
 
                FLATCOPY(newnode, var, Var);
                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_CoerceToDomainValue:
        case T_SetToDefault:
        case T_CurrentOfExpr:
        case T_NextValueExpr:
        case T_RangeTblRef:
        case T_SortGroupClause:
        case T_CTESearchClause:
            return (Node *) 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_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_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_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_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 (Node *) 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 bitmapset */
                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 *);
                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;
}

References Aggref::aggargtypes, Aggref::aggdirectargs, Aggref::aggdistinct, Aggref::aggfilter, WindowFunc::aggfilter, Aggref::aggorder, OnConflictExpr::arbiterElems, OnConflictExpr::arbiterWhere, NamedArgExpr::arg, FieldSelect::arg, FieldStore::arg, RelabelType::arg, CoerceViaIO::arg, ArrayCoerceExpr::arg, ConvertRowtypeExpr::arg, CollateExpr::arg, CaseExpr::arg, NullTest::arg, BooleanTest::arg, CoerceToDomain::arg, TableSampleClause::args, Aggref::args, GroupingFunc::args, WindowFunc::args, FuncExpr::args, OpExpr::args, ScalarArrayOpExpr::args, BoolExpr::args, SubPlan::args, CaseExpr::args, RowExpr::args, CoalesceExpr::args, MinMaxExpr::args, XmlExpr::args, check_stack_depth(), TableFunc::coldefexprs, TableFunc::colexprs, GroupingFunc::cols, copyObject, CommonTableExpr::ctequery, CommonTableExpr::cycle_clause, CTECycleClause::cycle_mark_default, CTECycleClause::cycle_mark_value, CaseExpr::defresult, TableFunc::docexpr, ArrayExpr::elements, ArrayCoerceExpr::elemexpr, elog, WindowClause::endOffset, ERROR, OnConflictExpr::exclRelTlist, CaseWhen::expr, InferenceElem::expr, TargetEntry::expr, PartitionPruneStepOp::exprs, FieldStore::fieldnums, FLATCOPY, FromExpr::fromlist, RangeTblFunction::funcexpr, IndexClause::indexquals, lappend(), SetOperationStmt::larg, JoinExpr::larg, RowCompareExpr::largs, lfirst, list_copy(), PartitionBoundSpec::listdatums, PartitionBoundSpec::lowerdatums, MUTATE, XmlExpr::named_args, FieldStore::newvals, NIL, nodeTag, TableFunc::ns_uris, OnConflictExpr::onConflictSet, OnConflictExpr::onConflictWhere, WindowClause::orderClause, WindowClause::partitionClause, PlaceHolderInfo::ph_var, PlaceHolderVar::phexpr, WithCheckOption::qual, JoinExpr::quals, FromExpr::quals, SetOperationStmt::rarg, JoinExpr::rarg, RowCompareExpr::rargs, SubscriptingRef::refassgnexpr, SubscriptingRef::refexpr, SubscriptingRef::reflowerindexpr, GroupingFunc::refs, SubscriptingRef::refupperindexpr, TableSampleClause::repeatable, CaseWhen::result, IndexClause::rinfo, TableFunc::rowexpr, CommonTableExpr::search_clause, WindowClause::startOffset, AlternativeSubPlan::subplans, SubLink::subselect, T_Aggref, T_AlternativeSubPlan, T_AppendRelInfo, T_ArrayCoerceExpr, T_ArrayExpr, T_BooleanTest, T_BoolExpr, T_CaseExpr, T_CaseTestExpr, T_CaseWhen, T_CoalesceExpr, T_CoerceToDomain, T_CoerceToDomainValue, T_CoerceViaIO, T_CollateExpr, T_CommonTableExpr, T_Const, T_ConvertRowtypeExpr, T_CTECycleClause, T_CTESearchClause, T_CurrentOfExpr, T_DistinctExpr, T_FieldSelect, T_FieldStore, T_FromExpr, T_FuncExpr, T_GroupingFunc, T_IndexClause, T_InferenceElem, T_JoinExpr, T_List, T_MinMaxExpr, T_NamedArgExpr, T_NextValueExpr, T_NullIfExpr, T_NullTest, T_OnConflictExpr, T_OpExpr, T_Param, T_PartitionBoundSpec, T_PartitionPruneStepCombine, T_PartitionPruneStepOp, T_PartitionRangeDatum, T_PlaceHolderInfo, T_PlaceHolderVar, T_Query, T_RangeTblFunction, T_RangeTblRef, T_RelabelType, T_RowCompareExpr, T_RowExpr, T_ScalarArrayOpExpr, T_SetOperationStmt, T_SetToDefault, T_SortGroupClause, T_SQLValueFunction, T_SubLink, T_SubPlan, T_SubscriptingRef, T_TableFunc, T_TableSampleClause, T_TargetEntry, T_Var, T_WindowClause, T_WindowFunc, T_WithCheckOption, T_XmlExpr, SubLink::testexpr, SubPlan::testexpr, AppendRelInfo::translated_vars, PartitionBoundSpec::upperdatums, and PartitionRangeDatum::value.

Referenced by adjust_appendrel_attrs_mutator(), convert_combining_aggrefs(), convert_testexpr_mutator(), eval_const_expressions_mutator(), fix_join_expr_mutator(), fix_scan_expr_mutator(), fix_upper_expr_mutator(), flatten_join_alias_vars_mutator(), map_variable_attnos_mutator(), process_sublinks_mutator(), replace_correlation_vars_mutator(), replace_nestloop_params_mutator(), replace_rte_variables_mutator(), simplify_function(), substitute_actual_parameters_mutator(), and substitute_actual_srf_parameters_mutator().

expression_tree_walker()

bool expression_tree_walker	(	Node *	node,
		bool(*)()	walker,
		void *	context
	)

Definition at line 1904 of file nodeFuncs.c.

{
    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.
     */
    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:
            /* primitive node types with no expression subnodes */
            break;
        case T_WithCheckOption:
            return walker(((WithCheckOption *) node)->qual, context);
        case T_Aggref:
            {
                Aggref     *expr = (Aggref *) node;
 
                /* recurse directly on List */
                if (expression_tree_walker((Node *) expr->aggdirectargs,
                                           walker, context))
                    return true;
                if (expression_tree_walker((Node *) expr->args,
                                           walker, context))
                    return true;
                if (expression_tree_walker((Node *) expr->aggorder,
                                           walker, context))
                    return true;
                if (expression_tree_walker((Node *) expr->aggdistinct,
                                           walker, context))
                    return true;
                if (walker((Node *) expr->aggfilter, context))
                    return true;
            }
            break;
        case T_GroupingFunc:
            {
                GroupingFunc *grouping = (GroupingFunc *) node;
 
                if (expression_tree_walker((Node *) grouping->args,
                                           walker, context))
                    return true;
            }
            break;
        case T_WindowFunc:
            {
                WindowFunc *expr = (WindowFunc *) node;
 
                /* recurse directly on List */
                if (expression_tree_walker((Node *) expr->args,
                                           walker, context))
                    return true;
                if (walker((Node *) expr->aggfilter, context))
                    return true;
            }
            break;
        case T_SubscriptingRef:
            {
                SubscriptingRef *sbsref = (SubscriptingRef *) node;
 
                /* recurse directly for upper/lower container index lists */
                if (expression_tree_walker((Node *) sbsref->refupperindexpr,
                                           walker, context))
                    return true;
                if (expression_tree_walker((Node *) sbsref->reflowerindexpr,
                                           walker, context))
                    return true;
                /* walker must see the refexpr and refassgnexpr, however */
                if (walker(sbsref->refexpr, context))
                    return true;
 
                if (walker(sbsref->refassgnexpr, context))
                    return true;
            }
            break;
        case T_FuncExpr:
            {
                FuncExpr   *expr = (FuncExpr *) node;
 
                if (expression_tree_walker((Node *) expr->args,
                                           walker, context))
                    return true;
            }
            break;
        case T_NamedArgExpr:
            return walker(((NamedArgExpr *) node)->arg, context);
        case T_OpExpr:
        case T_DistinctExpr:    /* struct-equivalent to OpExpr */
        case T_NullIfExpr:      /* struct-equivalent to OpExpr */
            {
                OpExpr     *expr = (OpExpr *) node;
 
                if (expression_tree_walker((Node *) expr->args,
                                           walker, context))
                    return true;
            }
            break;
        case T_ScalarArrayOpExpr:
            {
                ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
 
                if (expression_tree_walker((Node *) expr->args,
                                           walker, context))
                    return true;
            }
            break;
        case T_BoolExpr:
            {
                BoolExpr   *expr = (BoolExpr *) node;
 
                if (expression_tree_walker((Node *) expr->args,
                                           walker, context))
                    return true;
            }
            break;
        case T_SubLink:
            {
                SubLink    *sublink = (SubLink *) node;
 
                if (walker(sublink->testexpr, context))
                    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 walker(sublink->subselect, context);
            }
            break;
        case T_SubPlan:
            {
                SubPlan    *subplan = (SubPlan *) node;
 
                /* recurse into the testexpr, but not into the Plan */
                if (walker(subplan->testexpr, context))
                    return true;
                /* also examine args list */
                if (expression_tree_walker((Node *) subplan->args,
                                           walker, context))
                    return true;
            }
            break;
        case T_AlternativeSubPlan:
            return walker(((AlternativeSubPlan *) node)->subplans, context);
        case T_FieldSelect:
            return walker(((FieldSelect *) node)->arg, context);
        case T_FieldStore:
            {
                FieldStore *fstore = (FieldStore *) node;
 
                if (walker(fstore->arg, context))
                    return true;
                if (walker(fstore->newvals, context))
                    return true;
            }
            break;
        case T_RelabelType:
            return walker(((RelabelType *) node)->arg, context);
        case T_CoerceViaIO:
            return walker(((CoerceViaIO *) node)->arg, context);
        case T_ArrayCoerceExpr:
            {
                ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
 
                if (walker(acoerce->arg, context))
                    return true;
                if (walker(acoerce->elemexpr, context))
                    return true;
            }
            break;
        case T_ConvertRowtypeExpr:
            return walker(((ConvertRowtypeExpr *) node)->arg, context);
        case T_CollateExpr:
            return walker(((CollateExpr *) node)->arg, context);
        case T_CaseExpr:
            {
                CaseExpr   *caseexpr = (CaseExpr *) node;
 
                if (walker(caseexpr->arg, context))
                    return true;
                /* we assume walker doesn't care about CaseWhens, either */
                foreach(temp, caseexpr->args)
                {
                    CaseWhen   *when = lfirst_node(CaseWhen, temp);
 
                    if (walker(when->expr, context))
                        return true;
                    if (walker(when->result, context))
                        return true;
                }
                if (walker(caseexpr->defresult, context))
                    return true;
            }
            break;
        case T_ArrayExpr:
            return walker(((ArrayExpr *) node)->elements, context);
        case T_RowExpr:
            /* Assume colnames isn't interesting */
            return walker(((RowExpr *) node)->args, context);
        case T_RowCompareExpr:
            {
                RowCompareExpr *rcexpr = (RowCompareExpr *) node;
 
                if (walker(rcexpr->largs, context))
                    return true;
                if (walker(rcexpr->rargs, context))
                    return true;
            }
            break;
        case T_CoalesceExpr:
            return walker(((CoalesceExpr *) node)->args, context);
        case T_MinMaxExpr:
            return walker(((MinMaxExpr *) node)->args, context);
        case T_XmlExpr:
            {
                XmlExpr    *xexpr = (XmlExpr *) node;
 
                if (walker(xexpr->named_args, context))
                    return true;
                /* we assume walker doesn't care about arg_names */
                if (walker(xexpr->args, context))
                    return true;
            }
            break;
        case T_NullTest:
            return walker(((NullTest *) node)->arg, context);
        case T_BooleanTest:
            return walker(((BooleanTest *) node)->arg, context);
        case T_CoerceToDomain:
            return walker(((CoerceToDomain *) node)->arg, context);
        case T_TargetEntry:
            return walker(((TargetEntry *) node)->expr, context);
        case T_Query:
            /* Do nothing with a sub-Query, per discussion above */
            break;
        case T_WindowClause:
            {
                WindowClause *wc = (WindowClause *) node;
 
                if (walker(wc->partitionClause, context))
                    return true;
                if (walker(wc->orderClause, context))
                    return true;
                if (walker(wc->startOffset, context))
                    return true;
                if (walker(wc->endOffset, context))
                    return true;
            }
            break;
        case T_CTECycleClause:
            {
                CTECycleClause *cc = (CTECycleClause *) node;
 
                if (walker(cc->cycle_mark_value, context))
                    return true;
                if (walker(cc->cycle_mark_default, context))
                    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 (walker(cte->ctequery, context))
                    return true;
 
                if (walker(cte->search_clause, context))
                    return true;
                if (walker(cte->cycle_clause, context))
                    return true;
            }
            break;
        case T_PartitionBoundSpec:
            {
                PartitionBoundSpec *pbs = (PartitionBoundSpec *) node;
 
                if (walker(pbs->listdatums, context))
                    return true;
                if (walker(pbs->lowerdatums, context))
                    return true;
                if (walker(pbs->upperdatums, context))
                    return true;
            }
            break;
        case T_PartitionRangeDatum:
            {
                PartitionRangeDatum *prd = (PartitionRangeDatum *) node;
 
                if (walker(prd->value, context))
                    return true;
            }
            break;
        case T_List:
            foreach(temp, (List *) node)
            {
                if (walker((Node *) lfirst(temp), context))
                    return true;
            }
            break;
        case T_FromExpr:
            {
                FromExpr   *from = (FromExpr *) node;
 
                if (walker(from->fromlist, context))
                    return true;
                if (walker(from->quals, context))
                    return true;
            }
            break;
        case T_OnConflictExpr:
            {
                OnConflictExpr *onconflict = (OnConflictExpr *) node;
 
                if (walker((Node *) onconflict->arbiterElems, context))
                    return true;
                if (walker(onconflict->arbiterWhere, context))
                    return true;
                if (walker(onconflict->onConflictSet, context))
                    return true;
                if (walker(onconflict->onConflictWhere, context))
                    return true;
                if (walker(onconflict->exclRelTlist, context))
                    return true;
            }
            break;
        case T_PartitionPruneStepOp:
            {
                PartitionPruneStepOp *opstep = (PartitionPruneStepOp *) node;
 
                if (walker((Node *) opstep->exprs, context))
                    return true;
            }
            break;
        case T_PartitionPruneStepCombine:
            /* no expression subnodes */
            break;
        case T_JoinExpr:
            {
                JoinExpr   *join = (JoinExpr *) node;
 
                if (walker(join->larg, context))
                    return true;
                if (walker(join->rarg, context))
                    return true;
                if (walker(join->quals, context))
                    return true;
 
                /*
                 * alias clause, using list are deemed uninteresting.
                 */
            }
            break;
        case T_SetOperationStmt:
            {
                SetOperationStmt *setop = (SetOperationStmt *) node;
 
                if (walker(setop->larg, context))
                    return true;
                if (walker(setop->rarg, context))
                    return true;
 
                /* groupClauses are deemed uninteresting */
            }
            break;
        case T_IndexClause:
            {
                IndexClause *iclause = (IndexClause *) node;
 
                if (walker(iclause->rinfo, context))
                    return true;
                if (expression_tree_walker((Node *) iclause->indexquals,
                                           walker, context))
                    return true;
            }
            break;
        case T_PlaceHolderVar:
            return walker(((PlaceHolderVar *) node)->phexpr, context);
        case T_InferenceElem:
            return walker(((InferenceElem *) node)->expr, context);
        case T_AppendRelInfo:
            {
                AppendRelInfo *appinfo = (AppendRelInfo *) node;
 
                if (expression_tree_walker((Node *) appinfo->translated_vars,
                                           walker, context))
                    return true;
            }
            break;
        case T_PlaceHolderInfo:
            return walker(((PlaceHolderInfo *) node)->ph_var, context);
        case T_RangeTblFunction:
            return walker(((RangeTblFunction *) node)->funcexpr, context);
        case T_TableSampleClause:
            {
                TableSampleClause *tsc = (TableSampleClause *) node;
 
                if (expression_tree_walker((Node *) tsc->args,
                                           walker, context))
                    return true;
                if (walker((Node *) tsc->repeatable, context))
                    return true;
            }
            break;
        case T_TableFunc:
            {
                TableFunc  *tf = (TableFunc *) node;
 
                if (walker(tf->ns_uris, context))
                    return true;
                if (walker(tf->docexpr, context))
                    return true;
                if (walker(tf->rowexpr, context))
                    return true;
                if (walker(tf->colexprs, context))
                    return true;
                if (walker(tf->coldefexprs, context))
                    return true;
            }
            break;
        default:
            elog(ERROR, "unrecognized node type: %d",
                 (int) nodeTag(node));
            break;
    }
    return false;
}

References Aggref::aggdirectargs, Aggref::aggdistinct, Aggref::aggfilter, WindowFunc::aggfilter, Aggref::aggorder, OnConflictExpr::arbiterElems, OnConflictExpr::arbiterWhere, arg, FieldStore::arg, ArrayCoerceExpr::arg, CaseExpr::arg, generate_unaccent_rules::args, TableSampleClause::args, Aggref::args, GroupingFunc::args, WindowFunc::args, FuncExpr::args, OpExpr::args, ScalarArrayOpExpr::args, BoolExpr::args, SubPlan::args, CaseExpr::args, XmlExpr::args, check_stack_depth(), TableFunc::coldefexprs, TableFunc::colexprs, CommonTableExpr::ctequery, CommonTableExpr::cycle_clause, CTECycleClause::cycle_mark_default, CTECycleClause::cycle_mark_value, CaseExpr::defresult, TableFunc::docexpr, ArrayCoerceExpr::elemexpr, elog, WindowClause::endOffset, ERROR, OnConflictExpr::exclRelTlist, PartitionPruneStepOp::exprs, FromExpr::fromlist, IndexClause::indexquals, SetOperationStmt::larg, JoinExpr::larg, RowCompareExpr::largs, lfirst, lfirst_node, PartitionBoundSpec::listdatums, PartitionBoundSpec::lowerdatums, XmlExpr::named_args, FieldStore::newvals, nodeTag, TableFunc::ns_uris, OnConflictExpr::onConflictSet, OnConflictExpr::onConflictWhere, WindowClause::orderClause, WindowClause::partitionClause, JoinExpr::quals, FromExpr::quals, SetOperationStmt::rarg, JoinExpr::rarg, RowCompareExpr::rargs, SubscriptingRef::refassgnexpr, SubscriptingRef::refexpr, SubscriptingRef::reflowerindexpr, SubscriptingRef::refupperindexpr, TableSampleClause::repeatable, IndexClause::rinfo, TableFunc::rowexpr, CommonTableExpr::search_clause, WindowClause::startOffset, SubLink::subselect, T_Aggref, T_AlternativeSubPlan, T_AppendRelInfo, T_ArrayCoerceExpr, T_ArrayExpr, T_BooleanTest, T_BoolExpr, T_CaseExpr, T_CaseTestExpr, T_CoalesceExpr, T_CoerceToDomain, T_CoerceToDomainValue, T_CoerceViaIO, T_CollateExpr, T_CommonTableExpr, T_Const, T_ConvertRowtypeExpr, T_CTECycleClause, T_CTESearchClause, T_CurrentOfExpr, T_DistinctExpr, T_FieldSelect, T_FieldStore, T_FromExpr, T_FuncExpr, T_GroupingFunc, T_IndexClause, T_InferenceElem, T_JoinExpr, T_List, T_MinMaxExpr, T_NamedArgExpr, T_NextValueExpr, T_NullIfExpr, T_NullTest, T_OnConflictExpr, T_OpExpr, T_Param, T_PartitionBoundSpec, T_PartitionPruneStepCombine, T_PartitionPruneStepOp, T_PartitionRangeDatum, T_PlaceHolderInfo, T_PlaceHolderVar, T_Query, T_RangeTblFunction, T_RangeTblRef, T_RelabelType, T_RowCompareExpr, T_RowExpr, T_ScalarArrayOpExpr, T_SetOperationStmt, T_SetToDefault, T_SortGroupClause, T_SQLValueFunction, T_SubLink, T_SubPlan, T_SubscriptingRef, T_TableFunc, T_TableSampleClause, T_TargetEntry, T_Var, T_WindowClause, T_WindowFunc, T_WithCheckOption, T_XmlExpr, SubLink::testexpr, SubPlan::testexpr, AppendRelInfo::translated_vars, PartitionBoundSpec::upperdatums, and PartitionRangeDatum::value.

Referenced by acquireLocksOnSubLinks(), assign_collations_walker(), ChangeVarNodes_walker(), check_agg_arguments_walker(), check_nested_generated_walker(), check_parameter_resolution_walker(), check_ungrouped_columns_walker(), checkExprHasSubLink_walker(), contain_agg_clause_walker(), contain_aggs_of_level_walker(), contain_context_dependent_node_walker(), contain_dml_walker(), contain_exec_param_walker(), contain_leaked_vars_walker(), contain_mutable_functions_walker(), contain_non_const_walker(), contain_nonstrict_functions_walker(), contain_outer_selfref_walker(), contain_subplans_walker(), contain_var_clause_walker(), contain_vars_of_level_walker(), contain_volatile_functions_not_nextval_walker(), contain_volatile_functions_walker(), contain_windowfuncs_walker(), contains_multiexpr_param(), convert_saop_to_hashed_saop_walker(), cost_qual_eval_walker(), expression_returns_set_walker(), extract_query_dependencies_walker(), finalize_agg_primnode(), finalize_grouping_exprs_walker(), finalize_primnode(), find_cols_walker(), find_dependent_phvs_walker(), find_expr_references_walker(), find_window_functions_walker(), fireRIRonSubLink(), fireRIRrules(), fix_opfuncids_walker(), fix_scan_expr_walker(), flatten_rtes_walker(), get_last_attnums_walker(), IncrementVarSublevelsUp_walker(), index_expression_changed_walker(), inline_cte_walker(), isQueryUsingTempRelation_walker(), locate_agg_of_level_walker(), locate_var_of_level_walker(), locate_windowfunc_walker(), LockViewRecurse_walker(), max_parallel_hazard_walker(), OffsetVarNodes_walker(), preprocess_aggrefs_walker(), pull_exec_paramids_walker(), pull_paramids_walker(), pull_var_clause_walker(), pull_varattnos_walker(), pull_varnos_walker(), pull_vars_walker(), query_contains_extern_params_walker(), rangeTableEntry_used_walker(), ScanQueryWalker(), setRuleCheckAsUser_walker(), split_pathtarget_walker(), and substitute_phv_relids_walker().

exprInputCollation()

Oid exprInputCollation

(

const Node *

expr

)

Definition at line 974 of file nodeFuncs.c.

{
    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;
}

References InvalidOid, nodeTag, T_Aggref, T_DistinctExpr, T_FuncExpr, T_MinMaxExpr, T_NullIfExpr, T_OpExpr, T_ScalarArrayOpExpr, and T_WindowFunc.

Referenced by resolve_polymorphic_tupdesc().

exprIsLengthCoercion()

bool exprIsLengthCoercion	(	const Node *	expr,
		int32 *	coercedTypmod
	)

Definition at line 503 of file nodeFuncs.c.

{
    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;
}

References FuncExpr::args, COERCE_EXPLICIT_CAST, COERCE_IMPLICIT_CAST, Const::constisnull, Const::consttype, Const::constvalue, DatumGetInt32, FuncExpr::funcformat, IsA, list_length(), lsecond, and ArrayCoerceExpr::resulttypmod.

Referenced by deparseFuncExpr(), exprTypmod(), and get_func_expr().

exprLocation()

int exprLocation

(

const Node *

expr

)

Definition at line 1250 of file nodeFuncs.c.

{
    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_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_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_TargetEntry:
            /* just use argument's location */
            loc = exprLocation((Node *) ((const TargetEntry *) expr)->expr);
            break;
        case T_IntoClause:
            /* use the contained RangeVar's location --- close enough */
            loc = exprLocation((Node *) ((const IntoClause *) expr)->rel);
            break;
        case T_List:
            {
                /* report location of first list member that has a location */
                ListCell   *lc;
 
                loc = -1;       /* just to suppress compiler warning */
                foreach(lc, (const List *) expr)
                {
                    loc = exprLocation((Node *) lfirst(lc));
                    if (loc >= 0)
                        break;
                }
            }
            break;
        case T_A_Expr:
            {
                const A_Expr *aexpr = (const A_Expr *) expr;
 
                /* use leftmost of operator or left operand (if any) */
                /* we assume right operand can't be to left of operator */
                loc = leftmostLoc(aexpr->location,
                                  exprLocation(aexpr->lexpr));
            }
            break;
        case T_ColumnRef:
            loc = ((const ColumnRef *) expr)->location;
            break;
        case T_ParamRef:
            loc = ((const ParamRef *) expr)->location;
            break;
        case T_A_Const:
            loc = ((const A_Const *) expr)->location;
            break;
        case T_FuncCall:
            {
                const FuncCall *fc = (const FuncCall *) expr;
 
                /* consider both function name and leftmost arg */
                /* (we assume any ORDER BY nodes must be to right of name) */
                loc = leftmostLoc(fc->location,
                                  exprLocation((Node *) fc->args));
            }
            break;
        case T_A_ArrayExpr:
            /* the location points at ARRAY or [, which must be leftmost */
            loc = ((const A_ArrayExpr *) expr)->location;
            break;
        case T_ResTarget:
            /* we need not examine the contained expression (if any) */
            loc = ((const ResTarget *) expr)->location;
            break;
        case T_MultiAssignRef:
            loc = exprLocation(((const MultiAssignRef *) expr)->source);
            break;
        case T_TypeCast:
            {
                const TypeCast *tc = (const TypeCast *) expr;
 
                /*
                 * This could represent CAST(), ::, or TypeName 'literal', so
                 * any of the components might be leftmost.
                 */
                loc = exprLocation(tc->arg);
                loc = leftmostLoc(loc, tc->typeName->location);
                loc = leftmostLoc(loc, tc->location);
            }
            break;
        case T_CollateClause:
            /* just use argument's location */
            loc = exprLocation(((const CollateClause *) expr)->arg);
            break;
        case T_SortBy:
            /* just use argument's location (ignore operator, if any) */
            loc = exprLocation(((const SortBy *) expr)->node);
            break;
        case T_WindowDef:
            loc = ((const WindowDef *) expr)->location;
            break;
        case T_RangeTableSample:
            loc = ((const RangeTableSample *) expr)->location;
            break;
        case T_TypeName:
            loc = ((const TypeName *) expr)->location;
            break;
        case T_ColumnDef:
            loc = ((const ColumnDef *) expr)->location;
            break;
        case T_Constraint:
            loc = ((const Constraint *) expr)->location;
            break;
        case T_FunctionParameter:
            /* just use typename's location */
            loc = exprLocation((Node *) ((const FunctionParameter *) expr)->argType);
            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_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;
}

References arg, TypeCast::arg, NamedArgExpr::arg, RelabelType::arg, CoerceViaIO::arg, ArrayCoerceExpr::arg, ConvertRowtypeExpr::arg, NullTest::arg, BooleanTest::arg, CoerceToDomain::arg, FuncExpr::args, OpExpr::args, ScalarArrayOpExpr::args, BoolExpr::args, XmlExpr::args, fc(), leftmostLoc(), A_Expr::lexpr, lfirst, TypeName::location, A_Expr::location, TypeCast::location, FuncExpr::location, NamedArgExpr::location, OpExpr::location, ScalarArrayOpExpr::location, BoolExpr::location, SubLink::location, RelabelType::location, CoerceViaIO::location, ArrayCoerceExpr::location, ConvertRowtypeExpr::location, XmlExpr::location, NullTest::location, BooleanTest::location, CoerceToDomain::location, nodeTag, source, T_A_ArrayExpr, T_A_Const, T_A_Expr, T_Aggref, T_ArrayCoerceExpr, T_ArrayExpr, T_BooleanTest, T_BoolExpr, T_CaseExpr, T_CaseWhen, T_CoalesceExpr, T_CoerceToDomain, T_CoerceToDomainValue, T_CoerceViaIO, T_CollateClause, T_CollateExpr, T_ColumnDef, T_ColumnRef, T_CommonTableExpr, T_Const, T_Constraint, T_ConvertRowtypeExpr, T_CTECycleClause, T_CTESearchClause, T_DistinctExpr, T_FieldSelect, T_FieldStore, T_FuncCall, T_FuncExpr, T_FunctionParameter, T_GroupingFunc, T_GroupingSet, T_InferClause, T_InferenceElem, T_IntoClause, T_List, T_MinMaxExpr, T_MultiAssignRef, T_NamedArgExpr, T_NullIfExpr, T_NullTest, T_OnConflictClause, T_OpExpr, T_Param, T_ParamRef, T_PartitionBoundSpec, T_PartitionElem, T_PartitionRangeDatum, T_PartitionSpec, T_PlaceHolderVar, T_RangeTableSample, T_RangeVar, T_RelabelType, T_ResTarget, T_RowCompareExpr, T_RowExpr, T_ScalarArrayOpExpr, T_SetToDefault, T_SortBy, T_SQLValueFunction, T_SubLink, T_SubscriptingRef, T_TableFunc, T_TargetEntry, T_TypeCast, T_TypeName, T_Var, T_WindowDef, T_WindowFunc, T_WithClause, T_XmlExpr, T_XmlSerialize, SubLink::testexpr, and TypeCast::typeName.

Referenced by addRangeTableEntryForFunction(), addTargetToSortList(), analyzeCTE(), array_subscript_transform(), assign_collations_walker(), check_agg_arguments_walker(), check_srf_call_placement(), checkWellFormedRecursion(), coerce_to_boolean(), coerce_to_common_type(), coerce_to_specific_type_typmod(), EvaluateParams(), ExecInitFunc(), ExecInitSubscriptingRef(), finalize_grouping_exprs_walker(), get_matching_location(), hstore_subscript_transform(), init_sexpr(), jsonb_subscript_transform(), parseCheckAggregates(), ParseFuncOrColumn(), parser_coercion_errposition(), resolve_unique_index_expr(), select_common_type(), transformAggregateCall(), transformArrayExpr(), transformAssignedExpr(), transformCaseExpr(), transformCoalesceExpr(), transformContainerSubscripts(), transformDistinctClause(), transformDistinctOnClause(), transformFrameOffset(), transformFromClauseItem(), transformGroupClause(), transformGroupClauseExpr(), transformGroupingSet(), transformIndirection(), transformInsertRow(), transformInsertStmt(), transformMultiAssignRef(), transformOnConflictArbiter(), transformPartitionBound(), transformPartitionBoundValue(), transformPartitionRangeBounds(), transformPLAssignStmt(), transformRangeFunction(), transformReturningList(), transformSelectStmt(), transformSetOperationStmt(), transformSetOperationTree(), transformValuesClause(), and validateInfiniteBounds().

exprSetCollation()

void exprSetCollation	(	Node *	expr,
		Oid	collation
	)

Definition at line 1022 of file nodeFuncs.c.

{
    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_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_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;
    }
}

References arg, ARRAY_SUBLINK, Assert(), elog, ERROR, EXPR_SUBLINK, exprCollation(), if(), InvalidOid, IS_XMLSERIALIZE, IsA, linitial_node, nodeTag, OidIsValid, SubLink::subLinkType, SubLink::subselect, T_Aggref, T_ArrayCoerceExpr, T_ArrayExpr, T_BooleanTest, T_BoolExpr, T_CaseExpr, T_CoalesceExpr, T_CoerceToDomain, T_CoerceToDomainValue, T_CoerceViaIO, T_Const, T_ConvertRowtypeExpr, T_CurrentOfExpr, T_DistinctExpr, T_FieldSelect, T_FieldStore, T_FuncExpr, T_GroupingFunc, T_MinMaxExpr, T_NamedArgExpr, T_NextValueExpr, T_NullIfExpr, T_NullTest, T_OpExpr, T_Param, T_RelabelType, T_RowCompareExpr, T_RowExpr, T_ScalarArrayOpExpr, T_SetToDefault, T_SQLValueFunction, T_SubLink, T_SubscriptingRef, T_Var, T_WindowFunc, T_XmlExpr, Query::targetList, and generate_unaccent_rules::type.

Referenced by assign_collations_walker().

exprSetInputCollation()

void exprSetInputCollation	(	Node *	expr,
		Oid	inputcollation
	)

Definition at line 1186 of file nodeFuncs.c.

{
    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;
    }
}

References nodeTag, T_Aggref, T_DistinctExpr, T_FuncExpr, T_MinMaxExpr, T_NullIfExpr, T_OpExpr, T_ScalarArrayOpExpr, and T_WindowFunc.

Referenced by assign_collations_walker().

exprType()

Oid exprType

(

const Node *

expr

)

Definition at line 41 of file nodeFuncs.c.

{
    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_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_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_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;
}

References arg, ARRAY_SUBLINK, Assert(), elog, ereport, errcode(), errmsg(), ERROR, InferenceElem::expr, EXPR_SUBLINK, SubPlan::firstColType, format_type_be(), get_promoted_array_type(), if(), InvalidOid, IS_DOCUMENT, IS_XMLSERIALIZE, IsA, linitial, linitial_node, MULTIEXPR_SUBLINK, nodeTag, OidIsValid, SubLink::subLinkType, SubPlan::subLinkType, AlternativeSubPlan::subplans, SubLink::subselect, T_Aggref, T_AlternativeSubPlan, T_ArrayCoerceExpr, T_ArrayExpr, T_BooleanTest, T_BoolExpr, T_CaseExpr, T_CaseTestExpr, T_CoalesceExpr, T_CoerceToDomain, T_CoerceToDomainValue, T_CoerceViaIO, T_CollateExpr, T_Const, T_ConvertRowtypeExpr, T_CurrentOfExpr, T_DistinctExpr, T_FieldSelect, T_FieldStore, T_FuncExpr, T_GroupingFunc, T_InferenceElem, T_MinMaxExpr, T_NamedArgExpr, T_NextValueExpr, T_NullIfExpr, T_NullTest, T_OpExpr, T_Param, T_PlaceHolderVar, T_RelabelType, T_RowCompareExpr, T_RowExpr, T_ScalarArrayOpExpr, T_SetToDefault, T_SQLValueFunction, T_SubLink, T_SubPlan, T_SubscriptingRef, T_Var, T_WindowFunc, T_XmlExpr, Query::targetList, and generate_unaccent_rules::type.

Referenced by add_row_identity_var(), addRangeTableEntryForFunction(), addRangeTableEntryForSubquery(), addTargetToGroupList(), addTargetToSortList(), analyzeCTE(), analyzeCTETargetList(), appendAggOrderBy(), applyRelabelType(), array_subscript_transform(), assign_collations_walker(), assign_hypothetical_collations(), assign_param_for_placeholdervar(), ATExecAlterColumnType(), ATPrepAlterColumnType(), build_coercion_expression(), build_column_default(), build_subplan(), can_minmax_aggs(), canonicalize_ec_expression(), check_functions_in_node(), check_hashjoinable(), check_memoizable(), check_mergejoinable(), check_sql_fn_retval(), checkRuleResultList(), coerce_fn_result_column(), coerce_record_to_complex(), coerce_to_boolean(), coerce_to_common_type(), coerce_to_specific_type_typmod(), compare_tlist_datatypes(), compute_semijoin_info(), ComputeIndexAttrs(), ComputePartitionAttrs(), ConstructTupleDescriptor(), convert_EXISTS_to_ANY(), cookDefault(), cost_qual_eval_walker(), create_ctas_nodata(), create_indexscan_plan(), CreateStatistics(), DefineVirtualRelation(), deparseNullTest(), deparseOpExpr(), estimate_num_groups(), eval_const_expressions_mutator(), EvaluateParams(), examine_attribute(), examine_expression(), examine_variable(), exec_save_simple_expr(), ExecBuildProjectionInfo(), ExecBuildUpdateProjection(), ExecCheckPlanOutput(), ExecEvalXmlExpr(), ExecInitExprRec(), ExecInitIndexScan(), ExecMakeTableFunctionResult(), ExecTypeFromExprList(), ExecTypeFromTLInternal(), ExecWindowAgg(), expandRecordVariable(), expandRTE(), exprTypmod(), find_expr_references_walker(), find_placeholder_info(), fix_indexqual_operand(), foreign_expr_walker(), generate_append_tlist(), generate_join_implied_equalities_normal(), generate_setop_tlist(), generate_subquery_params(), generateClonedIndexStmt(), get_call_expr_argtype(), get_expr_result_tupdesc(), get_expr_result_type(), get_first_col_type(), get_fn_expr_rettype(), get_func_expr(), get_oper_expr(), get_rule_expr(), get_rule_expr_funccall(), get_rule_orderby(), get_simple_binary_op_name(), get_sublink_expr(), get_windowfunc_expr(), GetIndexInputType(), hash_ok_operator(), hstore_subscript_transform(), initialize_peragg(), inline_function(), internal_get_result_type(), jsonb_exec_setup(), jsonb_subscript_transform(), make_op(), make_scalar_array_op(), makeVarFromTargetEntry(), makeWholeRowVar(), match_pattern_prefix(), ordered_set_startup(), paraminfo_get_equal_hashops(), ParseFuncOrColumn(), pg_get_indexdef_worker(), pg_get_partkeydef_worker(), prepare_query_params(), preprocess_aggref(), preprocess_minmax_aggregates(), ProcedureCreate(), process_equivalence(), process_matched_tle(), recheck_cast_function_args(), relabel_to_typmod(), RelationBuildPartitionKey(), RelationGetDummyIndexExpressions(), remove_unused_subquery_outputs(), replace_nestloop_param_placeholdervar(), replace_outer_grouping(), replace_outer_placeholdervar(), resolveTargetListUnknowns(), scalararraysel(), select_common_type(), select_common_typmod(), set_append_rel_size(), set_dummy_tlist_references(), set_joinrel_partition_key_exprs(), set_pathtarget_cost_width(), set_rel_width(), show_sortorder_options(), tlist_same_datatypes(), transformAExprNullIf(), transformAggregateCall(), transformArrayExpr(), transformAssignedExpr(), transformAssignmentIndirection(), transformAssignmentSubscripts(), transformCaseExpr(), transformCollateClause(), transformExprRecurse(), transformFrameOffset(), transformFromClauseItem(), transformIndirection(), transformInsertStmt(), transformMultiAssignRef(), transformPartitionBoundValue(), transformPLAssignStmt(), transformSetOperationTree(), transformSubLink(), transformTypeCast(), unknown_attribute(), and xmlelement().

exprTypmod()

int32 exprTypmod

(

const Node *

expr

)

Definition at line 267 of file nodeFuncs.c.

{
    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_CoerceToDomain:
            return ((const CoerceToDomain *) expr)->resulttypmod;
        case T_CoerceToDomainValue:
            return ((const CoerceToDomainValue *) expr)->typeMod;
        case T_SetToDefault:
            return ((const SetToDefault *) expr)->typeMod;
        case T_PlaceHolderVar:
            return exprTypmod((Node *) ((const PlaceHolderVar *) expr)->phexpr);
        default:
            break;
    }
    return -1;
}

References arg, OpExpr::args, CaseExpr::args, CoalesceExpr::args, MinMaxExpr::args, ARRAY_SUBLINK, ArrayExpr::array_typeid, Assert(), CaseExpr::casetype, CoalesceExpr::coalescetype, CaseExpr::defresult, ArrayExpr::element_typeid, ArrayExpr::elements, elog, ERROR, EXPR_SUBLINK, exprIsLengthCoercion(), exprType(), SubPlan::firstColTypmod, for_each_from, if(), IsA, lfirst, lfirst_node, linitial, linitial_node, MinMaxExpr::minmaxtype, ArrayExpr::multidims, NIL, nodeTag, CaseWhen::result, SubLink::subLinkType, SubPlan::subLinkType, AlternativeSubPlan::subplans, SubLink::subselect, T_AlternativeSubPlan, T_ArrayCoerceExpr, T_ArrayExpr, T_CaseExpr, T_CaseTestExpr, T_CoalesceExpr, T_CoerceToDomain, T_CoerceToDomainValue, T_CollateExpr, T_Const, T_FieldSelect, T_FuncExpr, T_MinMaxExpr, T_NamedArgExpr, T_NullIfExpr, T_Param, T_PlaceHolderVar, T_RelabelType, T_SetToDefault, T_SQLValueFunction, T_SubLink, T_SubPlan, T_SubscriptingRef, T_Var, and Query::targetList.

Referenced by add_row_identity_var(), addRangeTableEntryForFunction(), addRangeTableEntryForSubquery(), analyzeCTE(), analyzeCTETargetList(), applyRelabelType(), assign_hypothetical_collations(), build_coercion_expression(), build_subplan(), canonicalize_ec_expression(), checkRuleResultList(), coerce_type_typmod(), ConstructTupleDescriptor(), convert_EXISTS_to_ANY(), create_ctas_nodata(), DefineVirtualRelation(), eval_const_expressions_mutator(), examine_attribute(), examine_expression(), examine_variable(), exec_save_simple_expr(), ExecTypeFromExprList(), ExecTypeFromTLInternal(), expandRecordVariable(), expandRTE(), find_placeholder_info(), generate_append_tlist(), generate_setop_tlist(), generate_subquery_params(), get_expr_result_type(), get_first_col_type(), get_rule_expr(), get_rule_expr_funccall(), interval_support(), makeVarFromTargetEntry(), numeric_support(), preprocess_aggref(), RelationBuildPartitionKey(), RelationGetDummyIndexExpressions(), remove_unused_subquery_outputs(), replace_nestloop_param_placeholdervar(), replace_outer_placeholdervar(), select_common_typmod(), set_append_rel_size(), set_dummy_tlist_references(), set_pathtarget_cost_width(), set_rel_width(), TemporalSimplify(), transformCaseExpr(), transformFromClauseItem(), transformIndirection(), transformMultiAssignRef(), transformPLAssignStmt(), transformSubLink(), varbit_support(), and varchar_support().

fix_opfuncids()

void fix_opfuncids

(

Node *

node

)

Definition at line 1652 of file nodeFuncs.c.

{
    /* This tree walk requires no special setup, so away we go... */
    fix_opfuncids_walker(node, NULL);
}

References fix_opfuncids_walker().

Referenced by evaluate_expr(), expression_planner(), expression_planner_with_deps(), fetch_statentries_for_relation(), get_qual_for_range(), get_relation_statistics(), operator_predicate_proof(), RelationBuildPartitionKey(), RelationGetIndexExpressions(), and RelationGetIndexPredicate().

fix_opfuncids_walker()

static bool fix_opfuncids_walker ( Node *  node, void *  context  )

static

Definition at line 1659 of file nodeFuncs.c.

{
    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);
}

References expression_tree_walker(), IsA, set_opfuncid(), and set_sa_opfuncid().

Referenced by fix_opfuncids().

leftmostLoc()

static int leftmostLoc ( int  loc1, int  loc2  )

static

Definition at line 1631 of file nodeFuncs.c.

{
    if (loc1 < 0)
        return loc2;
    else if (loc2 < 0)
        return loc1;
    else
        return Min(loc1, loc2);
}

References Min.

Referenced by exprLocation().

planstate_tree_walker()

bool planstate_tree_walker	(	PlanState *	planstate,
		bool(*)()	walker,
		void *	context
	)

Definition at line 4035 of file nodeFuncs.c.

{
    Plan       *plan = planstate->plan;
    ListCell   *lc;
 
    /* 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 (walker(outerPlanState(planstate), context))
            return true;
    }
 
    /* righttree */
    if (innerPlanState(planstate))
    {
        if (walker(innerPlanState(planstate), context))
            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 (walker(((SubqueryScanState *) planstate)->subplan, context))
                return true;
            break;
        case T_CustomScan:
            foreach(lc, ((CustomScanState *) planstate)->custom_ps)
            {
                if (walker((PlanState *) lfirst(lc), context))
                    return true;
            }
            break;
        default:
            break;
    }
 
    /* subPlan-s */
    if (planstate_walk_subplans(planstate->subPlan, walker, context))
        return true;
 
    return false;
}

References check_stack_depth(), PlanState::initPlan, innerPlanState, lfirst, nodeTag, outerPlanState, PlanState::plan, planstate_walk_members(), planstate_walk_subplans(), PlanState::subPlan, T_Append, T_BitmapAnd, T_BitmapOr, T_CustomScan, T_MergeAppend, and T_SubqueryScan.

Referenced by ExecParallelEstimate(), ExecParallelInitializeDSM(), ExecParallelInitializeWorker(), ExecParallelReInitializeDSM(), ExecParallelReportInstrumentation(), ExecParallelRetrieveInstrumentation(), ExecShutdownNode(), and ExplainPreScanNode().

planstate_walk_members()

static bool planstate_walk_members ( PlanState **  planstates, int  nplans, bool(*)()  walker, void *  context  )

static

Definition at line 4138 of file nodeFuncs.c.

{
    int         j;
 
    for (j = 0; j < nplans; j++)
    {
        if (walker(planstates[j], context))
            return true;
    }
 
    return false;
}

References j.

Referenced by planstate_tree_walker().

planstate_walk_subplans()

static bool planstate_walk_subplans ( List *  plans, bool(*)()  walker, void *  context  )

static

Definition at line 4116 of file nodeFuncs.c.

{
    ListCell   *lc;
 
    foreach(lc, plans)
    {
        SubPlanState *sps = lfirst_node(SubPlanState, lc);
 
        if (walker(sps->planstate, context))
            return true;
    }
 
    return false;
}

References lfirst_node, and SubPlanState::planstate.

Referenced by planstate_tree_walker().

query_or_expression_tree_mutator()

Node* query_or_expression_tree_mutator	(	Node *	node,
		Node *(*)()	mutator,
		void *	context,
		int	flags
	)

Definition at line 3526 of file nodeFuncs.c.

{
    if (node && IsA(node, Query))
        return (Node *) query_tree_mutator((Query *) node,
                                           mutator,
                                           context,
                                           flags);
    else
        return mutator(node, context);
}

References IsA, and query_tree_mutator().

Referenced by map_variable_attnos(), and replace_rte_variables().

query_or_expression_tree_walker()

bool query_or_expression_tree_walker	(	Node *	node,
		bool(*)()	walker,
		void *	context,
		int	flags
	)

Definition at line 3503 of file nodeFuncs.c.

{
    if (node && IsA(node, Query))
        return query_tree_walker((Query *) node,
                                 walker,
                                 context,
                                 flags);
    else
        return walker(node, context);
}

References IsA, and query_tree_walker().

Referenced by checkExprHasSubLink(), contain_aggs_of_level(), contain_vars_of_level(), contain_windowfuncs(), IncrementVarSublevelsUp(), locate_agg_of_level(), locate_var_of_level(), locate_windowfunc(), pull_varnos(), pull_varnos_of_level(), pull_vars_of_level(), rangeTableEntry_used(), and substitute_phv_relids().

query_tree_mutator()

Query* query_tree_mutator	(	Query *	query,
		Node *(*)()	mutator,
		void *	context,
		int	flags
	)

Definition at line 3342 of file nodeFuncs.c.

{
    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->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;
}

References Assert(), copyObject, Query::cteList, Query::distinctClause, WindowClause::endOffset, FLATCOPY, Query::groupClause, Query::havingQual, IsA, Query::jointree, lappend(), lfirst_node, Query::limitCount, Query::limitOffset, MUTATE, NIL, Query::onConflict, QTW_DONT_COPY_QUERY, QTW_EXAMINE_SORTGROUP, QTW_IGNORE_CTE_SUBQUERIES, range_table_mutator(), Query::returningList, Query::rtable, Query::setOperations, Query::sortClause, WindowClause::startOffset, Query::targetList, Query::windowClause, and Query::withCheckOptions.

Referenced by flatten_join_alias_vars_mutator(), map_variable_attnos_mutator(), query_or_expression_tree_mutator(), replace_rte_variables_mutator(), substitute_actual_srf_parameters(), and substitute_actual_srf_parameters_mutator().

query_tree_walker()

bool query_tree_walker	(	Query *	query,
		bool(*)()	walker,
		void *	context,
		int	flags
	)

Definition at line 2375 of file nodeFuncs.c.

{
    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 (walker((Node *) query->targetList, context))
        return true;
    if (walker((Node *) query->withCheckOptions, context))
        return true;
    if (walker((Node *) query->onConflict, context))
        return true;
    if (walker((Node *) query->returningList, context))
        return true;
    if (walker((Node *) query->jointree, context))
        return true;
    if (walker(query->setOperations, context))
        return true;
    if (walker(query->havingQual, context))
        return true;
    if (walker(query->limitOffset, context))
        return true;
    if (walker(query->limitCount, context))
        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 (walker((Node *) query->groupClause, context))
            return true;
        if (walker((Node *) query->windowClause, context))
            return true;
        if (walker((Node *) query->sortClause, context))
            return true;
        if (walker((Node *) query->distinctClause, context))
            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 (walker(wc->startOffset, context))
                return true;
            if (walker(wc->endOffset, context))
                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 (walker((Node *) query->cteList, context))
            return true;
    }
    if (!(flags & QTW_IGNORE_RANGE_TABLE))
    {
        if (range_table_walker(query->rtable, walker, context, flags))
            return true;
    }
    return false;
}

References Assert(), Query::cteList, Query::distinctClause, WindowClause::endOffset, Query::groupClause, Query::havingQual, IsA, Query::jointree, lfirst_node, Query::limitCount, Query::limitOffset, Query::onConflict, QTW_EXAMINE_SORTGROUP, QTW_IGNORE_CTE_SUBQUERIES, QTW_IGNORE_RANGE_TABLE, range_table_walker(), Query::returningList, Query::rtable, Query::setOperations, Query::sortClause, WindowClause::startOffset, Query::targetList, Query::windowClause, and Query::withCheckOptions.

Referenced by AcquireRewriteLocks(), assign_query_collations(), ChangeVarNodes(), ChangeVarNodes_walker(), check_agg_arguments_walker(), check_parameter_resolution_walker(), check_ungrouped_columns_walker(), check_variable_parameters(), contain_aggs_of_level_walker(), contain_dml_walker(), contain_mutable_functions_walker(), contain_outer_selfref_walker(), contain_vars_of_level_walker(), contain_volatile_functions_not_nextval_walker(), contain_volatile_functions_walker(), extract_query_dependencies_walker(), finalize_grouping_exprs_walker(), find_dependent_phvs(), find_dependent_phvs_walker(), find_expr_references_walker(), fireRIRrules(), flatten_rtes_walker(), flatten_unplanned_rtes(), IncrementVarSublevelsUp_walker(), inline_cte_walker(), isQueryUsingTempRelation_walker(), locate_agg_of_level_walker(), locate_var_of_level_walker(), LockViewRecurse_walker(), max_parallel_hazard_walker(), OffsetVarNodes(), OffsetVarNodes_walker(), pull_varnos_walker(), pull_vars_walker(), query_contains_extern_params(), query_contains_extern_params_walker(), query_or_expression_tree_walker(), rangeTableEntry_used_walker(), rewriteTargetView(), ScanQueryForLocks(), setRuleCheckAsUser_Query(), and substitute_phv_relids_walker().

range_table_entry_walker()

bool range_table_entry_walker	(	RangeTblEntry *	rte,
		bool(*)()	walker,
		void *	context,
		int	flags
	)

Definition at line 2495 of file nodeFuncs.c.

{
    /*
     * 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 (walker(rte, context))
            return true;
 
    switch (rte->rtekind)
    {
        case RTE_RELATION:
            if (walker(rte->tablesample, context))
                return true;
            break;
        case RTE_SUBQUERY:
            if (!(flags & QTW_IGNORE_RT_SUBQUERIES))
                if (walker(rte->subquery, context))
                    return true;
            break;
        case RTE_JOIN:
            if (!(flags & QTW_IGNORE_JOINALIASES))
                if (walker(rte->joinaliasvars, context))
                    return true;
            break;
        case RTE_FUNCTION:
            if (walker(rte->functions, context))
                return true;
            break;
        case RTE_TABLEFUNC:
            if (walker(rte->tablefunc, context))
                return true;
            break;
        case RTE_VALUES:
            if (walker(rte->values_lists, context))
                return true;
            break;
        case RTE_CTE:
        case RTE_NAMEDTUPLESTORE:
        case RTE_RESULT:
            /* nothing to do */
            break;
    }
 
    if (walker(rte->securityQuals, context))
        return true;
 
    if (flags & QTW_EXAMINE_RTES_AFTER)
        if (walker(rte, context))
            return true;
 
    return false;
}

References RangeTblEntry::functions, RangeTblEntry::joinaliasvars, QTW_EXAMINE_RTES_AFTER, QTW_EXAMINE_RTES_BEFORE, QTW_IGNORE_JOINALIASES, QTW_IGNORE_RT_SUBQUERIES, RTE_CTE, RTE_FUNCTION, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, RangeTblEntry::securityQuals, RangeTblEntry::subquery, RangeTblEntry::tablefunc, RangeTblEntry::tablesample, and RangeTblEntry::values_lists.

Referenced by find_dependent_phvs_in_jointree(), and range_table_walker().

range_table_mutator()

List* range_table_mutator	(	List *	rtable,
		Node *(*)()	mutator,
		void *	context,
		int	flags
	)

Definition at line 3431 of file nodeFuncs.c.

{
    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))
                {
                    CHECKFLATCOPY(newrte->subquery, rte->subquery, Query);
                    MUTATE(newrte->subquery, newrte->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;
        }
        MUTATE(newrte->securityQuals, rte->securityQuals, List *);
        newrt = lappend(newrt, newrte);
    }
    return newrt;
}

References CHECKFLATCOPY, copyObject, FLATCOPY, RangeTblEntry::functions, RangeTblEntry::joinaliasvars, lappend(), lfirst, MUTATE, NIL, QTW_IGNORE_JOINALIASES, QTW_IGNORE_RT_SUBQUERIES, RTE_CTE, RTE_FUNCTION, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, RangeTblEntry::securityQuals, RangeTblEntry::subquery, RangeTblEntry::tablefunc, RangeTblEntry::tablesample, and RangeTblEntry::values_lists.

Referenced by query_tree_mutator().

range_table_walker()

bool range_table_walker	(	List *	rtable,
		bool(*)()	walker,
		void *	context,
		int	flags
	)

Definition at line 2474 of file nodeFuncs.c.

{
    ListCell   *rt;
 
    foreach(rt, rtable)
    {
        RangeTblEntry *rte = lfirst_node(RangeTblEntry, rt);
 
        if (range_table_entry_walker(rte, walker, context, flags))
            return true;
    }
    return false;
}

References lfirst_node, and range_table_entry_walker().

Referenced by IncrementVarSublevelsUp_rtable(), and query_tree_walker().

raw_expression_tree_walker()

bool raw_expression_tree_walker	(	Node *	node,
		bool(*)()	walker,
		void *	context
	)

Definition at line 3557 of file nodeFuncs.c.

{
    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_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:
            /* primitive node types with no subnodes */
            break;
        case T_Alias:
            /* we assume the colnames list isn't interesting */
            break;
        case T_RangeVar:
            return walker(((RangeVar *) node)->alias, context);
        case T_GroupingFunc:
            return walker(((GroupingFunc *) node)->args, context);
        case T_SubLink:
            {
                SubLink    *sublink = (SubLink *) node;
 
                if (walker(sublink->testexpr, context))
                    return true;
                /* we assume the operName is not interesting */
                if (walker(sublink->subselect, context))
                    return true;
            }
            break;
        case T_CaseExpr:
            {
                CaseExpr   *caseexpr = (CaseExpr *) node;
 
                if (walker(caseexpr->arg, context))
                    return true;
                /* we assume walker doesn't care about CaseWhens, either */
                foreach(temp, caseexpr->args)
                {
                    CaseWhen   *when = lfirst_node(CaseWhen, temp);
 
                    if (walker(when->expr, context))
                        return true;
                    if (walker(when->result, context))
                        return true;
                }
                if (walker(caseexpr->defresult, context))
                    return true;
            }
            break;
        case T_RowExpr:
            /* Assume colnames isn't interesting */
            return walker(((RowExpr *) node)->args, context);
        case T_CoalesceExpr:
            return walker(((CoalesceExpr *) node)->args, context);
        case T_MinMaxExpr:
            return walker(((MinMaxExpr *) node)->args, context);
        case T_XmlExpr:
            {
                XmlExpr    *xexpr = (XmlExpr *) node;
 
                if (walker(xexpr->named_args, context))
                    return true;
                /* we assume walker doesn't care about arg_names */
                if (walker(xexpr->args, context))
                    return true;
            }
            break;
        case T_NullTest:
            return walker(((NullTest *) node)->arg, context);
        case T_BooleanTest:
            return walker(((BooleanTest *) node)->arg, context);
        case T_JoinExpr:
            {
                JoinExpr   *join = (JoinExpr *) node;
 
                if (walker(join->larg, context))
                    return true;
                if (walker(join->rarg, context))
                    return true;
                if (walker(join->quals, context))
                    return true;
                if (walker(join->alias, context))
                    return true;
                /* using list is deemed uninteresting */
            }
            break;
        case T_IntoClause:
            {
                IntoClause *into = (IntoClause *) node;
 
                if (walker(into->rel, context))
                    return true;
                /* colNames, options are deemed uninteresting */
                /* viewQuery should be null in raw parsetree, but check it */
                if (walker(into->viewQuery, context))
                    return true;
            }
            break;
        case T_List:
            foreach(temp, (List *) node)
            {
                if (walker((Node *) lfirst(temp), context))
                    return true;
            }
            break;
        case T_InsertStmt:
            {
                InsertStmt *stmt = (InsertStmt *) node;
 
                if (walker(stmt->relation, context))
                    return true;
                if (walker(stmt->cols, context))
                    return true;
                if (walker(stmt->selectStmt, context))
                    return true;
                if (walker(stmt->onConflictClause, context))
                    return true;
                if (walker(stmt->returningList, context))
                    return true;
                if (walker(stmt->withClause, context))
                    return true;
            }
            break;
        case T_DeleteStmt:
            {
                DeleteStmt *stmt = (DeleteStmt *) node;
 
                if (walker(stmt->relation, context))
                    return true;
                if (walker(stmt->usingClause, context))
                    return true;
                if (walker(stmt->whereClause, context))
                    return true;
                if (walker(stmt->returningList, context))
                    return true;
                if (walker(stmt->withClause, context))
                    return true;
            }
            break;
        case T_UpdateStmt:
            {
                UpdateStmt *stmt = (UpdateStmt *) node;
 
                if (walker(stmt->relation, context))
                    return true;
                if (walker(stmt->targetList, context))
                    return true;
                if (walker(stmt->whereClause, context))
                    return true;
                if (walker(stmt->fromClause, context))
                    return true;
                if (walker(stmt->returningList, context))
                    return true;
                if (walker(stmt->withClause, context))
                    return true;
            }
            break;
        case T_SelectStmt:
            {
                SelectStmt *stmt = (SelectStmt *) node;
 
                if (walker(stmt->distinctClause, context))
                    return true;
                if (walker(stmt->intoClause, context))
                    return true;
                if (walker(stmt->targetList, context))
                    return true;
                if (walker(stmt->fromClause, context))
                    return true;
                if (walker(stmt->whereClause, context))
                    return true;
                if (walker(stmt->groupClause, context))
                    return true;
                if (walker(stmt->havingClause, context))
                    return true;
                if (walker(stmt->windowClause, context))
                    return true;
                if (walker(stmt->valuesLists, context))
                    return true;
                if (walker(stmt->sortClause, context))
                    return true;
                if (walker(stmt->limitOffset, context))
                    return true;
                if (walker(stmt->limitCount, context))
                    return true;
                if (walker(stmt->lockingClause, context))
                    return true;
                if (walker(stmt->withClause, context))
                    return true;
                if (walker(stmt->larg, context))
                    return true;
                if (walker(stmt->rarg, context))
                    return true;
            }
            break;
        case T_PLAssignStmt:
            {
                PLAssignStmt *stmt = (PLAssignStmt *) node;
 
                if (walker(stmt->indirection, context))
                    return true;
                if (walker(stmt->val, context))
                    return true;
            }
            break;
        case T_A_Expr:
            {
                A_Expr     *expr = (A_Expr *) node;
 
                if (walker(expr->lexpr, context))
                    return true;
                if (walker(expr->rexpr, context))
                    return true;
                /* operator name is deemed uninteresting */
            }
            break;
        case T_BoolExpr:
            {
                BoolExpr   *expr = (BoolExpr *) node;
 
                if (walker(expr->args, context))
                    return true;
            }
            break;
        case T_ColumnRef:
            /* we assume the fields contain nothing interesting */
            break;
        case T_FuncCall:
            {
                FuncCall   *fcall = (FuncCall *) node;
 
                if (walker(fcall->args, context))
                    return true;
                if (walker(fcall->agg_order, context))
                    return true;
                if (walker(fcall->agg_filter, context))
                    return true;
                if (walker(fcall->over, context))
                    return true;
                /* function name is deemed uninteresting */
            }
            break;
        case T_NamedArgExpr:
            return walker(((NamedArgExpr *) node)->arg, context);
        case T_A_Indices:
            {
                A_Indices  *indices = (A_Indices *) node;
 
                if (walker(indices->lidx, context))
                    return true;
                if (walker(indices->uidx, context))
                    return true;
            }
            break;
        case T_A_Indirection:
            {
                A_Indirection *indir = (A_Indirection *) node;
 
                if (walker(indir->arg, context))
                    return true;
                if (walker(indir->indirection, context))
                    return true;
            }
            break;
        case T_A_ArrayExpr:
            return walker(((A_ArrayExpr *) node)->elements, context);
        case T_ResTarget:
            {
                ResTarget  *rt = (ResTarget *) node;
 
                if (walker(rt->indirection, context))
                    return true;
                if (walker(rt->val, context))
                    return true;
            }
            break;
        case T_MultiAssignRef:
            return walker(((MultiAssignRef *) node)->source, context);
        case T_TypeCast:
            {
                TypeCast   *tc = (TypeCast *) node;
 
                if (walker(tc->arg, context))
                    return true;
                if (walker(tc->typeName, context))
                    return true;
            }
            break;
        case T_CollateClause:
            return walker(((CollateClause *) node)->arg, context);
        case T_SortBy:
            return walker(((SortBy *) node)->node, context);
        case T_WindowDef:
            {
                WindowDef  *wd = (WindowDef *) node;
 
                if (walker(wd->partitionClause, context))
                    return true;
                if (walker(wd->orderClause, context))
                    return true;
                if (walker(wd->startOffset, context))
                    return true;
                if (walker(wd->endOffset, context))
                    return true;
            }
            break;
        case T_RangeSubselect:
            {
                RangeSubselect *rs = (RangeSubselect *) node;
 
                if (walker(rs->subquery, context))
                    return true;
                if (walker(rs->alias, context))
                    return true;
            }
            break;
        case T_RangeFunction:
            {
                RangeFunction *rf = (RangeFunction *) node;
 
                if (walker(rf->functions, context))
                    return true;
                if (walker(rf->alias, context))
                    return true;
                if (walker(rf->coldeflist, context))
                    return true;
            }
            break;
        case T_RangeTableSample:
            {
                RangeTableSample *rts = (RangeTableSample *) node;
 
                if (walker(rts->relation, context))
                    return true;
                /* method name is deemed uninteresting */
                if (walker(rts->args, context))
                    return true;
                if (walker(rts->repeatable, context))
                    return true;
            }
            break;
        case T_RangeTableFunc:
            {
                RangeTableFunc *rtf = (RangeTableFunc *) node;
 
                if (walker(rtf->docexpr, context))
                    return true;
                if (walker(rtf->rowexpr, context))
                    return true;
                if (walker(rtf->namespaces, context))
                    return true;
                if (walker(rtf->columns, context))
                    return true;
                if (walker(rtf->alias, context))
                    return true;
            }
            break;
        case T_RangeTableFuncCol:
            {
                RangeTableFuncCol *rtfc = (RangeTableFuncCol *) node;
 
                if (walker(rtfc->colexpr, context))
                    return true;
                if (walker(rtfc->coldefexpr, context))
                    return true;
            }
            break;
        case T_TypeName:
            {
                TypeName   *tn = (TypeName *) node;
 
                if (walker(tn->typmods, context))
                    return true;
                if (walker(tn->arrayBounds, context))
                    return true;
                /* type name itself is deemed uninteresting */
            }
            break;
        case T_ColumnDef:
            {
                ColumnDef  *coldef = (ColumnDef *) node;
 
                if (walker(coldef->typeName, context))
                    return true;
                if (walker(coldef->compression, context))
                    return true;
                if (walker(coldef->raw_default, context))
                    return true;
                if (walker(coldef->collClause, context))
                    return true;
                /* for now, constraints are ignored */
            }
            break;
        case T_IndexElem:
            {
                IndexElem  *indelem = (IndexElem *) node;
 
                if (walker(indelem->expr, context))
                    return true;
                /* collation and opclass names are deemed uninteresting */
            }
            break;
        case T_GroupingSet:
            return walker(((GroupingSet *) node)->content, context);
        case T_LockingClause:
            return walker(((LockingClause *) node)->lockedRels, context);
        case T_XmlSerialize:
            {
                XmlSerialize *xs = (XmlSerialize *) node;
 
                if (walker(xs->expr, context))
                    return true;
                if (walker(xs->typeName, context))
                    return true;
            }
            break;
        case T_WithClause:
            return walker(((WithClause *) node)->ctes, context);
        case T_InferClause:
            {
                InferClause *stmt = (InferClause *) node;
 
                if (walker(stmt->indexElems, context))
                    return true;
                if (walker(stmt->whereClause, context))
                    return true;
            }
            break;
        case T_OnConflictClause:
            {
                OnConflictClause *stmt = (OnConflictClause *) node;
 
                if (walker(stmt->infer, context))
                    return true;
                if (walker(stmt->targetList, context))
                    return true;
                if (walker(stmt->whereClause, context))
                    return true;
            }
            break;
        case T_CommonTableExpr:
            /* search_clause and cycle_clause are not interesting here */
            return walker(((CommonTableExpr *) node)->ctequery, context);
        default:
            elog(ERROR, "unrecognized node type: %d",
                 (int) nodeTag(node));
            break;
    }
    return false;
}