#include "postgres.h"
#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/plannodes.h"
#include "optimizer/clauses.h"
#include "parser/parse_coerce.h"
#include "parser/parse_relation.h"
#include "parser/parsetree.h"
#include "rewrite/rewriteManip.h"

Include dependency graph for rewriteManip.c:

Data Structures
struct	contain_aggs_of_level_context

struct	locate_agg_of_level_context

struct	locate_windowfunc_context

struct	OffsetVarNodes_context

struct	ChangeVarNodes_context

struct	IncrementVarSublevelsUp_context

struct	rangeTableEntry_used_context

struct	map_variable_attnos_context

struct	ReplaceVarsFromTargetList_context

Functions
static bool	contain_aggs_of_level_walker (Node node, contain_aggs_of_level_context context)

static bool	locate_agg_of_level_walker (Node node, locate_agg_of_level_context context)

static bool	contain_windowfuncs_walker (Node node, void context)

static bool	locate_windowfunc_walker (Node node, locate_windowfunc_context context)

static bool	checkExprHasSubLink_walker (Node node, void context)

static Relids	offset_relid_set (Relids relids, int offset)

static Relids	adjust_relid_set (Relids relids, int oldrelid, int newrelid)

bool	contain_aggs_of_level (Node *node, int levelsup)

int	locate_agg_of_level (Node *node, int levelsup)

bool	contain_windowfuncs (Node *node)

int	locate_windowfunc (Node *node)

bool	checkExprHasSubLink (Node *node)

static bool	contains_multiexpr_param (Node node, void context)

static bool	OffsetVarNodes_walker (Node node, OffsetVarNodes_context context)

void	OffsetVarNodes (Node *node, int offset, int sublevels_up)

static bool	ChangeVarNodes_walker (Node node, ChangeVarNodes_context context)

void	ChangeVarNodes (Node *node, int rt_index, int new_index, int sublevels_up)

static bool	IncrementVarSublevelsUp_walker (Node node, IncrementVarSublevelsUp_context context)

void	IncrementVarSublevelsUp (Node *node, int delta_sublevels_up, int min_sublevels_up)

void	IncrementVarSublevelsUp_rtable (List *rtable, int delta_sublevels_up, int min_sublevels_up)

static bool	rangeTableEntry_used_walker (Node node, rangeTableEntry_used_context context)

bool	rangeTableEntry_used (Node *node, int rt_index, int sublevels_up)

Query *	getInsertSelectQuery (Query parsetree, Query **subquery_ptr)

void	AddQual (Query parsetree, Node qual)

void	AddInvertedQual (Query parsetree, Node qual)

Node *	replace_rte_variables (Node node, int target_varno, int sublevels_up, replace_rte_variables_callback callback, void callback_arg, bool *outer_hasSubLinks)

Node *	replace_rte_variables_mutator (Node node, replace_rte_variables_context context)

static Node *	map_variable_attnos_mutator (Node node, map_variable_attnos_context context)

Node *	map_variable_attnos (Node node, int target_varno, int sublevels_up, const AttrNumber attno_map, int map_length, Oid to_rowtype, bool *found_whole_row)

static Node *	ReplaceVarsFromTargetList_callback (Var var, replace_rte_variables_context context)

Node *	ReplaceVarsFromTargetList (Node node, int target_varno, int sublevels_up, RangeTblEntry target_rte, List targetlist, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno, bool outer_hasSubLinks)

Function Documentation

void AddInvertedQual	(	Query *	parsetree,
		Node *	qual
	)

Definition at line 1044 of file rewriteManip.c.

References AddQual(), BooleanTest::arg, BooleanTest::booltesttype, IS_NOT_TRUE, BooleanTest::location, makeNode, and NULL.

Referenced by CopyAndAddInvertedQual().

 {
     BooleanTest *invqual;
 
     if (qual == NULL)
         return;
 
     /* Need not copy input qual, because AddQual will... */
     invqual = makeNode(BooleanTest);
     invqual->arg = (Expr *) qual;
     invqual->booltesttype = IS_NOT_TRUE;
     invqual->location = -1;
 
     AddQual(parsetree, (Node *) invqual);
 }

void AddQual	(	Query *	parsetree,
		Node *	qual
	)

Definition at line 976 of file rewriteManip.c.

References Assert, checkExprHasSubLink(), CMD_UTILITY, Query::commandType, contain_aggs_of_level(), copyObject, ereport, errcode(), errmsg(), ERROR, Query::hasSubLinks, IsA, Query::jointree, make_and_qual(), NULL, FromExpr::quals, Query::setOperations, and Query::utilityStmt.

Referenced by AddInvertedQual(), rewriteRuleAction(), and rewriteTargetView().

 {
     Node       *copy;
 
     if (qual == NULL)
         return;
 
     if (parsetree->commandType == CMD_UTILITY)
     {
         /*
          * There's noplace to put the qual on a utility statement.
          *
          * If it's a NOTIFY, silently ignore the qual; this means that the
          * NOTIFY will execute, whether or not there are any qualifying rows.
          * While clearly wrong, this is much more useful than refusing to
          * execute the rule at all, and extra NOTIFY events are harmless for
          * typical uses of NOTIFY.
          *
          * If it isn't a NOTIFY, error out, since unconditional execution of
          * other utility stmts is unlikely to be wanted.  (This case is not
          * currently allowed anyway, but keep the test for safety.)
          */
         if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
             return;
         else
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("conditional utility statements are not implemented")));
     }
 
     if (parsetree->setOperations != NULL)
     {
         /*
          * There's noplace to put the qual on a setop statement, either. (This
          * could be fixed, but right now the planner simply ignores any qual
          * condition on a setop query.)
          */
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
     }
 
     /* INTERSECT want's the original, but we need to copy - Jan */
     copy = copyObject(qual);
 
     parsetree->jointree->quals = make_and_qual(parsetree->jointree->quals,
                                                copy);
 
     /*
      * We had better not have stuck an aggregate into the WHERE clause.
      */
     Assert(!contain_aggs_of_level(copy, 0));
 
     /*
      * Make sure query is marked correctly if added qual has sublinks. Need
      * not search qual when query is already marked.
      */
     if (!parsetree->hasSubLinks)
         parsetree->hasSubLinks = checkExprHasSubLink(copy);
 }

static Relids adjust_relid_set	(	Relids	relids,
		int	oldrelid,
		int	newrelid
	)

static

Definition at line 661 of file rewriteManip.c.

References bms_add_member(), bms_copy(), bms_del_member(), and bms_is_member().

Referenced by ChangeVarNodes_walker().

 {
     if (bms_is_member(oldrelid, relids))
     {
         /* Ensure we have a modifiable copy */
         relids = bms_copy(relids);
         /* Remove old, add new */
         relids = bms_del_member(relids, oldrelid);
         relids = bms_add_member(relids, newrelid);
     }
     return relids;
 }

void ChangeVarNodes	(	Node *	node,
		int	rt_index,
		int	new_index,
		int	sublevels_up
	)

Definition at line 607 of file rewriteManip.c.

References ChangeVarNodes_walker(), OnConflictExpr::exclRelIndex, IsA, lfirst, ChangeVarNodes_context::new_index, Query::onConflict, query_tree_walker(), Query::resultRelation, Query::rowMarks, ChangeVarNodes_context::rt_index, RowMarkClause::rti, and ChangeVarNodes_context::sublevels_up.

Referenced by add_security_quals(), add_with_check_options(), ApplyRetrieveRule(), CopyAndAddInvertedQual(), get_relation_constraints(), get_relation_info(), inheritance_planner(), rewriteRuleAction(), rewriteTargetView(), and TriggerEnabled().

 {
     ChangeVarNodes_context context;
 
     context.rt_index = rt_index;
     context.new_index = new_index;
     context.sublevels_up = sublevels_up;
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, go straight to query_tree_walker to make sure that
      * sublevels_up doesn't get incremented prematurely.
      */
     if (node && IsA(node, Query))
     {
         Query      *qry = (Query *) node;
 
         /*
          * If we are starting at a Query, and sublevels_up is zero, then we
          * must also fix rangetable indexes in the Query itself --- namely
          * resultRelation and rowMarks entries.  sublevels_up cannot be zero
          * when recursing into a subquery, so there's no need to have the same
          * logic inside ChangeVarNodes_walker.
          */
         if (sublevels_up == 0)
         {
             ListCell   *l;
 
             if (qry->resultRelation == rt_index)
                 qry->resultRelation = new_index;
 
             /* this is unlikely to ever be used, but ... */
             if (qry->onConflict && qry->onConflict->exclRelIndex == rt_index)
                 qry->onConflict->exclRelIndex = new_index;
 
             foreach(l, qry->rowMarks)
             {
                 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
 
                 if (rc->rti == rt_index)
                     rc->rti = new_index;
             }
         }
         query_tree_walker(qry, ChangeVarNodes_walker,
                           (void *) &context, 0);
     }
     else
         ChangeVarNodes_walker(node, &context);
 }

static bool ChangeVarNodes_walker	(	Node *	node,
		ChangeVarNodes_context *	context
	)

static

Definition at line 504 of file rewriteManip.c.

References adjust_relid_set(), Assert, AppendRelInfo::child_relid, CurrentOfExpr::cvarno, expression_tree_walker(), IsA, ChangeVarNodes_context::new_index, NULL, AppendRelInfo::parent_relid, PlaceHolderVar::phlevelsup, PlaceHolderVar::phrels, PlanRowMark::prti, query_tree_walker(), result, ChangeVarNodes_context::rt_index, PlanRowMark::rti, RangeTblRef::rtindex, JoinExpr::rtindex, ChangeVarNodes_context::sublevels_up, Var::varlevelsup, Var::varno, and Var::varnoold.

Referenced by ChangeVarNodes().

 {
     if (node == NULL)
         return false;
     if (IsA(node, Var))
     {
         Var        *var = (Var *) node;
 
         if (var->varlevelsup == context->sublevels_up &&
             var->varno == context->rt_index)
         {
             var->varno = context->new_index;
             var->varnoold = context->new_index;
         }
         return false;
     }
     if (IsA(node, CurrentOfExpr))
     {
         CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
 
         if (context->sublevels_up == 0 &&
             cexpr->cvarno == context->rt_index)
             cexpr->cvarno = context->new_index;
         return false;
     }
     if (IsA(node, RangeTblRef))
     {
         RangeTblRef *rtr = (RangeTblRef *) node;
 
         if (context->sublevels_up == 0 &&
             rtr->rtindex == context->rt_index)
             rtr->rtindex = context->new_index;
         /* the subquery itself is visited separately */
         return false;
     }
     if (IsA(node, JoinExpr))
     {
         JoinExpr   *j = (JoinExpr *) node;
 
         if (context->sublevels_up == 0 &&
             j->rtindex == context->rt_index)
             j->rtindex = context->new_index;
         /* fall through to examine children */
     }
     if (IsA(node, PlaceHolderVar))
     {
         PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
         if (phv->phlevelsup == context->sublevels_up)
         {
             phv->phrels = adjust_relid_set(phv->phrels,
                                            context->rt_index,
                                            context->new_index);
         }
         /* fall through to examine children */
     }
     if (IsA(node, PlanRowMark))
     {
         PlanRowMark *rowmark = (PlanRowMark *) node;
 
         if (context->sublevels_up == 0)
         {
             if (rowmark->rti == context->rt_index)
                 rowmark->rti = context->new_index;
             if (rowmark->prti == context->rt_index)
                 rowmark->prti = context->new_index;
         }
         return false;
     }
     if (IsA(node, AppendRelInfo))
     {
         AppendRelInfo *appinfo = (AppendRelInfo *) node;
 
         if (context->sublevels_up == 0)
         {
             if (appinfo->parent_relid == context->rt_index)
                 appinfo->parent_relid = context->new_index;
             if (appinfo->child_relid == context->rt_index)
                 appinfo->child_relid = context->new_index;
         }
         /* fall through to examine children */
     }
     /* Shouldn't need to handle other planner auxiliary nodes here */
     Assert(!IsA(node, SpecialJoinInfo));
     Assert(!IsA(node, PlaceHolderInfo));
     Assert(!IsA(node, MinMaxAggInfo));
 
     if (IsA(node, Query))
     {
         /* Recurse into subselects */
         bool        result;
 
         context->sublevels_up++;
         result = query_tree_walker((Query *) node, ChangeVarNodes_walker,
                                    (void *) context, 0);
         context->sublevels_up--;
         return result;
     }
     return expression_tree_walker(node, ChangeVarNodes_walker,
                                   (void *) context);
 }

bool checkExprHasSubLink ( Node * node )

Definition at line 277 of file rewriteManip.c.

References checkExprHasSubLink_walker(), NULL, QTW_IGNORE_RC_SUBQUERIES, and query_or_expression_tree_walker().

Referenced by AddQual(), flatten_join_alias_vars_mutator(), RelationBuildRowSecurity(), replace_rte_variables_mutator(), rewriteRuleAction(), and rewriteTargetView().

 {
     /*
      * If a Query is passed, examine it --- but we should not recurse into
      * sub-Queries that are in its rangetable or CTE list.
      */
     return query_or_expression_tree_walker(node,
                                            checkExprHasSubLink_walker,
                                            NULL,
                                            QTW_IGNORE_RC_SUBQUERIES);
 }

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

static

Definition at line 290 of file rewriteManip.c.

References expression_tree_walker(), IsA, and NULL.

Referenced by checkExprHasSubLink().

 {
     if (node == NULL)
         return false;
     if (IsA(node, SubLink))
         return true;            /* abort the tree traversal and return true */
     return expression_tree_walker(node, checkExprHasSubLink_walker, context);
 }

bool contain_aggs_of_level	(	Node *	node,
		int	levelsup
	)

Definition at line 67 of file rewriteManip.c.

References contain_aggs_of_level_walker(), query_or_expression_tree_walker(), and contain_aggs_of_level_context::sublevels_up.

Referenced by AddQual(), checkTargetlistEntrySQL92(), and convert_EXISTS_to_ANY().

 {
     contain_aggs_of_level_context context;
 
     context.sublevels_up = levelsup;
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, we don't want to increment sublevels_up.
      */
     return query_or_expression_tree_walker(node,
                                            contain_aggs_of_level_walker,
                                            (void *) &context,
                                            0);
 }

static bool contain_aggs_of_level_walker	(	Node *	node,
		contain_aggs_of_level_context *	context
	)

static

Definition at line 84 of file rewriteManip.c.

References expression_tree_walker(), IsA, NULL, query_tree_walker(), result, and contain_aggs_of_level_context::sublevels_up.

Referenced by contain_aggs_of_level().

 {
     if (node == NULL)
         return false;
     if (IsA(node, Aggref))
     {
         if (((Aggref *) node)->agglevelsup == context->sublevels_up)
             return true;        /* abort the tree traversal and return true */
         /* else fall through to examine argument */
     }
     if (IsA(node, GroupingFunc))
     {
         if (((GroupingFunc *) node)->agglevelsup == context->sublevels_up)
             return true;
         /* else fall through to examine argument */
     }
     if (IsA(node, Query))
     {
         /* Recurse into subselects */
         bool        result;
 
         context->sublevels_up++;
         result = query_tree_walker((Query *) node,
                                    contain_aggs_of_level_walker,
                                    (void *) context, 0);
         context->sublevels_up--;
         return result;
     }
     return expression_tree_walker(node, contain_aggs_of_level_walker,
                                   (void *) context);
 }

bool contain_windowfuncs ( Node * node )

Definition at line 197 of file rewriteManip.c.

References contain_windowfuncs_walker(), NULL, and query_or_expression_tree_walker().

Referenced by checkTargetlistEntrySQL92(), contain_window_function(), and transformWindowFuncCall().

 {
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, we don't want to increment sublevels_up.
      */
     return query_or_expression_tree_walker(node,
                                            contain_windowfuncs_walker,
                                            NULL,
                                            0);
 }

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

static

Definition at line 210 of file rewriteManip.c.

References expression_tree_walker(), IsA, and NULL.

Referenced by contain_windowfuncs().

 {
     if (node == NULL)
         return false;
     if (IsA(node, WindowFunc))
         return true;            /* abort the tree traversal and return true */
     /* Mustn't recurse into subselects */
     return expression_tree_walker(node, contain_windowfuncs_walker,
                                   (void *) context);
 }

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

static

Definition at line 306 of file rewriteManip.c.

References expression_tree_walker(), IsA, NULL, and PARAM_MULTIEXPR.

Referenced by ReplaceVarsFromTargetList_callback().

 {
     if (node == NULL)
         return false;
     if (IsA(node, Param))
     {
         if (((Param *) node)->paramkind == PARAM_MULTIEXPR)
             return true;        /* abort the tree traversal and return true */
         return false;
     }
     return expression_tree_walker(node, contains_multiexpr_param, context);
 }

Query* getInsertSelectQuery	(	Query *	parsetree,
		Query ***	subquery_ptr
	)

Definition at line 921 of file rewriteManip.c.

References Assert, CMD_INSERT, CMD_SELECT, Query::commandType, elog, ERROR, FromExpr::fromlist, IsA, Query::jointree, linitial, list_length(), NULL, PRS2_NEW_VARNO, PRS2_OLD_VARNO, rt_fetch, Query::rtable, RangeTblRef::rtindex, and RangeTblEntry::subquery.

Referenced by DefineQueryRewrite(), InsertRule(), make_ruledef(), rewriteRuleAction(), and transformRuleStmt().

 {
     Query      *selectquery;
     RangeTblEntry *selectrte;
     RangeTblRef *rtr;
 
     if (subquery_ptr)
         *subquery_ptr = NULL;
 
     if (parsetree == NULL)
         return parsetree;
     if (parsetree->commandType != CMD_INSERT)
         return parsetree;
 
     /*
      * Currently, this is ONLY applied to rule-action queries, and so we
      * expect to find the OLD and NEW placeholder entries in the given query.
      * If they're not there, it must be an INSERT/SELECT in which they've been
      * pushed down to the SELECT.
      */
     if (list_length(parsetree->rtable) >= 2 &&
         strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->aliasname,
                "old") == 0 &&
         strcmp(rt_fetch(PRS2_NEW_VARNO, parsetree->rtable)->eref->aliasname,
                "new") == 0)
         return parsetree;
     Assert(parsetree->jointree && IsA(parsetree->jointree, FromExpr));
     if (list_length(parsetree->jointree->fromlist) != 1)
         elog(ERROR, "expected to find SELECT subquery");
     rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
     Assert(IsA(rtr, RangeTblRef));
     selectrte = rt_fetch(rtr->rtindex, parsetree->rtable);
     selectquery = selectrte->subquery;
     if (!(selectquery && IsA(selectquery, Query) &&
           selectquery->commandType == CMD_SELECT))
         elog(ERROR, "expected to find SELECT subquery");
     if (list_length(selectquery->rtable) >= 2 &&
         strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->aliasname,
                "old") == 0 &&
         strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->aliasname,
                "new") == 0)
     {
         if (subquery_ptr)
             *subquery_ptr = &(selectrte->subquery);
         return selectquery;
     }
     elog(ERROR, "could not find rule placeholders");
     return NULL;                /* not reached */
 }

void IncrementVarSublevelsUp	(	Node *	node,
		int	delta_sublevels_up,
		int	min_sublevels_up
	)

Definition at line 773 of file rewriteManip.c.

References IncrementVarSublevelsUp_context::delta_sublevels_up, IncrementVarSublevelsUp_walker(), IncrementVarSublevelsUp_context::min_sublevels_up, QTW_EXAMINE_RTES, and query_or_expression_tree_walker().

Referenced by assign_param_for_placeholdervar(), build_minmax_path(), convert_EXISTS_sublink_to_join(), convert_EXISTS_to_ANY(), extract_lateral_references(), flatten_join_alias_vars_mutator(), pull_up_simple_subquery(), pullup_replace_vars_callback(), replace_outer_agg(), replace_outer_grouping(), ReplaceVarsFromTargetList_callback(), and substitute_actual_srf_parameters_mutator().

 {
     IncrementVarSublevelsUp_context context;
 
     context.delta_sublevels_up = delta_sublevels_up;
     context.min_sublevels_up = min_sublevels_up;
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, we don't want to increment sublevels_up.
      */
     query_or_expression_tree_walker(node,
                                     IncrementVarSublevelsUp_walker,
                                     (void *) &context,
                                     QTW_EXAMINE_RTES);
 }

void IncrementVarSublevelsUp_rtable	(	List *	rtable,
		int	delta_sublevels_up,
		int	min_sublevels_up
	)

Definition at line 796 of file rewriteManip.c.

References IncrementVarSublevelsUp_context::delta_sublevels_up, IncrementVarSublevelsUp_walker(), IncrementVarSublevelsUp_context::min_sublevels_up, QTW_EXAMINE_RTES, and range_table_walker().

Referenced by pull_up_simple_union_all().

 {
     IncrementVarSublevelsUp_context context;
 
     context.delta_sublevels_up = delta_sublevels_up;
     context.min_sublevels_up = min_sublevels_up;
 
     range_table_walker(rtable,
                        IncrementVarSublevelsUp_walker,
                        (void *) &context,
                        QTW_EXAMINE_RTES);
 }

static bool IncrementVarSublevelsUp_walker	(	Node *	node,
		IncrementVarSublevelsUp_context *	context
	)

static

Definition at line 700 of file rewriteManip.c.

References Aggref::agglevelsup, GroupingFunc::agglevelsup, RangeTblEntry::ctelevelsup, IncrementVarSublevelsUp_context::delta_sublevels_up, elog, ERROR, expression_tree_walker(), IsA, IncrementVarSublevelsUp_context::min_sublevels_up, NULL, PlaceHolderVar::phlevelsup, QTW_EXAMINE_RTES, query_tree_walker(), result, RTE_CTE, RangeTblEntry::rtekind, and Var::varlevelsup.

Referenced by IncrementVarSublevelsUp(), and IncrementVarSublevelsUp_rtable().

 {
     if (node == NULL)
         return false;
     if (IsA(node, Var))
     {
         Var        *var = (Var *) node;
 
         if (var->varlevelsup >= context->min_sublevels_up)
             var->varlevelsup += context->delta_sublevels_up;
         return false;           /* done here */
     }
     if (IsA(node, CurrentOfExpr))
     {
         /* this should not happen */
         if (context->min_sublevels_up == 0)
             elog(ERROR, "cannot push down CurrentOfExpr");
         return false;
     }
     if (IsA(node, Aggref))
     {
         Aggref     *agg = (Aggref *) node;
 
         if (agg->agglevelsup >= context->min_sublevels_up)
             agg->agglevelsup += context->delta_sublevels_up;
         /* fall through to recurse into argument */
     }
     if (IsA(node, GroupingFunc))
     {
         GroupingFunc *grp = (GroupingFunc *) node;
 
         if (grp->agglevelsup >= context->min_sublevels_up)
             grp->agglevelsup += context->delta_sublevels_up;
         /* fall through to recurse into argument */
     }
     if (IsA(node, PlaceHolderVar))
     {
         PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
         if (phv->phlevelsup >= context->min_sublevels_up)
             phv->phlevelsup += context->delta_sublevels_up;
         /* fall through to recurse into argument */
     }
     if (IsA(node, RangeTblEntry))
     {
         RangeTblEntry *rte = (RangeTblEntry *) node;
 
         if (rte->rtekind == RTE_CTE)
         {
             if (rte->ctelevelsup >= context->min_sublevels_up)
                 rte->ctelevelsup += context->delta_sublevels_up;
         }
         return false;           /* allow range_table_walker to continue */
     }
     if (IsA(node, Query))
     {
         /* Recurse into subselects */
         bool        result;
 
         context->min_sublevels_up++;
         result = query_tree_walker((Query *) node,
                                    IncrementVarSublevelsUp_walker,
                                    (void *) context,
                                    QTW_EXAMINE_RTES);
         context->min_sublevels_up--;
         return result;
     }
     return expression_tree_walker(node, IncrementVarSublevelsUp_walker,
                                   (void *) context);
 }

int locate_agg_of_level	(	Node *	node,
		int	levelsup
	)

Definition at line 131 of file rewriteManip.c.

References locate_agg_of_level_context::agg_location, locate_agg_of_level_walker(), query_or_expression_tree_walker(), and locate_agg_of_level_context::sublevels_up.

Referenced by check_agg_arguments(), checkTargetlistEntrySQL92(), and parseCheckAggregates().

 {
     locate_agg_of_level_context context;
 
     context.agg_location = -1;  /* in case we find nothing */
     context.sublevels_up = levelsup;
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, we don't want to increment sublevels_up.
      */
     (void) query_or_expression_tree_walker(node,
                                            locate_agg_of_level_walker,
                                            (void *) &context,
                                            0);
 
     return context.agg_location;
 }

static bool locate_agg_of_level_walker	(	Node *	node,
		locate_agg_of_level_context *	context
	)

static

Definition at line 151 of file rewriteManip.c.

References locate_agg_of_level_context::agg_location, expression_tree_walker(), IsA, NULL, query_tree_walker(), result, and locate_agg_of_level_context::sublevels_up.

Referenced by locate_agg_of_level().

 {
     if (node == NULL)
         return false;
     if (IsA(node, Aggref))
     {
         if (((Aggref *) node)->agglevelsup == context->sublevels_up &&
             ((Aggref *) node)->location >= 0)
         {
             context->agg_location = ((Aggref *) node)->location;
             return true;        /* abort the tree traversal and return true */
         }
         /* else fall through to examine argument */
     }
     if (IsA(node, GroupingFunc))
     {
         if (((GroupingFunc *) node)->agglevelsup == context->sublevels_up &&
             ((GroupingFunc *) node)->location >= 0)
         {
             context->agg_location = ((GroupingFunc *) node)->location;
             return true;        /* abort the tree traversal and return true */
         }
     }
     if (IsA(node, Query))
     {
         /* Recurse into subselects */
         bool        result;
 
         context->sublevels_up++;
         result = query_tree_walker((Query *) node,
                                    locate_agg_of_level_walker,
                                    (void *) context, 0);
         context->sublevels_up--;
         return result;
     }
     return expression_tree_walker(node, locate_agg_of_level_walker,
                                   (void *) context);
 }

int locate_windowfunc ( Node * node )

Definition at line 235 of file rewriteManip.c.

References locate_windowfunc_walker(), query_or_expression_tree_walker(), and locate_windowfunc_context::win_location.

Referenced by checkTargetlistEntrySQL92(), and transformWindowFuncCall().

 {
     locate_windowfunc_context context;
 
     context.win_location = -1;  /* in case we find nothing */
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, we don't want to increment sublevels_up.
      */
     (void) query_or_expression_tree_walker(node,
                                            locate_windowfunc_walker,
                                            (void *) &context,
                                            0);
 
     return context.win_location;
 }

static bool locate_windowfunc_walker	(	Node *	node,
		locate_windowfunc_context *	context
	)

static

Definition at line 254 of file rewriteManip.c.

References expression_tree_walker(), IsA, NULL, and locate_windowfunc_context::win_location.

Referenced by locate_windowfunc().

 {
     if (node == NULL)
         return false;
     if (IsA(node, WindowFunc))
     {
         if (((WindowFunc *) node)->location >= 0)
         {
             context->win_location = ((WindowFunc *) node)->location;
             return true;        /* abort the tree traversal and return true */
         }
         /* else fall through to examine argument */
     }
     /* Mustn't recurse into subselects */
     return expression_tree_walker(node, locate_windowfunc_walker,
                                   (void *) context);
 }

Node* map_variable_attnos	(	Node *	node,
		int	target_varno,
		int	sublevels_up,
		const AttrNumber *	attno_map,
		int	map_length,
		Oid	to_rowtype,
		bool *	found_whole_row
	)

Definition at line 1311 of file rewriteManip.c.

References map_variable_attnos_context::attno_map, map_variable_attnos_context::found_whole_row, map_variable_attnos_context::map_length, map_variable_attnos_mutator(), query_or_expression_tree_mutator(), map_variable_attnos_context::sublevels_up, map_variable_attnos_context::target_varno, and map_variable_attnos_context::to_rowtype.

Referenced by ATPrepAlterColumnType(), generateClonedIndexStmt(), map_partition_varattnos(), MergeAttributes(), and transformTableLikeClause().

 {
     map_variable_attnos_context context;
 
     context.target_varno = target_varno;
     context.sublevels_up = sublevels_up;
     context.attno_map = attno_map;
     context.map_length = map_length;
     context.to_rowtype = to_rowtype;
     context.found_whole_row = found_whole_row;
 
     *found_whole_row = false;
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, we don't want to increment sublevels_up.
      */
     return query_or_expression_tree_mutator(node,
                                             map_variable_attnos_mutator,
                                             (void *) &context,
                                             0);
 }

static Node* map_variable_attnos_mutator	(	Node *	node,
		map_variable_attnos_context *	context
	)

static

Definition at line 1230 of file rewriteManip.c.

References ConvertRowtypeExpr::arg, Assert, map_variable_attnos_context::attno_map, COERCE_IMPLICIT_CAST, ConvertRowtypeExpr::convertformat, elog, ERROR, expression_tree_mutator(), map_variable_attnos_context::found_whole_row, IsA, ConvertRowtypeExpr::location, makeNode, map_variable_attnos_context::map_length, NULL, OidIsValid, palloc(), query_tree_mutator(), RECORDOID, ConvertRowtypeExpr::resulttype, map_variable_attnos_context::sublevels_up, map_variable_attnos_context::target_varno, map_variable_attnos_context::to_rowtype, Var::varattno, Var::varlevelsup, Var::varno, Var::varoattno, and Var::vartype.

Referenced by map_variable_attnos().

 {
     if (node == NULL)
         return NULL;
     if (IsA(node, Var))
     {
         Var        *var = (Var *) node;
 
         if (var->varno == context->target_varno &&
             var->varlevelsup == context->sublevels_up)
         {
             /* Found a matching variable, make the substitution */
             Var        *newvar = (Var *) palloc(sizeof(Var));
             int         attno = var->varattno;
 
             *newvar = *var;
             if (attno > 0)
             {
                 /* user-defined column, replace attno */
                 if (attno > context->map_length ||
                     context->attno_map[attno - 1] == 0)
                     elog(ERROR, "unexpected varattno %d in expression to be mapped",
                          attno);
                 newvar->varattno = newvar->varoattno = context->attno_map[attno - 1];
             }
             else if (attno == 0)
             {
                 /* whole-row variable, warn caller */
                 *(context->found_whole_row) = true;
 
                 /* If the callers expects us to convert the same, do so. */
                 if (OidIsValid(context->to_rowtype))
                 {
                     /* No support for RECORDOID. */
                     Assert(var->vartype != RECORDOID);
 
                     /* Don't convert unless necessary. */
                     if (context->to_rowtype != var->vartype)
                     {
                         ConvertRowtypeExpr *r;
 
                         /* Var itself is converted to the requested type. */
                         newvar->vartype = context->to_rowtype;
 
                         /*
                          * And a conversion node on top to convert back to the
                          * original type.
                          */
                         r = makeNode(ConvertRowtypeExpr);
                         r->arg = (Expr *) newvar;
                         r->resulttype = var->vartype;
                         r->convertformat = COERCE_IMPLICIT_CAST;
                         r->location = -1;
 
                         return (Node *) r;
                     }
                 }
             }
             return (Node *) newvar;
         }
         /* otherwise fall through to copy the var normally */
     }
     else if (IsA(node, Query))
     {
         /* Recurse into RTE subquery or not-yet-planned sublink subquery */
         Query      *newnode;
 
         context->sublevels_up++;
         newnode = query_tree_mutator((Query *) node,
                                      map_variable_attnos_mutator,
                                      (void *) context,
                                      0);
         context->sublevels_up--;
         return (Node *) newnode;
     }
     return expression_tree_mutator(node, map_variable_attnos_mutator,
                                    (void *) context);
 }

static Relids offset_relid_set	(	Relids	relids,
		int	offset
	)

static

Definition at line 472 of file rewriteManip.c.

References bms_add_member(), bms_next_member(), NULL, and result.

Referenced by OffsetVarNodes_walker().

 {
     Relids      result = NULL;
     int         rtindex;
 
     rtindex = -1;
     while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
         result = bms_add_member(result, rtindex + offset);
     return result;
 }

void OffsetVarNodes	(	Node *	node,
		int	offset,
		int	sublevels_up
	)

Definition at line 424 of file rewriteManip.c.

References OnConflictExpr::exclRelIndex, IsA, lfirst, OffsetVarNodes_context::offset, OffsetVarNodes_walker(), Query::onConflict, query_tree_walker(), Query::resultRelation, Query::rowMarks, RowMarkClause::rti, and OffsetVarNodes_context::sublevels_up.

Referenced by convert_EXISTS_sublink_to_join(), pull_up_simple_subquery(), rewriteRuleAction(), and UpdateRangeTableOfViewParse().

 {
     OffsetVarNodes_context context;
 
     context.offset = offset;
     context.sublevels_up = sublevels_up;
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, go straight to query_tree_walker to make sure that
      * sublevels_up doesn't get incremented prematurely.
      */
     if (node && IsA(node, Query))
     {
         Query      *qry = (Query *) node;
 
         /*
          * If we are starting at a Query, and sublevels_up is zero, then we
          * must also fix rangetable indexes in the Query itself --- namely
          * resultRelation, exclRelIndex and rowMarks entries.  sublevels_up
          * cannot be zero when recursing into a subquery, so there's no need
          * to have the same logic inside OffsetVarNodes_walker.
          */
         if (sublevels_up == 0)
         {
             ListCell   *l;
 
             if (qry->resultRelation)
                 qry->resultRelation += offset;
 
             if (qry->onConflict && qry->onConflict->exclRelIndex)
                 qry->onConflict->exclRelIndex += offset;
 
             foreach(l, qry->rowMarks)
             {
                 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
 
                 rc->rti += offset;
             }
         }
         query_tree_walker(qry, OffsetVarNodes_walker,
                           (void *) &context, 0);
     }
     else
         OffsetVarNodes_walker(node, &context);
 }

static bool OffsetVarNodes_walker	(	Node *	node,
		OffsetVarNodes_context *	context
	)

static

Definition at line 340 of file rewriteManip.c.

References Assert, AppendRelInfo::child_relid, CurrentOfExpr::cvarno, expression_tree_walker(), IsA, NULL, OffsetVarNodes_context::offset, offset_relid_set(), AppendRelInfo::parent_relid, PlaceHolderVar::phlevelsup, PlaceHolderVar::phrels, query_tree_walker(), result, RangeTblRef::rtindex, JoinExpr::rtindex, OffsetVarNodes_context::sublevels_up, Var::varlevelsup, Var::varno, and Var::varnoold.

Referenced by OffsetVarNodes().

 {
     if (node == NULL)
         return false;
     if (IsA(node, Var))
     {
         Var        *var = (Var *) node;
 
         if (var->varlevelsup == context->sublevels_up)
         {
             var->varno += context->offset;
             var->varnoold += context->offset;
         }
         return false;
     }
     if (IsA(node, CurrentOfExpr))
     {
         CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
 
         if (context->sublevels_up == 0)
             cexpr->cvarno += context->offset;
         return false;
     }
     if (IsA(node, RangeTblRef))
     {
         RangeTblRef *rtr = (RangeTblRef *) node;
 
         if (context->sublevels_up == 0)
             rtr->rtindex += context->offset;
         /* the subquery itself is visited separately */
         return false;
     }
     if (IsA(node, JoinExpr))
     {
         JoinExpr   *j = (JoinExpr *) node;
 
         if (j->rtindex && context->sublevels_up == 0)
             j->rtindex += context->offset;
         /* fall through to examine children */
     }
     if (IsA(node, PlaceHolderVar))
     {
         PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
         if (phv->phlevelsup == context->sublevels_up)
         {
             phv->phrels = offset_relid_set(phv->phrels,
                                            context->offset);
         }
         /* fall through to examine children */
     }
     if (IsA(node, AppendRelInfo))
     {
         AppendRelInfo *appinfo = (AppendRelInfo *) node;
 
         if (context->sublevels_up == 0)
         {
             appinfo->parent_relid += context->offset;
             appinfo->child_relid += context->offset;
         }
         /* fall through to examine children */
     }
     /* Shouldn't need to handle other planner auxiliary nodes here */
     Assert(!IsA(node, PlanRowMark));
     Assert(!IsA(node, SpecialJoinInfo));
     Assert(!IsA(node, PlaceHolderInfo));
     Assert(!IsA(node, MinMaxAggInfo));
 
     if (IsA(node, Query))
     {
         /* Recurse into subselects */
         bool        result;
 
         context->sublevels_up++;
         result = query_tree_walker((Query *) node, OffsetVarNodes_walker,
                                    (void *) context, 0);
         context->sublevels_up--;
         return result;
     }
     return expression_tree_walker(node, OffsetVarNodes_walker,
                                   (void *) context);
 }

bool rangeTableEntry_used	(	Node *	node,
		int	rt_index,
		int	sublevels_up
	)

Definition at line 889 of file rewriteManip.c.

References query_or_expression_tree_walker(), rangeTableEntry_used_walker(), rangeTableEntry_used_context::rt_index, and rangeTableEntry_used_context::sublevels_up.

Referenced by fireRIRrules(), matchLocks(), rewriteRuleAction(), and transformRuleStmt().

 {
     rangeTableEntry_used_context context;
 
     context.rt_index = rt_index;
     context.sublevels_up = sublevels_up;
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, we don't want to increment sublevels_up.
      */
     return query_or_expression_tree_walker(node,
                                            rangeTableEntry_used_walker,
                                            (void *) &context,
                                            0);
 }

static bool rangeTableEntry_used_walker	(	Node *	node,
		rangeTableEntry_used_context *	context
	)

static

Definition at line 823 of file rewriteManip.c.

References Assert, CurrentOfExpr::cvarno, expression_tree_walker(), IsA, NULL, query_tree_walker(), result, rangeTableEntry_used_context::rt_index, RangeTblRef::rtindex, JoinExpr::rtindex, rangeTableEntry_used_context::sublevels_up, Var::varlevelsup, and Var::varno.

Referenced by rangeTableEntry_used().

 {
     if (node == NULL)
         return false;
     if (IsA(node, Var))
     {
         Var        *var = (Var *) node;
 
         if (var->varlevelsup == context->sublevels_up &&
             var->varno == context->rt_index)
             return true;
         return false;
     }
     if (IsA(node, CurrentOfExpr))
     {
         CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
 
         if (context->sublevels_up == 0 &&
             cexpr->cvarno == context->rt_index)
             return true;
         return false;
     }
     if (IsA(node, RangeTblRef))
     {
         RangeTblRef *rtr = (RangeTblRef *) node;
 
         if (rtr->rtindex == context->rt_index &&
             context->sublevels_up == 0)
             return true;
         /* the subquery itself is visited separately */
         return false;
     }
     if (IsA(node, JoinExpr))
     {
         JoinExpr   *j = (JoinExpr *) node;
 
         if (j->rtindex == context->rt_index &&
             context->sublevels_up == 0)
             return true;
         /* fall through to examine children */
     }
     /* Shouldn't need to handle planner auxiliary nodes here */
     Assert(!IsA(node, PlaceHolderVar));
     Assert(!IsA(node, PlanRowMark));
     Assert(!IsA(node, SpecialJoinInfo));
     Assert(!IsA(node, AppendRelInfo));
     Assert(!IsA(node, PlaceHolderInfo));
     Assert(!IsA(node, MinMaxAggInfo));
 
     if (IsA(node, Query))
     {
         /* Recurse into subselects */
         bool        result;
 
         context->sublevels_up++;
         result = query_tree_walker((Query *) node, rangeTableEntry_used_walker,
                                    (void *) context, 0);
         context->sublevels_up--;
         return result;
     }
     return expression_tree_walker(node, rangeTableEntry_used_walker,
                                   (void *) context);
 }

Node* replace_rte_variables	(	Node *	node,
		int	target_varno,
		int	sublevels_up,
		replace_rte_variables_callback	callback,
		void *	callback_arg,
		bool *	outer_hasSubLinks
	)

Definition at line 1084 of file rewriteManip.c.

References replace_rte_variables_context::callback, callback(), replace_rte_variables_context::callback_arg, elog, ERROR, replace_rte_variables_context::inserted_sublink, IsA, query_or_expression_tree_mutator(), replace_rte_variables_mutator(), result, replace_rte_variables_context::sublevels_up, and replace_rte_variables_context::target_varno.

Referenced by pullup_replace_vars(), pullup_replace_vars_subquery(), and ReplaceVarsFromTargetList().

 {
     Node       *result;
     replace_rte_variables_context context;
 
     context.callback = callback;
     context.callback_arg = callback_arg;
     context.target_varno = target_varno;
     context.sublevels_up = sublevels_up;
 
     /*
      * We try to initialize inserted_sublink to true if there is no need to
      * detect new sublinks because the query already has some.
      */
     if (node && IsA(node, Query))
         context.inserted_sublink = ((Query *) node)->hasSubLinks;
     else if (outer_hasSubLinks)
         context.inserted_sublink = *outer_hasSubLinks;
     else
         context.inserted_sublink = false;
 
     /*
      * Must be prepared to start with a Query or a bare expression tree; if
      * it's a Query, we don't want to increment sublevels_up.
      */
     result = query_or_expression_tree_mutator(node,
                                               replace_rte_variables_mutator,
                                               (void *) &context,
                                               0);
 
     if (context.inserted_sublink)
     {
         if (result && IsA(result, Query))
             ((Query *) result)->hasSubLinks = true;
         else if (outer_hasSubLinks)
             *outer_hasSubLinks = true;
         else
             elog(ERROR, "replace_rte_variables inserted a SubLink, but has noplace to record it");
     }
 
     return result;
 }

Node* replace_rte_variables_mutator	(	Node *	node,
		replace_rte_variables_context *	context
	)

Definition at line 1131 of file rewriteManip.c.

References replace_rte_variables_context::callback, checkExprHasSubLink(), CurrentOfExpr::cvarno, ereport, errcode(), errmsg(), ERROR, expression_tree_mutator(), Query::hasSubLinks, replace_rte_variables_context::inserted_sublink, IsA, NULL, query_tree_mutator(), replace_rte_variables_mutator(), replace_rte_variables_context::sublevels_up, replace_rte_variables_context::target_varno, Var::varlevelsup, and Var::varno.

Referenced by pullup_replace_vars_callback(), replace_rte_variables(), replace_rte_variables_mutator(), and ReplaceVarsFromTargetList_callback().

 {
     if (node == NULL)
         return NULL;
     if (IsA(node, Var))
     {
         Var        *var = (Var *) node;
 
         if (var->varno == context->target_varno &&
             var->varlevelsup == context->sublevels_up)
         {
             /* Found a matching variable, make the substitution */
             Node       *newnode;
 
             newnode = (*context->callback) (var, context);
             /* Detect if we are adding a sublink to query */
             if (!context->inserted_sublink)
                 context->inserted_sublink = checkExprHasSubLink(newnode);
             return newnode;
         }
         /* otherwise fall through to copy the var normally */
     }
     else if (IsA(node, CurrentOfExpr))
     {
         CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
 
         if (cexpr->cvarno == context->target_varno &&
             context->sublevels_up == 0)
         {
             /*
              * We get here if a WHERE CURRENT OF expression turns out to apply
              * to a view.  Someday we might be able to translate the
              * expression to apply to an underlying table of the view, but
              * right now it's not implemented.
              */
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("WHERE CURRENT OF on a view is not implemented")));
         }
         /* otherwise fall through to copy the expr normally */
     }
     else if (IsA(node, Query))
     {
         /* Recurse into RTE subquery or not-yet-planned sublink subquery */
         Query      *newnode;
         bool        save_inserted_sublink;
 
         context->sublevels_up++;
         save_inserted_sublink = context->inserted_sublink;
         context->inserted_sublink = ((Query *) node)->hasSubLinks;
         newnode = query_tree_mutator((Query *) node,
                                      replace_rte_variables_mutator,
                                      (void *) context,
                                      0);
         newnode->hasSubLinks |= context->inserted_sublink;
         context->inserted_sublink = save_inserted_sublink;
         context->sublevels_up--;
         return (Node *) newnode;
     }
     return expression_tree_mutator(node, replace_rte_variables_mutator,
                                    (void *) context);
 }

Node* ReplaceVarsFromTargetList	(	Node *	node,
		int	target_varno,
		int	sublevels_up,
		RangeTblEntry *	target_rte,
		List *	targetlist,
		ReplaceVarsNoMatchOption	nomatch_option,
		int	nomatch_varno,
		bool *	outer_hasSubLinks
	)

Definition at line 1470 of file rewriteManip.c.

References ReplaceVarsFromTargetList_context::nomatch_option, ReplaceVarsFromTargetList_context::nomatch_varno, replace_rte_variables(), ReplaceVarsFromTargetList_callback(), ReplaceVarsFromTargetList_context::target_rte, and ReplaceVarsFromTargetList_context::targetlist.

Referenced by CopyAndAddInvertedQual(), rewriteRuleAction(), rewriteTargetView(), and subquery_push_qual().

 {
     ReplaceVarsFromTargetList_context context;
 
     context.target_rte = target_rte;
     context.targetlist = targetlist;
     context.nomatch_option = nomatch_option;
     context.nomatch_varno = nomatch_varno;
 
     return replace_rte_variables(node, target_varno, sublevels_up,
                                  ReplaceVarsFromTargetList_callback,
                                  (void *) &context,
                                  outer_hasSubLinks);
 }

static Node* ReplaceVarsFromTargetList_callback	(	Var *	var,
		replace_rte_variables_context *	context
	)

static

Definition at line 1366 of file rewriteManip.c.

References RowExpr::args, replace_rte_variables_context::callback_arg, COERCE_IMPLICIT_CAST, coerce_to_domain(), RowExpr::colnames, contains_multiexpr_param(), copyObject, elog, ereport, errcode(), errmsg(), ERROR, expandRTE(), get_tle_by_resno(), IncrementVarSublevelsUp(), InvalidAttrNumber, InvalidOid, Var::location, RowExpr::location, makeNode, makeNullConst(), ReplaceVarsFromTargetList_context::nomatch_option, ReplaceVarsFromTargetList_context::nomatch_varno, NULL, RECORDOID, replace_rte_variables_mutator(), REPLACEVARS_CHANGE_VARNO, REPLACEVARS_REPORT_ERROR, REPLACEVARS_SUBSTITUTE_NULL, RowExpr::row_format, RowExpr::row_typeid, ReplaceVarsFromTargetList_context::target_rte, ReplaceVarsFromTargetList_context::targetlist, Var::varattno, Var::varcollid, Var::varlevelsup, Var::varno, Var::varnoold, Var::vartype, and Var::vartypmod.

Referenced by ReplaceVarsFromTargetList().

 {
     ReplaceVarsFromTargetList_context *rcon = (ReplaceVarsFromTargetList_context *) context->callback_arg;
     TargetEntry *tle;
 
     if (var->varattno == InvalidAttrNumber)
     {
         /* Must expand whole-tuple reference into RowExpr */
         RowExpr    *rowexpr;
         List       *colnames;
         List       *fields;
 
         /*
          * If generating an expansion for a var of a named rowtype (ie, this
          * is a plain relation RTE), then we must include dummy items for
          * dropped columns.  If the var is RECORD (ie, this is a JOIN), then
          * omit dropped columns.  Either way, attach column names to the
          * RowExpr for use of ruleutils.c.
          */
         expandRTE(rcon->target_rte,
                   var->varno, var->varlevelsup, var->location,
                   (var->vartype != RECORDOID),
                   &colnames, &fields);
         /* Adjust the generated per-field Vars... */
         fields = (List *) replace_rte_variables_mutator((Node *) fields,
                                                         context);
         rowexpr = makeNode(RowExpr);
         rowexpr->args = fields;
         rowexpr->row_typeid = var->vartype;
         rowexpr->row_format = COERCE_IMPLICIT_CAST;
         rowexpr->colnames = colnames;
         rowexpr->location = var->location;
 
         return (Node *) rowexpr;
     }
 
     /* Normal case referencing one targetlist element */
     tle = get_tle_by_resno(rcon->targetlist, var->varattno);
 
     if (tle == NULL || tle->resjunk)
     {
         /* Failed to find column in targetlist */
         switch (rcon->nomatch_option)
         {
             case REPLACEVARS_REPORT_ERROR:
                 /* fall through, throw error below */
                 break;
 
             case REPLACEVARS_CHANGE_VARNO:
                 var = (Var *) copyObject(var);
                 var->varno = rcon->nomatch_varno;
                 var->varnoold = rcon->nomatch_varno;
                 return (Node *) var;
 
             case REPLACEVARS_SUBSTITUTE_NULL:
 
                 /*
                  * If Var is of domain type, we should add a CoerceToDomain
                  * node, in case there is a NOT NULL domain constraint.
                  */
                 return coerce_to_domain((Node *) makeNullConst(var->vartype,
                                                                var->vartypmod,
                                                                var->varcollid),
                                         InvalidOid, -1,
                                         var->vartype,
                                         COERCE_IMPLICIT_CAST,
                                         -1,
                                         false,
                                         false);
         }
         elog(ERROR, "could not find replacement targetlist entry for attno %d",
              var->varattno);
         return NULL;            /* keep compiler quiet */
     }
     else
     {
         /* Make a copy of the tlist item to return */
         Expr       *newnode = copyObject(tle->expr);
 
         /* Must adjust varlevelsup if tlist item is from higher query */
         if (var->varlevelsup > 0)
             IncrementVarSublevelsUp((Node *) newnode, var->varlevelsup, 0);
 
         /*
          * Check to see if the tlist item contains a PARAM_MULTIEXPR Param,
          * and throw error if so.  This case could only happen when expanding
          * an ON UPDATE rule's NEW variable and the referenced tlist item in
          * the original UPDATE command is part of a multiple assignment. There
          * seems no practical way to handle such cases without multiple
          * evaluation of the multiple assignment's sub-select, which would
          * create semantic oddities that users of rules would probably prefer
          * not to cope with.  So treat it as an unimplemented feature.
          */
         if (contains_multiexpr_param((Node *) newnode, NULL))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("NEW variables in ON UPDATE rules cannot reference columns that are part of a multiple assignment in the subject UPDATE command")));
 
         return (Node *) newnode;
     }
 }

Data Structures

Functions

Function Documentation