PostgreSQL Source Code git master
rewriteManip.c File Reference
#include "postgres.h"
#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/pathnodes.h"
#include "nodes/plannodes.h"
#include "parser/parse_coerce.h"
#include "parser/parse_relation.h"
#include "parser/parsetree.h"
#include "rewrite/rewriteManip.h"
#include "utils/lsyscache.h"
Include dependency graph for rewriteManip.c:

Go to the source code of this file.

Data Structures

struct  contain_aggs_of_level_context
 
struct  locate_agg_of_level_context
 
struct  locate_windowfunc_context
 
struct  add_nulling_relids_context
 
struct  remove_nulling_relids_context
 
struct  OffsetVarNodes_context
 
struct  IncrementVarSublevelsUp_context
 
struct  SetVarReturningType_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 Nodeadd_nulling_relids_mutator (Node *node, add_nulling_relids_context *context)
 
static Noderemove_nulling_relids_mutator (Node *node, remove_nulling_relids_context *context)
 
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)
 
void CombineRangeTables (List **dst_rtable, List **dst_perminfos, List *src_rtable, List *src_perminfos)
 
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 ChangeVarNodesExtended (Node *node, int rt_index, int new_index, int sublevels_up, ChangeVarNodes_callback callback)
 
void ChangeVarNodes (Node *node, int rt_index, int new_index, int sublevels_up)
 
bool ChangeVarNodesWalkExpression (Node *node, ChangeVarNodes_context *context)
 
Relids adjust_relid_set (Relids relids, int oldrelid, int newrelid)
 
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 SetVarReturningType_walker (Node *node, SetVarReturningType_context *context)
 
static void SetVarReturningType (Node *node, int result_relation, int sublevels_up, VarReturningType returning_type)
 
static bool rangeTableEntry_used_walker (Node *node, rangeTableEntry_used_context *context)
 
bool rangeTableEntry_used (Node *node, int rt_index, int sublevels_up)
 
QuerygetInsertSelectQuery (Query *parsetree, Query ***subquery_ptr)
 
void AddQual (Query *parsetree, Node *qual)
 
void AddInvertedQual (Query *parsetree, Node *qual)
 
Nodeadd_nulling_relids (Node *node, const Bitmapset *target_relids, const Bitmapset *added_relids)
 
Noderemove_nulling_relids (Node *node, const Bitmapset *removable_relids, const Bitmapset *except_relids)
 
Nodereplace_rte_variables (Node *node, int target_varno, int sublevels_up, replace_rte_variables_callback callback, void *callback_arg, bool *outer_hasSubLinks)
 
Nodereplace_rte_variables_mutator (Node *node, replace_rte_variables_context *context)
 
static Nodemap_variable_attnos_mutator (Node *node, map_variable_attnos_context *context)
 
Nodemap_variable_attnos (Node *node, int target_varno, int sublevels_up, const AttrMap *attno_map, Oid to_rowtype, bool *found_whole_row)
 
static NodeReplaceVarsFromTargetList_callback (Var *var, replace_rte_variables_context *context)
 
NodeReplaceVarFromTargetList (Var *var, RangeTblEntry *target_rte, List *targetlist, int result_relation, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno)
 
NodeReplaceVarsFromTargetList (Node *node, int target_varno, int sublevels_up, RangeTblEntry *target_rte, List *targetlist, int result_relation, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno, bool *outer_hasSubLinks)
 

Function Documentation

◆ add_nulling_relids()

Node * add_nulling_relids ( Node node,
const Bitmapset target_relids,
const Bitmapset added_relids 
)

Definition at line 1243 of file rewriteManip.c.

1246{
1248
1249 context.target_relids = target_relids;
1250 context.added_relids = added_relids;
1251 context.sublevels_up = 0;
1254 &context,
1255 0);
1256}
#define query_or_expression_tree_mutator(n, m, c, f)
Definition: nodeFuncs.h:173
static Node * add_nulling_relids_mutator(Node *node, add_nulling_relids_context *context)
const Bitmapset * target_relids
Definition: rewriteManip.c:46
const Bitmapset * added_relids
Definition: rewriteManip.c:47

References add_nulling_relids_mutator(), add_nulling_relids_context::added_relids, query_or_expression_tree_mutator, add_nulling_relids_context::sublevels_up, and add_nulling_relids_context::target_relids.

Referenced by deconstruct_distribute_oj_quals(), mark_nullable_by_grouping(), pullup_replace_vars_callback(), and transform_MERGE_to_join().

◆ add_nulling_relids_mutator()

static Node * add_nulling_relids_mutator ( Node node,
add_nulling_relids_context context 
)
static

Definition at line 1259 of file rewriteManip.c.

1261{
1262 if (node == NULL)
1263 return NULL;
1264 if (IsA(node, Var))
1265 {
1266 Var *var = (Var *) node;
1267
1268 if (var->varlevelsup == context->sublevels_up &&
1269 (context->target_relids == NULL ||
1270 bms_is_member(var->varno, context->target_relids)))
1271 {
1272 Relids newnullingrels = bms_union(var->varnullingrels,
1273 context->added_relids);
1274
1275 /* Copy the Var ... */
1276 var = copyObject(var);
1277 /* ... and replace the copy's varnullingrels field */
1278 var->varnullingrels = newnullingrels;
1279 return (Node *) var;
1280 }
1281 /* Otherwise fall through to copy the Var normally */
1282 }
1283 else if (IsA(node, PlaceHolderVar))
1284 {
1285 PlaceHolderVar *phv = (PlaceHolderVar *) node;
1286
1287 if (phv->phlevelsup == context->sublevels_up &&
1288 (context->target_relids == NULL ||
1289 bms_overlap(phv->phrels, context->target_relids)))
1290 {
1291 Relids newnullingrels = bms_union(phv->phnullingrels,
1292 context->added_relids);
1293
1294 /*
1295 * We don't modify the contents of the PHV's expression, only add
1296 * to phnullingrels. This corresponds to assuming that the PHV
1297 * will be evaluated at the same level as before, then perhaps be
1298 * nulled as it bubbles up. Hence, just flat-copy the node ...
1299 */
1300 phv = makeNode(PlaceHolderVar);
1301 memcpy(phv, node, sizeof(PlaceHolderVar));
1302 /* ... and replace the copy's phnullingrels field */
1303 phv->phnullingrels = newnullingrels;
1304 return (Node *) phv;
1305 }
1306 /* Otherwise fall through to copy the PlaceHolderVar normally */
1307 }
1308 else if (IsA(node, Query))
1309 {
1310 /* Recurse into RTE or sublink subquery */
1311 Query *newnode;
1312
1313 context->sublevels_up++;
1314 newnode = query_tree_mutator((Query *) node,
1316 context,
1317 0);
1318 context->sublevels_up--;
1319 return (Node *) newnode;
1320 }
1322}
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:251
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:582
#define expression_tree_mutator(n, m, c)
Definition: nodeFuncs.h:155
#define query_tree_mutator(q, m, c, f)
Definition: nodeFuncs.h:160
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
#define copyObject(obj)
Definition: nodes.h:230
#define makeNode(_type_)
Definition: nodes.h:161
Definition: nodes.h:135
Relids phnullingrels
Definition: pathnodes.h:2935
Index phlevelsup
Definition: pathnodes.h:2941
Definition: primnodes.h:262
int varno
Definition: primnodes.h:269
Index varlevelsup
Definition: primnodes.h:294

References add_nulling_relids_mutator(), add_nulling_relids_context::added_relids, bms_is_member(), bms_overlap(), bms_union(), copyObject, expression_tree_mutator, IsA, makeNode, PlaceHolderVar::phlevelsup, PlaceHolderVar::phnullingrels, query_tree_mutator, add_nulling_relids_context::sublevels_up, add_nulling_relids_context::target_relids, Var::varlevelsup, and Var::varno.

Referenced by add_nulling_relids(), and add_nulling_relids_mutator().

◆ AddInvertedQual()

void AddInvertedQual ( Query parsetree,
Node qual 
)

Definition at line 1219 of file rewriteManip.c.

1220{
1221 BooleanTest *invqual;
1222
1223 if (qual == NULL)
1224 return;
1225
1226 /* Need not copy input qual, because AddQual will... */
1227 invqual = makeNode(BooleanTest);
1228 invqual->arg = (Expr *) qual;
1229 invqual->booltesttype = IS_NOT_TRUE;
1230 invqual->location = -1;
1231
1232 AddQual(parsetree, (Node *) invqual);
1233}
@ IS_NOT_TRUE
Definition: primnodes.h:1981
void AddQual(Query *parsetree, Node *qual)
ParseLoc location
Definition: primnodes.h:1989
BoolTestType booltesttype
Definition: primnodes.h:1988
Expr * arg
Definition: primnodes.h:1987

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

Referenced by CopyAndAddInvertedQual().

◆ AddQual()

void AddQual ( Query parsetree,
Node qual 
)

Definition at line 1151 of file rewriteManip.c.

1152{
1153 Node *copy;
1154
1155 if (qual == NULL)
1156 return;
1157
1158 if (parsetree->commandType == CMD_UTILITY)
1159 {
1160 /*
1161 * There's noplace to put the qual on a utility statement.
1162 *
1163 * If it's a NOTIFY, silently ignore the qual; this means that the
1164 * NOTIFY will execute, whether or not there are any qualifying rows.
1165 * While clearly wrong, this is much more useful than refusing to
1166 * execute the rule at all, and extra NOTIFY events are harmless for
1167 * typical uses of NOTIFY.
1168 *
1169 * If it isn't a NOTIFY, error out, since unconditional execution of
1170 * other utility stmts is unlikely to be wanted. (This case is not
1171 * currently allowed anyway, but keep the test for safety.)
1172 */
1173 if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
1174 return;
1175 else
1176 ereport(ERROR,
1177 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1178 errmsg("conditional utility statements are not implemented")));
1179 }
1180
1181 if (parsetree->setOperations != NULL)
1182 {
1183 /*
1184 * There's noplace to put the qual on a setop statement, either. (This
1185 * could be fixed, but right now the planner simply ignores any qual
1186 * condition on a setop query.)
1187 */
1188 ereport(ERROR,
1189 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1190 errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
1191 }
1192
1193 /* INTERSECT wants the original, but we need to copy - Jan */
1194 copy = copyObject(qual);
1195
1196 parsetree->jointree->quals = make_and_qual(parsetree->jointree->quals,
1197 copy);
1198
1199 /*
1200 * We had better not have stuck an aggregate into the WHERE clause.
1201 */
1202 Assert(!contain_aggs_of_level(copy, 0));
1203
1204 /*
1205 * Make sure query is marked correctly if added qual has sublinks. Need
1206 * not search qual when query is already marked.
1207 */
1208 if (!parsetree->hasSubLinks)
1209 parsetree->hasSubLinks = checkExprHasSubLink(copy);
1210}
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
Assert(PointerIsAligned(start, uint64))
Node * make_and_qual(Node *qual1, Node *qual2)
Definition: makefuncs.c:780
@ CMD_UTILITY
Definition: nodes.h:276
bool checkExprHasSubLink(Node *node)
Definition: rewriteManip.c:292
bool contain_aggs_of_level(Node *node, int levelsup)
Definition: rewriteManip.c:85
Node * quals
Definition: primnodes.h:2338
FromExpr * jointree
Definition: parsenodes.h:177
Node * setOperations
Definition: parsenodes.h:230
CmdType commandType
Definition: parsenodes.h:121
Node * utilityStmt
Definition: parsenodes.h:136

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

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

◆ adjust_relid_set()

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

Definition at line 764 of file rewriteManip.c.

765{
766 if (!IS_SPECIAL_VARNO(oldrelid) && bms_is_member(oldrelid, relids))
767 {
768 /* Ensure we have a modifiable copy */
769 relids = bms_copy(relids);
770 /* Remove old, add new */
771 relids = bms_del_member(relids, oldrelid);
772 if (!IS_SPECIAL_VARNO(newrelid))
773 relids = bms_add_member(relids, newrelid);
774 }
775 return relids;
776}
Bitmapset * bms_del_member(Bitmapset *a, int x)
Definition: bitmapset.c:868
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
Bitmapset * bms_copy(const Bitmapset *a)
Definition: bitmapset.c:122
#define IS_SPECIAL_VARNO(varno)
Definition: primnodes.h:247

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

Referenced by ChangeVarNodes_walker(), remove_rel_from_eclass(), remove_rel_from_query(), remove_self_join_rel(), replace_relid_callback(), and update_eclasses().

◆ ChangeVarNodes()

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

◆ ChangeVarNodes_walker()

static bool ChangeVarNodes_walker ( Node node,
ChangeVarNodes_context context 
)
static

Definition at line 554 of file rewriteManip.c.

555{
556 if (node == NULL)
557 return false;
558
559 if (context->callback && context->callback(node, context))
560 return false;
561
562 if (IsA(node, Var))
563 {
564 Var *var = (Var *) node;
565
566 if (var->varlevelsup == context->sublevels_up)
567 {
568 if (var->varno == context->rt_index)
569 var->varno = context->new_index;
570 var->varnullingrels = adjust_relid_set(var->varnullingrels,
571 context->rt_index,
572 context->new_index);
573 if (var->varnosyn == context->rt_index)
574 var->varnosyn = context->new_index;
575 }
576 return false;
577 }
578 if (IsA(node, CurrentOfExpr))
579 {
580 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
581
582 if (context->sublevels_up == 0 &&
583 cexpr->cvarno == context->rt_index)
584 cexpr->cvarno = context->new_index;
585 return false;
586 }
587 if (IsA(node, RangeTblRef))
588 {
589 RangeTblRef *rtr = (RangeTblRef *) node;
590
591 if (context->sublevels_up == 0 &&
592 rtr->rtindex == context->rt_index)
593 rtr->rtindex = context->new_index;
594 /* the subquery itself is visited separately */
595 return false;
596 }
597 if (IsA(node, JoinExpr))
598 {
599 JoinExpr *j = (JoinExpr *) node;
600
601 if (context->sublevels_up == 0 &&
602 j->rtindex == context->rt_index)
603 j->rtindex = context->new_index;
604 /* fall through to examine children */
605 }
606 if (IsA(node, PlaceHolderVar))
607 {
608 PlaceHolderVar *phv = (PlaceHolderVar *) node;
609
610 if (phv->phlevelsup == context->sublevels_up)
611 {
612 phv->phrels = adjust_relid_set(phv->phrels,
613 context->rt_index,
614 context->new_index);
616 context->rt_index,
617 context->new_index);
618 }
619 /* fall through to examine children */
620 }
621 if (IsA(node, PlanRowMark))
622 {
623 PlanRowMark *rowmark = (PlanRowMark *) node;
624
625 if (context->sublevels_up == 0)
626 {
627 if (rowmark->rti == context->rt_index)
628 rowmark->rti = context->new_index;
629 if (rowmark->prti == context->rt_index)
630 rowmark->prti = context->new_index;
631 }
632 return false;
633 }
634 if (IsA(node, AppendRelInfo))
635 {
636 AppendRelInfo *appinfo = (AppendRelInfo *) node;
637
638 if (context->sublevels_up == 0)
639 {
640 if (appinfo->parent_relid == context->rt_index)
641 appinfo->parent_relid = context->new_index;
642 if (appinfo->child_relid == context->rt_index)
643 appinfo->child_relid = context->new_index;
644 }
645 /* fall through to examine children */
646 }
647 /* Shouldn't need to handle other planner auxiliary nodes here */
648 Assert(!IsA(node, SpecialJoinInfo));
649 Assert(!IsA(node, PlaceHolderInfo));
650 Assert(!IsA(node, MinMaxAggInfo));
651
652 if (IsA(node, Query))
653 {
654 /* Recurse into subselects */
655 bool result;
656
657 context->sublevels_up++;
659 context, 0);
660 context->sublevels_up--;
661 return result;
662 }
663 return expression_tree_walker(node, ChangeVarNodes_walker, context);
664}
int j
Definition: isn.c:78
#define query_tree_walker(q, w, c, f)
Definition: nodeFuncs.h:158
#define expression_tree_walker(n, w, c)
Definition: nodeFuncs.h:153
Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid)
Definition: rewriteManip.c:764
static bool ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
Definition: rewriteManip.c:554
Index child_relid
Definition: pathnodes.h:3114
Index parent_relid
Definition: pathnodes.h:3113
ChangeVarNodes_callback callback
Definition: rewriteManip.h:54
Index prti
Definition: plannodes.h:1542

References adjust_relid_set(), Assert(), ChangeVarNodes_context::callback, ChangeVarNodes_walker(), AppendRelInfo::child_relid, CurrentOfExpr::cvarno, expression_tree_walker, IsA, j, ChangeVarNodes_context::new_index, AppendRelInfo::parent_relid, PlaceHolderVar::phlevelsup, PlaceHolderVar::phnullingrels, PlanRowMark::prti, query_tree_walker, ChangeVarNodes_context::rt_index, PlanRowMark::rti, RangeTblRef::rtindex, ChangeVarNodes_context::sublevels_up, Var::varlevelsup, and Var::varno.

Referenced by ChangeVarNodes_walker(), ChangeVarNodesExtended(), and ChangeVarNodesWalkExpression().

◆ ChangeVarNodesExtended()

void ChangeVarNodesExtended ( Node node,
int  rt_index,
int  new_index,
int  sublevels_up,
ChangeVarNodes_callback  callback 
)

Definition at line 680 of file rewriteManip.c.

682{
684
685 context.rt_index = rt_index;
686 context.new_index = new_index;
687 context.sublevels_up = sublevels_up;
688 context.callback = callback;
689
690 /*
691 * Must be prepared to start with a Query or a bare expression tree; if
692 * it's a Query, go straight to query_tree_walker to make sure that
693 * sublevels_up doesn't get incremented prematurely.
694 */
695 if (node && IsA(node, Query))
696 {
697 Query *qry = (Query *) node;
698
699 /*
700 * If we are starting at a Query, and sublevels_up is zero, then we
701 * must also fix rangetable indexes in the Query itself --- namely
702 * resultRelation, mergeTargetRelation, exclRelIndex and rowMarks
703 * entries. sublevels_up cannot be zero when recursing into a
704 * subquery, so there's no need to have the same logic inside
705 * ChangeVarNodes_walker.
706 */
707 if (sublevels_up == 0)
708 {
709 ListCell *l;
710
711 if (qry->resultRelation == rt_index)
712 qry->resultRelation = new_index;
713
714 if (qry->mergeTargetRelation == rt_index)
715 qry->mergeTargetRelation = new_index;
716
717 /* this is unlikely to ever be used, but ... */
718 if (qry->onConflict && qry->onConflict->exclRelIndex == rt_index)
719 qry->onConflict->exclRelIndex = new_index;
720
721 foreach(l, qry->rowMarks)
722 {
724
725 if (rc->rti == rt_index)
726 rc->rti = new_index;
727 }
728 }
729 query_tree_walker(qry, ChangeVarNodes_walker, &context, 0);
730 }
731 else
732 ChangeVarNodes_walker(node, &context);
733}
#define lfirst(lc)
Definition: pg_list.h:172
List * rowMarks
Definition: parsenodes.h:228
OnConflictExpr * onConflict
Definition: parsenodes.h:198
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46

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

Referenced by ChangeVarNodes(), match_unique_clauses(), remove_rel_from_eclass(), remove_rel_from_query(), remove_self_join_rel(), split_selfjoin_quals(), and update_eclasses().

◆ ChangeVarNodesWalkExpression()

bool ChangeVarNodesWalkExpression ( Node node,
ChangeVarNodes_context context 
)

Definition at line 747 of file rewriteManip.c.

748{
749 return expression_tree_walker(node,
751 (void *) context);
752}

References ChangeVarNodes_walker(), and expression_tree_walker.

Referenced by replace_relid_callback().

◆ checkExprHasSubLink()

bool checkExprHasSubLink ( Node node)

Definition at line 292 of file rewriteManip.c.

293{
294 /*
295 * If a Query is passed, examine it --- but we should not recurse into
296 * sub-Queries that are in its rangetable or CTE list.
297 */
300 NULL,
302}
#define query_or_expression_tree_walker(n, w, c, f)
Definition: nodeFuncs.h:171
#define QTW_IGNORE_RC_SUBQUERIES
Definition: nodeFuncs.h:24
static bool checkExprHasSubLink_walker(Node *node, void *context)
Definition: rewriteManip.c:305

References checkExprHasSubLink_walker(), QTW_IGNORE_RC_SUBQUERIES, and query_or_expression_tree_walker.

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

◆ checkExprHasSubLink_walker()

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

Definition at line 305 of file rewriteManip.c.

306{
307 if (node == NULL)
308 return false;
309 if (IsA(node, SubLink))
310 return true; /* abort the tree traversal and return true */
312}

References checkExprHasSubLink_walker(), expression_tree_walker, and IsA.

Referenced by checkExprHasSubLink(), and checkExprHasSubLink_walker().

◆ CombineRangeTables()

void CombineRangeTables ( List **  dst_rtable,
List **  dst_perminfos,
List src_rtable,
List src_perminfos 
)

Definition at line 347 of file rewriteManip.c.

349{
350 ListCell *l;
351 int offset = list_length(*dst_perminfos);
352
353 if (offset > 0)
354 {
355 foreach(l, src_rtable)
356 {
358
359 if (rte->perminfoindex > 0)
360 rte->perminfoindex += offset;
361 }
362 }
363
364 *dst_perminfos = list_concat(*dst_perminfos, src_perminfos);
365 *dst_rtable = list_concat(*dst_rtable, src_rtable);
366}
List * list_concat(List *list1, const List *list2)
Definition: list.c:561
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static int list_length(const List *l)
Definition: pg_list.h:152

References lfirst_node, list_concat(), and list_length().

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

◆ contain_aggs_of_level()

bool contain_aggs_of_level ( Node node,
int  levelsup 
)

Definition at line 85 of file rewriteManip.c.

86{
88
89 context.sublevels_up = levelsup;
90
91 /*
92 * Must be prepared to start with a Query or a bare expression tree; if
93 * it's a Query, we don't want to increment sublevels_up.
94 */
97 &context,
98 0);
99}
static bool contain_aggs_of_level_walker(Node *node, contain_aggs_of_level_context *context)
Definition: rewriteManip.c:102

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_walker()

static bool contain_aggs_of_level_walker ( Node node,
contain_aggs_of_level_context context 
)
static

Definition at line 102 of file rewriteManip.c.

104{
105 if (node == NULL)
106 return false;
107 if (IsA(node, Aggref))
108 {
109 if (((Aggref *) node)->agglevelsup == context->sublevels_up)
110 return true; /* abort the tree traversal and return true */
111 /* else fall through to examine argument */
112 }
113 if (IsA(node, GroupingFunc))
114 {
115 if (((GroupingFunc *) node)->agglevelsup == context->sublevels_up)
116 return true;
117 /* else fall through to examine argument */
118 }
119 if (IsA(node, Query))
120 {
121 /* Recurse into subselects */
122 bool result;
123
124 context->sublevels_up++;
125 result = query_tree_walker((Query *) node,
127 context, 0);
128 context->sublevels_up--;
129 return result;
130 }
132 context);
133}

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

Referenced by contain_aggs_of_level(), and contain_aggs_of_level_walker().

◆ contain_windowfuncs()

bool contain_windowfuncs ( Node node)

Definition at line 214 of file rewriteManip.c.

215{
216 /*
217 * Must be prepared to start with a Query or a bare expression tree; if
218 * it's a Query, we don't want to increment sublevels_up.
219 */
222 NULL,
223 0);
224}
static bool contain_windowfuncs_walker(Node *node, void *context)
Definition: rewriteManip.c:227

References contain_windowfuncs_walker(), and query_or_expression_tree_walker.

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

◆ contain_windowfuncs_walker()

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

Definition at line 227 of file rewriteManip.c.

228{
229 if (node == NULL)
230 return false;
231 if (IsA(node, WindowFunc))
232 return true; /* abort the tree traversal and return true */
233 /* Mustn't recurse into subselects */
235}

References contain_windowfuncs_walker(), expression_tree_walker, and IsA.

Referenced by contain_windowfuncs(), and contain_windowfuncs_walker().

◆ contains_multiexpr_param()

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

Definition at line 321 of file rewriteManip.c.

322{
323 if (node == NULL)
324 return false;
325 if (IsA(node, Param))
326 {
327 if (((Param *) node)->paramkind == PARAM_MULTIEXPR)
328 return true; /* abort the tree traversal and return true */
329 return false;
330 }
332}
@ PARAM_MULTIEXPR
Definition: primnodes.h:387
static bool contains_multiexpr_param(Node *node, void *context)
Definition: rewriteManip.c:321

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

Referenced by contains_multiexpr_param(), and ReplaceVarFromTargetList().

◆ getInsertSelectQuery()

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

Definition at line 1093 of file rewriteManip.c.

1094{
1095 Query *selectquery;
1096 RangeTblEntry *selectrte;
1097 RangeTblRef *rtr;
1098
1099 if (subquery_ptr)
1100 *subquery_ptr = NULL;
1101
1102 if (parsetree == NULL)
1103 return parsetree;
1104 if (parsetree->commandType != CMD_INSERT)
1105 return parsetree;
1106
1107 /*
1108 * Currently, this is ONLY applied to rule-action queries, and so we
1109 * expect to find the OLD and NEW placeholder entries in the given query.
1110 * If they're not there, it must be an INSERT/SELECT in which they've been
1111 * pushed down to the SELECT.
1112 */
1113 if (list_length(parsetree->rtable) >= 2 &&
1114 strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->aliasname,
1115 "old") == 0 &&
1116 strcmp(rt_fetch(PRS2_NEW_VARNO, parsetree->rtable)->eref->aliasname,
1117 "new") == 0)
1118 return parsetree;
1119 Assert(parsetree->jointree && IsA(parsetree->jointree, FromExpr));
1120 if (list_length(parsetree->jointree->fromlist) != 1)
1121 elog(ERROR, "expected to find SELECT subquery");
1122 rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
1123 if (!IsA(rtr, RangeTblRef))
1124 elog(ERROR, "expected to find SELECT subquery");
1125 selectrte = rt_fetch(rtr->rtindex, parsetree->rtable);
1126 if (!(selectrte->rtekind == RTE_SUBQUERY &&
1127 selectrte->subquery &&
1128 IsA(selectrte->subquery, Query) &&
1129 selectrte->subquery->commandType == CMD_SELECT))
1130 elog(ERROR, "expected to find SELECT subquery");
1131 selectquery = selectrte->subquery;
1132 if (list_length(selectquery->rtable) >= 2 &&
1133 strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->aliasname,
1134 "old") == 0 &&
1135 strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->aliasname,
1136 "new") == 0)
1137 {
1138 if (subquery_ptr)
1139 *subquery_ptr = &(selectrte->subquery);
1140 return selectquery;
1141 }
1142 elog(ERROR, "could not find rule placeholders");
1143 return NULL; /* not reached */
1144}
#define elog(elevel,...)
Definition: elog.h:225
@ CMD_INSERT
Definition: nodes.h:273
@ CMD_SELECT
Definition: nodes.h:271
@ RTE_SUBQUERY
Definition: parsenodes.h:1027
#define rt_fetch(rangetable_index, rangetable)
Definition: parsetree.h:31
#define linitial(l)
Definition: pg_list.h:178
#define PRS2_OLD_VARNO
Definition: primnodes.h:250
#define PRS2_NEW_VARNO
Definition: primnodes.h:251
List * fromlist
Definition: primnodes.h:2337
List * rtable
Definition: parsenodes.h:170
Query * subquery
Definition: parsenodes.h:1118
RTEKind rtekind
Definition: parsenodes.h:1061

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

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

◆ IncrementVarSublevelsUp()

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

Definition at line 884 of file rewriteManip.c.

886{
888
889 context.delta_sublevels_up = delta_sublevels_up;
890 context.min_sublevels_up = min_sublevels_up;
891
892 /*
893 * Must be prepared to start with a Query or a bare expression tree; if
894 * it's a Query, we don't want to increment sublevels_up.
895 */
898 &context,
900}
#define QTW_EXAMINE_RTES_BEFORE
Definition: nodeFuncs.h:27
static bool IncrementVarSublevelsUp_walker(Node *node, IncrementVarSublevelsUp_context *context)
Definition: rewriteManip.c:804

References IncrementVarSublevelsUp_context::delta_sublevels_up, IncrementVarSublevelsUp_walker(), IncrementVarSublevelsUp_context::min_sublevels_up, QTW_EXAMINE_RTES_BEFORE, 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_group_exprs_mutator(), flatten_join_alias_vars_mutator(), inline_cte_walker(), pull_up_simple_subquery(), pullup_replace_vars_callback(), replace_outer_agg(), replace_outer_grouping(), replace_outer_returning(), ReplaceVarsFromTargetList_callback(), rewriteSearchAndCycle(), and substitute_actual_srf_parameters_mutator().

◆ IncrementVarSublevelsUp_rtable()

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

Definition at line 907 of file rewriteManip.c.

909{
911
912 context.delta_sublevels_up = delta_sublevels_up;
913 context.min_sublevels_up = min_sublevels_up;
914
915 range_table_walker(rtable,
917 &context,
919}
#define range_table_walker(rt, w, c, f)
Definition: nodeFuncs.h:163

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

Referenced by pull_up_simple_union_all().

◆ IncrementVarSublevelsUp_walker()

static bool IncrementVarSublevelsUp_walker ( Node node,
IncrementVarSublevelsUp_context context 
)
static

Definition at line 804 of file rewriteManip.c.

806{
807 if (node == NULL)
808 return false;
809 if (IsA(node, Var))
810 {
811 Var *var = (Var *) node;
812
813 if (var->varlevelsup >= context->min_sublevels_up)
814 var->varlevelsup += context->delta_sublevels_up;
815 return false; /* done here */
816 }
817 if (IsA(node, CurrentOfExpr))
818 {
819 /* this should not happen */
820 if (context->min_sublevels_up == 0)
821 elog(ERROR, "cannot push down CurrentOfExpr");
822 return false;
823 }
824 if (IsA(node, Aggref))
825 {
826 Aggref *agg = (Aggref *) node;
827
828 if (agg->agglevelsup >= context->min_sublevels_up)
829 agg->agglevelsup += context->delta_sublevels_up;
830 /* fall through to recurse into argument */
831 }
832 if (IsA(node, GroupingFunc))
833 {
834 GroupingFunc *grp = (GroupingFunc *) node;
835
836 if (grp->agglevelsup >= context->min_sublevels_up)
837 grp->agglevelsup += context->delta_sublevels_up;
838 /* fall through to recurse into argument */
839 }
840 if (IsA(node, PlaceHolderVar))
841 {
842 PlaceHolderVar *phv = (PlaceHolderVar *) node;
843
844 if (phv->phlevelsup >= context->min_sublevels_up)
845 phv->phlevelsup += context->delta_sublevels_up;
846 /* fall through to recurse into argument */
847 }
848 if (IsA(node, ReturningExpr))
849 {
850 ReturningExpr *rexpr = (ReturningExpr *) node;
851
852 if (rexpr->retlevelsup >= context->min_sublevels_up)
853 rexpr->retlevelsup += context->delta_sublevels_up;
854 /* fall through to recurse into argument */
855 }
856 if (IsA(node, RangeTblEntry))
857 {
858 RangeTblEntry *rte = (RangeTblEntry *) node;
859
860 if (rte->rtekind == RTE_CTE)
861 {
862 if (rte->ctelevelsup >= context->min_sublevels_up)
863 rte->ctelevelsup += context->delta_sublevels_up;
864 }
865 return false; /* allow range_table_walker to continue */
866 }
867 if (IsA(node, Query))
868 {
869 /* Recurse into subselects */
870 bool result;
871
872 context->min_sublevels_up++;
873 result = query_tree_walker((Query *) node,
875 context,
877 context->min_sublevels_up--;
878 return result;
879 }
881}
@ RTE_CTE
Definition: parsenodes.h:1032
Index agglevelsup
Definition: primnodes.h:568
Index ctelevelsup
Definition: parsenodes.h:1212

References GroupingFunc::agglevelsup, RangeTblEntry::ctelevelsup, IncrementVarSublevelsUp_context::delta_sublevels_up, elog, ERROR, expression_tree_walker, IncrementVarSublevelsUp_walker(), IsA, IncrementVarSublevelsUp_context::min_sublevels_up, PlaceHolderVar::phlevelsup, QTW_EXAMINE_RTES_BEFORE, query_tree_walker, ReturningExpr::retlevelsup, RTE_CTE, RangeTblEntry::rtekind, and Var::varlevelsup.

Referenced by IncrementVarSublevelsUp(), IncrementVarSublevelsUp_rtable(), and IncrementVarSublevelsUp_walker().

◆ locate_agg_of_level()

int locate_agg_of_level ( Node node,
int  levelsup 
)

Definition at line 149 of file rewriteManip.c.

150{
152
153 context.agg_location = -1; /* in case we find nothing */
154 context.sublevels_up = levelsup;
155
156 /*
157 * Must be prepared to start with a Query or a bare expression tree; if
158 * it's a Query, we don't want to increment sublevels_up.
159 */
162 &context,
163 0);
164
165 return context.agg_location;
166}
static bool locate_agg_of_level_walker(Node *node, locate_agg_of_level_context *context)
Definition: rewriteManip.c:169

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_walker()

static bool locate_agg_of_level_walker ( Node node,
locate_agg_of_level_context context 
)
static

Definition at line 169 of file rewriteManip.c.

171{
172 if (node == NULL)
173 return false;
174 if (IsA(node, Aggref))
175 {
176 if (((Aggref *) node)->agglevelsup == context->sublevels_up &&
177 ((Aggref *) node)->location >= 0)
178 {
179 context->agg_location = ((Aggref *) node)->location;
180 return true; /* abort the tree traversal and return true */
181 }
182 /* else fall through to examine argument */
183 }
184 if (IsA(node, GroupingFunc))
185 {
186 if (((GroupingFunc *) node)->agglevelsup == context->sublevels_up &&
187 ((GroupingFunc *) node)->location >= 0)
188 {
189 context->agg_location = ((GroupingFunc *) node)->location;
190 return true; /* abort the tree traversal and return true */
191 }
192 }
193 if (IsA(node, Query))
194 {
195 /* Recurse into subselects */
196 bool result;
197
198 context->sublevels_up++;
199 result = query_tree_walker((Query *) node,
201 context, 0);
202 context->sublevels_up--;
203 return result;
204 }
206}

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

Referenced by locate_agg_of_level(), and locate_agg_of_level_walker().

◆ locate_windowfunc()

int locate_windowfunc ( Node node)

Definition at line 251 of file rewriteManip.c.

252{
254
255 context.win_location = -1; /* in case we find nothing */
256
257 /*
258 * Must be prepared to start with a Query or a bare expression tree; if
259 * it's a Query, we don't want to increment sublevels_up.
260 */
263 &context,
264 0);
265
266 return context.win_location;
267}
static bool locate_windowfunc_walker(Node *node, locate_windowfunc_context *context)
Definition: rewriteManip.c:270

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

Referenced by checkTargetlistEntrySQL92(), and transformWindowFuncCall().

◆ locate_windowfunc_walker()

static bool locate_windowfunc_walker ( Node node,
locate_windowfunc_context context 
)
static

Definition at line 270 of file rewriteManip.c.

271{
272 if (node == NULL)
273 return false;
274 if (IsA(node, WindowFunc))
275 {
276 if (((WindowFunc *) node)->location >= 0)
277 {
278 context->win_location = ((WindowFunc *) node)->location;
279 return true; /* abort the tree traversal and return true */
280 }
281 /* else fall through to examine argument */
282 }
283 /* Mustn't recurse into subselects */
285}

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

Referenced by locate_windowfunc(), and locate_windowfunc_walker().

◆ map_variable_attnos()

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

Definition at line 1705 of file rewriteManip.c.

1709{
1711
1712 context.target_varno = target_varno;
1713 context.sublevels_up = sublevels_up;
1714 context.attno_map = attno_map;
1715 context.to_rowtype = to_rowtype;
1716 context.found_whole_row = found_whole_row;
1717
1718 *found_whole_row = false;
1719
1720 /*
1721 * Must be prepared to start with a Query or a bare expression tree; if
1722 * it's a Query, we don't want to increment sublevels_up.
1723 */
1726 &context,
1727 0);
1728}
static Node * map_variable_attnos_mutator(Node *node, map_variable_attnos_context *context)

References map_variable_attnos_context::attno_map, map_variable_attnos_context::found_whole_row, 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(), CompareIndexInfo(), ExecInitPartitionInfo(), expandTableLikeClause(), generateClonedExtStatsStmt(), generateClonedIndexStmt(), map_partition_varattnos(), and MergeAttributes().

◆ map_variable_attnos_mutator()

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

Definition at line 1583 of file rewriteManip.c.

1585{
1586 if (node == NULL)
1587 return NULL;
1588 if (IsA(node, Var))
1589 {
1590 Var *var = (Var *) node;
1591
1592 if (var->varno == context->target_varno &&
1593 var->varlevelsup == context->sublevels_up)
1594 {
1595 /* Found a matching variable, make the substitution */
1596 Var *newvar = (Var *) palloc(sizeof(Var));
1597 int attno = var->varattno;
1598
1599 *newvar = *var; /* initially copy all fields of the Var */
1600
1601 if (attno > 0)
1602 {
1603 /* user-defined column, replace attno */
1604 if (attno > context->attno_map->maplen ||
1605 context->attno_map->attnums[attno - 1] == 0)
1606 elog(ERROR, "unexpected varattno %d in expression to be mapped",
1607 attno);
1608 newvar->varattno = context->attno_map->attnums[attno - 1];
1609 /* If the syntactic referent is same RTE, fix it too */
1610 if (newvar->varnosyn == context->target_varno)
1611 newvar->varattnosyn = newvar->varattno;
1612 }
1613 else if (attno == 0)
1614 {
1615 /* whole-row variable, warn caller */
1616 *(context->found_whole_row) = true;
1617
1618 /* If the caller expects us to convert the Var, do so. */
1619 if (OidIsValid(context->to_rowtype) &&
1620 context->to_rowtype != var->vartype)
1621 {
1623
1624 /* This certainly won't work for a RECORD variable. */
1625 Assert(var->vartype != RECORDOID);
1626
1627 /* Var itself is changed to the requested type. */
1628 newvar->vartype = context->to_rowtype;
1629
1630 /*
1631 * Add a conversion node on top to convert back to the
1632 * original type expected by the expression.
1633 */
1635 r->arg = (Expr *) newvar;
1636 r->resulttype = var->vartype;
1637 r->convertformat = COERCE_IMPLICIT_CAST;
1638 r->location = -1;
1639
1640 return (Node *) r;
1641 }
1642 }
1643 return (Node *) newvar;
1644 }
1645 /* otherwise fall through to copy the var normally */
1646 }
1647 else if (IsA(node, ConvertRowtypeExpr))
1648 {
1650 Var *var = (Var *) r->arg;
1651
1652 /*
1653 * If this is coercing a whole-row Var that we need to convert, then
1654 * just convert the Var without adding an extra ConvertRowtypeExpr.
1655 * Effectively we're simplifying var::parenttype::grandparenttype into
1656 * just var::grandparenttype. This avoids building stacks of CREs if
1657 * this function is applied repeatedly.
1658 */
1659 if (IsA(var, Var) &&
1660 var->varno == context->target_varno &&
1661 var->varlevelsup == context->sublevels_up &&
1662 var->varattno == 0 &&
1663 OidIsValid(context->to_rowtype) &&
1664 context->to_rowtype != var->vartype)
1665 {
1666 ConvertRowtypeExpr *newnode;
1667 Var *newvar = (Var *) palloc(sizeof(Var));
1668
1669 /* whole-row variable, warn caller */
1670 *(context->found_whole_row) = true;
1671
1672 *newvar = *var; /* initially copy all fields of the Var */
1673
1674 /* This certainly won't work for a RECORD variable. */
1675 Assert(var->vartype != RECORDOID);
1676
1677 /* Var itself is changed to the requested type. */
1678 newvar->vartype = context->to_rowtype;
1679
1680 newnode = (ConvertRowtypeExpr *) palloc(sizeof(ConvertRowtypeExpr));
1681 *newnode = *r; /* initially copy all fields of the CRE */
1682 newnode->arg = (Expr *) newvar;
1683
1684 return (Node *) newnode;
1685 }
1686 /* otherwise fall through to process the expression normally */
1687 }
1688 else if (IsA(node, Query))
1689 {
1690 /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1691 Query *newnode;
1692
1693 context->sublevels_up++;
1694 newnode = query_tree_mutator((Query *) node,
1696 context,
1697 0);
1698 context->sublevels_up--;
1699 return (Node *) newnode;
1700 }
1702}
#define OidIsValid(objectId)
Definition: c.h:746
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
void * palloc(Size size)
Definition: mcxt.c:1945
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:753
int maplen
Definition: attmap.h:37
AttrNumber * attnums
Definition: attmap.h:36
AttrNumber varattno
Definition: primnodes.h:274

References ConvertRowtypeExpr::arg, Assert(), map_variable_attnos_context::attno_map, AttrMap::attnums, COERCE_IMPLICIT_CAST, elog, ERROR, expression_tree_mutator, map_variable_attnos_context::found_whole_row, if(), IsA, ConvertRowtypeExpr::location, makeNode, map_variable_attnos_mutator(), AttrMap::maplen, OidIsValid, palloc(), query_tree_mutator, ConvertRowtypeExpr::resulttype, map_variable_attnos_context::sublevels_up, map_variable_attnos_context::target_varno, map_variable_attnos_context::to_rowtype, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by map_variable_attnos(), and map_variable_attnos_mutator().

◆ offset_relid_set()

static Relids offset_relid_set ( Relids  relids,
int  offset 
)
static

Definition at line 527 of file rewriteManip.c.

528{
529 Relids result = NULL;
530 int rtindex;
531
532 rtindex = -1;
533 while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
534 result = bms_add_member(result, rtindex + offset);
535 return result;
536}
int bms_next_member(const Bitmapset *a, int prevbit)
Definition: bitmapset.c:1306

References bms_add_member(), and bms_next_member().

Referenced by OffsetVarNodes_walker().

◆ OffsetVarNodes()

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

Definition at line 476 of file rewriteManip.c.

477{
479
480 context.offset = offset;
481 context.sublevels_up = sublevels_up;
482
483 /*
484 * Must be prepared to start with a Query or a bare expression tree; if
485 * it's a Query, go straight to query_tree_walker to make sure that
486 * sublevels_up doesn't get incremented prematurely.
487 */
488 if (node && IsA(node, Query))
489 {
490 Query *qry = (Query *) node;
491
492 /*
493 * If we are starting at a Query, and sublevels_up is zero, then we
494 * must also fix rangetable indexes in the Query itself --- namely
495 * resultRelation, mergeTargetRelation, exclRelIndex and rowMarks
496 * entries. sublevels_up cannot be zero when recursing into a
497 * subquery, so there's no need to have the same logic inside
498 * OffsetVarNodes_walker.
499 */
500 if (sublevels_up == 0)
501 {
502 ListCell *l;
503
504 if (qry->resultRelation)
505 qry->resultRelation += offset;
506
507 if (qry->mergeTargetRelation)
508 qry->mergeTargetRelation += offset;
509
510 if (qry->onConflict && qry->onConflict->exclRelIndex)
511 qry->onConflict->exclRelIndex += offset;
512
513 foreach(l, qry->rowMarks)
514 {
516
517 rc->rti += offset;
518 }
519 }
520 query_tree_walker(qry, OffsetVarNodes_walker, &context, 0);
521 }
522 else
523 OffsetVarNodes_walker(node, &context);
524}
static bool OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
Definition: rewriteManip.c:388

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

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

◆ OffsetVarNodes_walker()

static bool OffsetVarNodes_walker ( Node node,
OffsetVarNodes_context context 
)
static

Definition at line 388 of file rewriteManip.c.

389{
390 if (node == NULL)
391 return false;
392 if (IsA(node, Var))
393 {
394 Var *var = (Var *) node;
395
396 if (var->varlevelsup == context->sublevels_up)
397 {
398 var->varno += context->offset;
399 var->varnullingrels = offset_relid_set(var->varnullingrels,
400 context->offset);
401 if (var->varnosyn > 0)
402 var->varnosyn += context->offset;
403 }
404 return false;
405 }
406 if (IsA(node, CurrentOfExpr))
407 {
408 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
409
410 if (context->sublevels_up == 0)
411 cexpr->cvarno += context->offset;
412 return false;
413 }
414 if (IsA(node, RangeTblRef))
415 {
416 RangeTblRef *rtr = (RangeTblRef *) node;
417
418 if (context->sublevels_up == 0)
419 rtr->rtindex += context->offset;
420 /* the subquery itself is visited separately */
421 return false;
422 }
423 if (IsA(node, JoinExpr))
424 {
425 JoinExpr *j = (JoinExpr *) node;
426
427 if (j->rtindex && context->sublevels_up == 0)
428 j->rtindex += context->offset;
429 /* fall through to examine children */
430 }
431 if (IsA(node, PlaceHolderVar))
432 {
433 PlaceHolderVar *phv = (PlaceHolderVar *) node;
434
435 if (phv->phlevelsup == context->sublevels_up)
436 {
437 phv->phrels = offset_relid_set(phv->phrels,
438 context->offset);
440 context->offset);
441 }
442 /* fall through to examine children */
443 }
444 if (IsA(node, AppendRelInfo))
445 {
446 AppendRelInfo *appinfo = (AppendRelInfo *) node;
447
448 if (context->sublevels_up == 0)
449 {
450 appinfo->parent_relid += context->offset;
451 appinfo->child_relid += context->offset;
452 }
453 /* fall through to examine children */
454 }
455 /* Shouldn't need to handle other planner auxiliary nodes here */
456 Assert(!IsA(node, PlanRowMark));
457 Assert(!IsA(node, SpecialJoinInfo));
458 Assert(!IsA(node, PlaceHolderInfo));
459 Assert(!IsA(node, MinMaxAggInfo));
460
461 if (IsA(node, Query))
462 {
463 /* Recurse into subselects */
464 bool result;
465
466 context->sublevels_up++;
468 context, 0);
469 context->sublevels_up--;
470 return result;
471 }
472 return expression_tree_walker(node, OffsetVarNodes_walker, context);
473}
static Relids offset_relid_set(Relids relids, int offset)
Definition: rewriteManip.c:527

References Assert(), AppendRelInfo::child_relid, CurrentOfExpr::cvarno, expression_tree_walker, IsA, j, OffsetVarNodes_context::offset, offset_relid_set(), OffsetVarNodes_walker(), AppendRelInfo::parent_relid, PlaceHolderVar::phlevelsup, PlaceHolderVar::phnullingrels, query_tree_walker, RangeTblRef::rtindex, OffsetVarNodes_context::sublevels_up, Var::varlevelsup, and Var::varno.

Referenced by OffsetVarNodes(), and OffsetVarNodes_walker().

◆ rangeTableEntry_used()

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

Definition at line 1061 of file rewriteManip.c.

1062{
1064
1065 context.rt_index = rt_index;
1066 context.sublevels_up = sublevels_up;
1067
1068 /*
1069 * Must be prepared to start with a Query or a bare expression tree; if
1070 * it's a Query, we don't want to increment sublevels_up.
1071 */
1074 &context,
1075 0);
1076}
static bool rangeTableEntry_used_walker(Node *node, rangeTableEntry_used_context *context)
Definition: rewriteManip.c:995

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_walker()

static bool rangeTableEntry_used_walker ( Node node,
rangeTableEntry_used_context context 
)
static

Definition at line 995 of file rewriteManip.c.

997{
998 if (node == NULL)
999 return false;
1000 if (IsA(node, Var))
1001 {
1002 Var *var = (Var *) node;
1003
1004 if (var->varlevelsup == context->sublevels_up &&
1005 (var->varno == context->rt_index ||
1006 bms_is_member(context->rt_index, var->varnullingrels)))
1007 return true;
1008 return false;
1009 }
1010 if (IsA(node, CurrentOfExpr))
1011 {
1012 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
1013
1014 if (context->sublevels_up == 0 &&
1015 cexpr->cvarno == context->rt_index)
1016 return true;
1017 return false;
1018 }
1019 if (IsA(node, RangeTblRef))
1020 {
1021 RangeTblRef *rtr = (RangeTblRef *) node;
1022
1023 if (rtr->rtindex == context->rt_index &&
1024 context->sublevels_up == 0)
1025 return true;
1026 /* the subquery itself is visited separately */
1027 return false;
1028 }
1029 if (IsA(node, JoinExpr))
1030 {
1031 JoinExpr *j = (JoinExpr *) node;
1032
1033 if (j->rtindex == context->rt_index &&
1034 context->sublevels_up == 0)
1035 return true;
1036 /* fall through to examine children */
1037 }
1038 /* Shouldn't need to handle planner auxiliary nodes here */
1039 Assert(!IsA(node, PlaceHolderVar));
1040 Assert(!IsA(node, PlanRowMark));
1041 Assert(!IsA(node, SpecialJoinInfo));
1042 Assert(!IsA(node, AppendRelInfo));
1043 Assert(!IsA(node, PlaceHolderInfo));
1044 Assert(!IsA(node, MinMaxAggInfo));
1045
1046 if (IsA(node, Query))
1047 {
1048 /* Recurse into subselects */
1049 bool result;
1050
1051 context->sublevels_up++;
1053 context, 0);
1054 context->sublevels_up--;
1055 return result;
1056 }
1058}

References Assert(), bms_is_member(), CurrentOfExpr::cvarno, expression_tree_walker, IsA, j, query_tree_walker, rangeTableEntry_used_walker(), rangeTableEntry_used_context::rt_index, RangeTblRef::rtindex, rangeTableEntry_used_context::sublevels_up, Var::varlevelsup, and Var::varno.

Referenced by rangeTableEntry_used(), and rangeTableEntry_used_walker().

◆ remove_nulling_relids()

Node * remove_nulling_relids ( Node node,
const Bitmapset removable_relids,
const Bitmapset except_relids 
)

◆ remove_nulling_relids_mutator()

static Node * remove_nulling_relids_mutator ( Node node,
remove_nulling_relids_context context 
)
static

Definition at line 1347 of file rewriteManip.c.

1349{
1350 if (node == NULL)
1351 return NULL;
1352 if (IsA(node, Var))
1353 {
1354 Var *var = (Var *) node;
1355
1356 if (var->varlevelsup == context->sublevels_up &&
1357 !bms_is_member(var->varno, context->except_relids) &&
1358 bms_overlap(var->varnullingrels, context->removable_relids))
1359 {
1360 /* Copy the Var ... */
1361 var = copyObject(var);
1362 /* ... and replace the copy's varnullingrels field */
1363 var->varnullingrels = bms_difference(var->varnullingrels,
1364 context->removable_relids);
1365 return (Node *) var;
1366 }
1367 /* Otherwise fall through to copy the Var normally */
1368 }
1369 else if (IsA(node, PlaceHolderVar))
1370 {
1371 PlaceHolderVar *phv = (PlaceHolderVar *) node;
1372
1373 if (phv->phlevelsup == context->sublevels_up &&
1374 !bms_overlap(phv->phrels, context->except_relids))
1375 {
1376 /*
1377 * Note: it might seem desirable to remove the PHV altogether if
1378 * phnullingrels goes to empty. Currently we dare not do that
1379 * because we use PHVs in some cases to enforce separate identity
1380 * of subexpressions; see wrap_option usages in prepjointree.c.
1381 */
1382 /* Copy the PlaceHolderVar and mutate what's below ... */
1383 phv = (PlaceHolderVar *)
1386 context);
1387 /* ... and replace the copy's phnullingrels field */
1389 context->removable_relids);
1390 /* We must also update phrels, if it contains a removable RTI */
1391 phv->phrels = bms_difference(phv->phrels,
1392 context->removable_relids);
1393 Assert(!bms_is_empty(phv->phrels));
1394 return (Node *) phv;
1395 }
1396 /* Otherwise fall through to copy the PlaceHolderVar normally */
1397 }
1398 else if (IsA(node, Query))
1399 {
1400 /* Recurse into RTE or sublink subquery */
1401 Query *newnode;
1402
1403 context->sublevels_up++;
1404 newnode = query_tree_mutator((Query *) node,
1406 context,
1407 0);
1408 context->sublevels_up--;
1409 return (Node *) newnode;
1410 }
1412}
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:346
#define bms_is_empty(a)
Definition: bitmapset.h:118

References Assert(), bms_difference(), bms_is_empty, bms_is_member(), bms_overlap(), copyObject, remove_nulling_relids_context::except_relids, expression_tree_mutator, IsA, PlaceHolderVar::phlevelsup, PlaceHolderVar::phnullingrels, query_tree_mutator, remove_nulling_relids_context::removable_relids, remove_nulling_relids_mutator(), remove_nulling_relids_context::sublevels_up, Var::varlevelsup, and Var::varno.

Referenced by remove_nulling_relids(), and remove_nulling_relids_mutator().

◆ replace_rte_variables()

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 1438 of file rewriteManip.c.

1442{
1443 Node *result;
1445
1446 context.callback = callback;
1447 context.callback_arg = callback_arg;
1448 context.target_varno = target_varno;
1449 context.sublevels_up = sublevels_up;
1450
1451 /*
1452 * We try to initialize inserted_sublink to true if there is no need to
1453 * detect new sublinks because the query already has some.
1454 */
1455 if (node && IsA(node, Query))
1456 context.inserted_sublink = ((Query *) node)->hasSubLinks;
1457 else if (outer_hasSubLinks)
1458 context.inserted_sublink = *outer_hasSubLinks;
1459 else
1460 context.inserted_sublink = false;
1461
1462 /*
1463 * Must be prepared to start with a Query or a bare expression tree; if
1464 * it's a Query, we don't want to increment sublevels_up.
1465 */
1468 &context,
1469 0);
1470
1471 if (context.inserted_sublink)
1472 {
1473 if (result && IsA(result, Query))
1474 ((Query *) result)->hasSubLinks = true;
1475 else if (outer_hasSubLinks)
1476 *outer_hasSubLinks = true;
1477 else
1478 elog(ERROR, "replace_rte_variables inserted a SubLink, but has noplace to record it");
1479 }
1480
1481 return result;
1482}
Node * replace_rte_variables_mutator(Node *node, replace_rte_variables_context *context)
replace_rte_variables_callback callback
Definition: rewriteManip.h:30

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(), replace_rte_variables_context::sublevels_up, and replace_rte_variables_context::target_varno.

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

◆ replace_rte_variables_mutator()

Node * replace_rte_variables_mutator ( Node node,
replace_rte_variables_context context 
)

Definition at line 1485 of file rewriteManip.c.

1487{
1488 if (node == NULL)
1489 return NULL;
1490 if (IsA(node, Var))
1491 {
1492 Var *var = (Var *) node;
1493
1494 if (var->varno == context->target_varno &&
1495 var->varlevelsup == context->sublevels_up)
1496 {
1497 /* Found a matching variable, make the substitution */
1498 Node *newnode;
1499
1500 newnode = context->callback(var, context);
1501 /* Detect if we are adding a sublink to query */
1502 if (!context->inserted_sublink)
1503 context->inserted_sublink = checkExprHasSubLink(newnode);
1504 return newnode;
1505 }
1506 /* otherwise fall through to copy the var normally */
1507 }
1508 else if (IsA(node, CurrentOfExpr))
1509 {
1510 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
1511
1512 if (cexpr->cvarno == context->target_varno &&
1513 context->sublevels_up == 0)
1514 {
1515 /*
1516 * We get here if a WHERE CURRENT OF expression turns out to apply
1517 * to a view. Someday we might be able to translate the
1518 * expression to apply to an underlying table of the view, but
1519 * right now it's not implemented.
1520 */
1521 ereport(ERROR,
1522 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1523 errmsg("WHERE CURRENT OF on a view is not implemented")));
1524 }
1525 /* otherwise fall through to copy the expr normally */
1526 }
1527 else if (IsA(node, Query))
1528 {
1529 /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1530 Query *newnode;
1531 bool save_inserted_sublink;
1532
1533 context->sublevels_up++;
1534 save_inserted_sublink = context->inserted_sublink;
1535 context->inserted_sublink = ((Query *) node)->hasSubLinks;
1536 newnode = query_tree_mutator((Query *) node,
1538 context,
1539 0);
1540 newnode->hasSubLinks |= context->inserted_sublink;
1541 context->inserted_sublink = save_inserted_sublink;
1542 context->sublevels_up--;
1543 return (Node *) newnode;
1544 }
1546}

References replace_rte_variables_context::callback, checkExprHasSubLink(), CurrentOfExpr::cvarno, ereport, errcode(), errmsg(), ERROR, expression_tree_mutator, replace_rte_variables_context::inserted_sublink, IsA, 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 replace_rte_variables(), and replace_rte_variables_mutator().

◆ ReplaceVarFromTargetList()

Node * ReplaceVarFromTargetList ( Var var,
RangeTblEntry target_rte,
List targetlist,
int  result_relation,
ReplaceVarsNoMatchOption  nomatch_option,
int  nomatch_varno 
)

Definition at line 1795 of file rewriteManip.c.

1801{
1802 TargetEntry *tle;
1803
1804 if (var->varattno == InvalidAttrNumber)
1805 {
1806 /* Must expand whole-tuple reference into RowExpr */
1807 RowExpr *rowexpr;
1808 List *colnames;
1809 List *fields;
1810 ListCell *lc;
1811
1812 /*
1813 * If generating an expansion for a var of a named rowtype (ie, this
1814 * is a plain relation RTE), then we must include dummy items for
1815 * dropped columns. If the var is RECORD (ie, this is a JOIN), then
1816 * omit dropped columns. In the latter case, attach column names to
1817 * the RowExpr for use of the executor and ruleutils.c.
1818 *
1819 * In order to be able to cache the results, we always generate the
1820 * expansion with varlevelsup = 0. The caller is responsible for
1821 * adjusting it if needed.
1822 *
1823 * The varreturningtype is copied onto each individual field Var, so
1824 * that it is handled correctly when we recurse.
1825 */
1826 expandRTE(target_rte,
1827 var->varno, 0 /* not varlevelsup */ ,
1828 var->varreturningtype, var->location,
1829 (var->vartype != RECORDOID),
1830 &colnames, &fields);
1831 rowexpr = makeNode(RowExpr);
1832 /* the fields will be set below */
1833 rowexpr->args = NIL;
1834 rowexpr->row_typeid = var->vartype;
1835 rowexpr->row_format = COERCE_IMPLICIT_CAST;
1836 rowexpr->colnames = (var->vartype == RECORDOID) ? colnames : NIL;
1837 rowexpr->location = var->location;
1838 /* Adjust the generated per-field Vars... */
1839 foreach(lc, fields)
1840 {
1841 Node *field = lfirst(lc);
1842
1843 if (field && IsA(field, Var))
1844 field = ReplaceVarFromTargetList((Var *) field,
1845 target_rte,
1846 targetlist,
1847 result_relation,
1848 nomatch_option,
1849 nomatch_varno);
1850 rowexpr->args = lappend(rowexpr->args, field);
1851 }
1852
1853 /* Wrap it in a ReturningExpr, if needed, per comments above */
1855 {
1857
1858 rexpr->retlevelsup = 0;
1859 rexpr->retold = (var->varreturningtype == VAR_RETURNING_OLD);
1860 rexpr->retexpr = (Expr *) rowexpr;
1861
1862 return (Node *) rexpr;
1863 }
1864
1865 return (Node *) rowexpr;
1866 }
1867
1868 /* Normal case referencing one targetlist element */
1869 tle = get_tle_by_resno(targetlist, var->varattno);
1870
1871 if (tle == NULL || tle->resjunk)
1872 {
1873 /* Failed to find column in targetlist */
1874 switch (nomatch_option)
1875 {
1877 /* fall through, throw error below */
1878 break;
1879
1881 var = copyObject(var);
1882 var->varno = nomatch_varno;
1883 var->varlevelsup = 0;
1884 /* we leave the syntactic referent alone */
1885 return (Node *) var;
1886
1888 {
1889 /*
1890 * If Var is of domain type, we must add a CoerceToDomain
1891 * node, in case there is a NOT NULL domain constraint.
1892 */
1893 int16 vartyplen;
1894 bool vartypbyval;
1895
1896 get_typlenbyval(var->vartype, &vartyplen, &vartypbyval);
1897 return coerce_null_to_domain(var->vartype,
1898 var->vartypmod,
1899 var->varcollid,
1900 vartyplen,
1901 vartypbyval);
1902 }
1903 }
1904 elog(ERROR, "could not find replacement targetlist entry for attno %d",
1905 var->varattno);
1906 return NULL; /* keep compiler quiet */
1907 }
1908 else
1909 {
1910 /* Make a copy of the tlist item to return */
1911 Expr *newnode = copyObject(tle->expr);
1912
1913 /*
1914 * Check to see if the tlist item contains a PARAM_MULTIEXPR Param,
1915 * and throw error if so. This case could only happen when expanding
1916 * an ON UPDATE rule's NEW variable and the referenced tlist item in
1917 * the original UPDATE command is part of a multiple assignment. There
1918 * seems no practical way to handle such cases without multiple
1919 * evaluation of the multiple assignment's sub-select, which would
1920 * create semantic oddities that users of rules would probably prefer
1921 * not to cope with. So treat it as an unimplemented feature.
1922 */
1923 if (contains_multiexpr_param((Node *) newnode, NULL))
1924 ereport(ERROR,
1925 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1926 errmsg("NEW variables in ON UPDATE rules cannot reference columns that are part of a multiple assignment in the subject UPDATE command")));
1927
1928 /* Handle any OLD/NEW RETURNING list Vars */
1930 {
1931 /*
1932 * Copy varreturningtype onto any Vars in the tlist item that
1933 * refer to result_relation (which had better be non-zero).
1934 */
1935 if (result_relation == 0)
1936 elog(ERROR, "variable returning old/new found outside RETURNING list");
1937
1938 SetVarReturningType((Node *) newnode, result_relation,
1939 0, var->varreturningtype);
1940
1941 /* Wrap it in a ReturningExpr, if needed, per comments above */
1942 if (!IsA(newnode, Var) ||
1943 ((Var *) newnode)->varno != result_relation ||
1944 ((Var *) newnode)->varlevelsup != 0)
1945 {
1947
1948 rexpr->retlevelsup = 0;
1949 rexpr->retold = (var->varreturningtype == VAR_RETURNING_OLD);
1950 rexpr->retexpr = newnode;
1951
1952 newnode = (Expr *) rexpr;
1953 }
1954 }
1955
1956 return (Node *) newnode;
1957 }
1958}
#define InvalidAttrNumber
Definition: attnum.h:23
int16_t int16
Definition: c.h:497
List * lappend(List *list, void *datum)
Definition: list.c:339
void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
Definition: lsyscache.c:2391
Node * coerce_null_to_domain(Oid typid, int32 typmod, Oid collation, int typlen, bool typbyval)
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
void expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up, VarReturningType returning_type, int location, bool include_dropped, List **colnames, List **colvars)
#define NIL
Definition: pg_list.h:68
@ VAR_RETURNING_OLD
Definition: primnodes.h:257
@ VAR_RETURNING_DEFAULT
Definition: primnodes.h:256
static void SetVarReturningType(Node *node, int result_relation, int sublevels_up, VarReturningType returning_type)
Definition: rewriteManip.c:970
Node * ReplaceVarFromTargetList(Var *var, RangeTblEntry *target_rte, List *targetlist, int result_relation, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno)
@ REPLACEVARS_SUBSTITUTE_NULL
Definition: rewriteManip.h:41
@ REPLACEVARS_CHANGE_VARNO
Definition: rewriteManip.h:40
@ REPLACEVARS_REPORT_ERROR
Definition: rewriteManip.h:39
Definition: pg_list.h:54
Expr * retexpr
Definition: primnodes.h:2157
List * args
Definition: primnodes.h:1428
ParseLoc location
Definition: primnodes.h:1452
Expr * expr
Definition: primnodes.h:2219
ParseLoc location
Definition: primnodes.h:310
VarReturningType varreturningtype
Definition: primnodes.h:297

References RowExpr::args, COERCE_IMPLICIT_CAST, coerce_null_to_domain(), contains_multiexpr_param(), copyObject, elog, ereport, errcode(), errmsg(), ERROR, expandRTE(), TargetEntry::expr, get_tle_by_resno(), get_typlenbyval(), InvalidAttrNumber, IsA, lappend(), lfirst, Var::location, RowExpr::location, makeNode, NIL, ReplaceVarFromTargetList(), REPLACEVARS_CHANGE_VARNO, REPLACEVARS_REPORT_ERROR, REPLACEVARS_SUBSTITUTE_NULL, ReturningExpr::retexpr, ReturningExpr::retlevelsup, ReturningExpr::retold, SetVarReturningType(), VAR_RETURNING_DEFAULT, VAR_RETURNING_OLD, Var::varattno, Var::varlevelsup, Var::varno, and Var::varreturningtype.

Referenced by pullup_replace_vars_callback(), ReplaceVarFromTargetList(), and ReplaceVarsFromTargetList_callback().

◆ ReplaceVarsFromTargetList()

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

Definition at line 1961 of file rewriteManip.c.

1969{
1971
1972 context.target_rte = target_rte;
1973 context.targetlist = targetlist;
1974 context.result_relation = result_relation;
1975 context.nomatch_option = nomatch_option;
1976 context.nomatch_varno = nomatch_varno;
1977
1978 return replace_rte_variables(node, target_varno, sublevels_up,
1980 &context,
1981 outer_hasSubLinks);
1982}
static Node * ReplaceVarsFromTargetList_callback(Var *var, replace_rte_variables_context *context)
Node * replace_rte_variables(Node *node, int target_varno, int sublevels_up, replace_rte_variables_callback callback, void *callback_arg, bool *outer_hasSubLinks)
ReplaceVarsNoMatchOption nomatch_option

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

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

◆ ReplaceVarsFromTargetList_callback()

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

Definition at line 1774 of file rewriteManip.c.

1776{
1778 Node *newnode;
1779
1780 newnode = ReplaceVarFromTargetList(var,
1781 rcon->target_rte,
1782 rcon->targetlist,
1783 rcon->result_relation,
1784 rcon->nomatch_option,
1785 rcon->nomatch_varno);
1786
1787 /* Must adjust varlevelsup if replaced Var is within a subquery */
1788 if (var->varlevelsup > 0)
1789 IncrementVarSublevelsUp(newnode, var->varlevelsup, 0);
1790
1791 return newnode;
1792}
void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up, int min_sublevels_up)
Definition: rewriteManip.c:884

References replace_rte_variables_context::callback_arg, IncrementVarSublevelsUp(), ReplaceVarsFromTargetList_context::nomatch_option, ReplaceVarsFromTargetList_context::nomatch_varno, ReplaceVarFromTargetList(), ReplaceVarsFromTargetList_context::result_relation, ReplaceVarsFromTargetList_context::target_rte, ReplaceVarsFromTargetList_context::targetlist, and Var::varlevelsup.

Referenced by ReplaceVarsFromTargetList().

◆ SetVarReturningType()

static void SetVarReturningType ( Node node,
int  result_relation,
int  sublevels_up,
VarReturningType  returning_type 
)
static

Definition at line 970 of file rewriteManip.c.

972{
974
975 context.result_relation = result_relation;
976 context.sublevels_up = sublevels_up;
977 context.returning_type = returning_type;
978
979 /* Expect to start with an expression */
980 SetVarReturningType_walker(node, &context);
981}
static bool SetVarReturningType_walker(Node *node, SetVarReturningType_context *context)
Definition: rewriteManip.c:940
VarReturningType returning_type
Definition: rewriteManip.c:936

References SetVarReturningType_context::result_relation, SetVarReturningType_context::returning_type, SetVarReturningType_walker(), and SetVarReturningType_context::sublevels_up.

Referenced by ReplaceVarFromTargetList().

◆ SetVarReturningType_walker()

static bool SetVarReturningType_walker ( Node node,
SetVarReturningType_context context 
)
static

Definition at line 940 of file rewriteManip.c.

941{
942 if (node == NULL)
943 return false;
944 if (IsA(node, Var))
945 {
946 Var *var = (Var *) node;
947
948 if (var->varno == context->result_relation &&
949 var->varlevelsup == context->sublevels_up)
950 var->varreturningtype = context->returning_type;
951
952 return false;
953 }
954
955 if (IsA(node, Query))
956 {
957 /* Recurse into subselects */
958 bool result;
959
960 context->sublevels_up++;
962 context, 0);
963 context->sublevels_up--;
964 return result;
965 }
967}

References expression_tree_walker, IsA, query_tree_walker, SetVarReturningType_context::result_relation, SetVarReturningType_context::returning_type, SetVarReturningType_walker(), SetVarReturningType_context::sublevels_up, Var::varlevelsup, Var::varno, and Var::varreturningtype.

Referenced by SetVarReturningType(), and SetVarReturningType_walker().