PostgreSQL Source Code  git master
rewriteManip.h File Reference
#include "nodes/parsenodes.h"
Include dependency graph for rewriteManip.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  replace_rte_variables_context
 

Typedefs

typedef struct replace_rte_variables_context replace_rte_variables_context
 
typedef Node *(* replace_rte_variables_callback) (Var *var, replace_rte_variables_context *context)
 
typedef enum ReplaceVarsNoMatchOption ReplaceVarsNoMatchOption
 

Enumerations

enum  ReplaceVarsNoMatchOption { REPLACEVARS_REPORT_ERROR , REPLACEVARS_CHANGE_VARNO , REPLACEVARS_SUBSTITUTE_NULL }
 

Functions

void CombineRangeTables (List **dst_rtable, List **dst_perminfos, List *src_rtable, List *src_perminfos)
 
void OffsetVarNodes (Node *node, int offset, int sublevels_up)
 
void ChangeVarNodes (Node *node, int rt_index, int new_index, int sublevels_up)
 
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)
 
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)
 
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)
 
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)
 
Nodemap_variable_attnos (Node *node, int target_varno, int sublevels_up, const struct AttrMap *attno_map, Oid to_rowtype, bool *found_whole_row)
 
NodeReplaceVarsFromTargetList (Node *node, int target_varno, int sublevels_up, RangeTblEntry *target_rte, List *targetlist, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno, bool *outer_hasSubLinks)
 

Typedef Documentation

◆ replace_rte_variables_callback

typedef Node*(* replace_rte_variables_callback) (Var *var, replace_rte_variables_context *context)

Definition at line 24 of file rewriteManip.h.

◆ replace_rte_variables_context

◆ ReplaceVarsNoMatchOption

Enumeration Type Documentation

◆ ReplaceVarsNoMatchOption

Enumerator
REPLACEVARS_REPORT_ERROR 
REPLACEVARS_CHANGE_VARNO 
REPLACEVARS_SUBSTITUTE_NULL 

Definition at line 36 of file rewriteManip.h.

37 {
38  REPLACEVARS_REPORT_ERROR, /* throw error if no match */
39  REPLACEVARS_CHANGE_VARNO, /* change the Var's varno, nothing else */
40  REPLACEVARS_SUBSTITUTE_NULL /* replace with a NULL Const */
ReplaceVarsNoMatchOption
Definition: rewriteManip.h:37
@ REPLACEVARS_SUBSTITUTE_NULL
Definition: rewriteManip.h:40
@ REPLACEVARS_CHANGE_VARNO
Definition: rewriteManip.h:39
@ REPLACEVARS_REPORT_ERROR
Definition: rewriteManip.h:38

Function Documentation

◆ add_nulling_relids()

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

Definition at line 1131 of file rewriteManip.c.

1134 {
1136 
1137  context.target_relids = target_relids;
1138  context.added_relids = added_relids;
1139  context.sublevels_up = 0;
1142  &context,
1143  0);
1144 }
#define query_or_expression_tree_mutator(n, m, c, f)
Definition: nodeFuncs.h:171
static Node * add_nulling_relids_mutator(Node *node, add_nulling_relids_context *context)
const Bitmapset * target_relids
Definition: rewriteManip.c:45
const Bitmapset * added_relids
Definition: rewriteManip.c:46

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

◆ AddInvertedQual()

void AddInvertedQual ( Query parsetree,
Node qual 
)

Definition at line 1108 of file rewriteManip.c.

1109 {
1110  BooleanTest *invqual;
1111 
1112  if (qual == NULL)
1113  return;
1114 
1115  /* Need not copy input qual, because AddQual will... */
1116  invqual = makeNode(BooleanTest);
1117  invqual->arg = (Expr *) qual;
1118  invqual->booltesttype = IS_NOT_TRUE;
1119  invqual->location = -1;
1120 
1121  AddQual(parsetree, (Node *) invqual);
1122 }
#define makeNode(_type_)
Definition: nodes.h:176
@ IS_NOT_TRUE
Definition: primnodes.h:1537
void AddQual(Query *parsetree, Node *qual)
BoolTestType booltesttype
Definition: primnodes.h:1544
Expr * arg
Definition: primnodes.h:1543
Definition: nodes.h:129

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

1041 {
1042  Node *copy;
1043 
1044  if (qual == NULL)
1045  return;
1046 
1047  if (parsetree->commandType == CMD_UTILITY)
1048  {
1049  /*
1050  * There's noplace to put the qual on a utility statement.
1051  *
1052  * If it's a NOTIFY, silently ignore the qual; this means that the
1053  * NOTIFY will execute, whether or not there are any qualifying rows.
1054  * While clearly wrong, this is much more useful than refusing to
1055  * execute the rule at all, and extra NOTIFY events are harmless for
1056  * typical uses of NOTIFY.
1057  *
1058  * If it isn't a NOTIFY, error out, since unconditional execution of
1059  * other utility stmts is unlikely to be wanted. (This case is not
1060  * currently allowed anyway, but keep the test for safety.)
1061  */
1062  if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
1063  return;
1064  else
1065  ereport(ERROR,
1066  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1067  errmsg("conditional utility statements are not implemented")));
1068  }
1069 
1070  if (parsetree->setOperations != NULL)
1071  {
1072  /*
1073  * There's noplace to put the qual on a setop statement, either. (This
1074  * could be fixed, but right now the planner simply ignores any qual
1075  * condition on a setop query.)
1076  */
1077  ereport(ERROR,
1078  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1079  errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
1080  }
1081 
1082  /* INTERSECT wants the original, but we need to copy - Jan */
1083  copy = copyObject(qual);
1084 
1085  parsetree->jointree->quals = make_and_qual(parsetree->jointree->quals,
1086  copy);
1087 
1088  /*
1089  * We had better not have stuck an aggregate into the WHERE clause.
1090  */
1091  Assert(!contain_aggs_of_level(copy, 0));
1092 
1093  /*
1094  * Make sure query is marked correctly if added qual has sublinks. Need
1095  * not search qual when query is already marked.
1096  */
1097  if (!parsetree->hasSubLinks)
1098  parsetree->hasSubLinks = checkExprHasSubLink(copy);
1099 }
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
Assert(fmt[strlen(fmt) - 1] !='\n')
Node * make_and_qual(Node *qual1, Node *qual2)
Definition: makefuncs.c:691
#define IsA(nodeptr, _type_)
Definition: nodes.h:179
#define copyObject(obj)
Definition: nodes.h:244
@ CMD_UTILITY
Definition: nodes.h:281
bool checkExprHasSubLink(Node *node)
Definition: rewriteManip.c:295
bool contain_aggs_of_level(Node *node, int levelsup)
Definition: rewriteManip.c:85
Node * quals
Definition: primnodes.h:1841
FromExpr * jointree
Definition: parsenodes.h:182
Node * setOperations
Definition: parsenodes.h:217
CmdType commandType
Definition: parsenodes.h:128
Node * utilityStmt
Definition: parsenodes.h:143

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

◆ ChangeVarNodes()

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

Definition at line 670 of file rewriteManip.c.

671 {
672  ChangeVarNodes_context context;
673 
674  context.rt_index = rt_index;
675  context.new_index = new_index;
676  context.sublevels_up = sublevels_up;
677 
678  /*
679  * Must be prepared to start with a Query or a bare expression tree; if
680  * it's a Query, go straight to query_tree_walker to make sure that
681  * sublevels_up doesn't get incremented prematurely.
682  */
683  if (node && IsA(node, Query))
684  {
685  Query *qry = (Query *) node;
686 
687  /*
688  * If we are starting at a Query, and sublevels_up is zero, then we
689  * must also fix rangetable indexes in the Query itself --- namely
690  * resultRelation and rowMarks entries. sublevels_up cannot be zero
691  * when recursing into a subquery, so there's no need to have the same
692  * logic inside ChangeVarNodes_walker.
693  */
694  if (sublevels_up == 0)
695  {
696  ListCell *l;
697 
698  if (qry->resultRelation == rt_index)
699  qry->resultRelation = new_index;
700 
701  /* this is unlikely to ever be used, but ... */
702  if (qry->onConflict && qry->onConflict->exclRelIndex == rt_index)
703  qry->onConflict->exclRelIndex = new_index;
704 
705  foreach(l, qry->rowMarks)
706  {
707  RowMarkClause *rc = (RowMarkClause *) lfirst(l);
708 
709  if (rc->rti == rt_index)
710  rc->rti = new_index;
711  }
712  }
714  (void *) &context, 0);
715  }
716  else
717  ChangeVarNodes_walker(node, &context);
718 }
#define query_tree_walker(q, w, c, f)
Definition: nodeFuncs.h:156
#define lfirst(lc)
Definition: pg_list.h:172
static bool ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
Definition: rewriteManip.c:560
List * rowMarks
Definition: parsenodes.h:215
OnConflictExpr * onConflict
Definition: parsenodes.h:194

References 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 add_security_quals(), add_with_check_options(), ApplyRetrieveRule(), CopyAndAddInvertedQual(), get_relation_constraints(), get_relation_info(), get_relation_statistics(), rewriteRuleAction(), rewriteTargetView(), set_baserel_partition_constraint(), set_baserel_partition_key_exprs(), and TriggerEnabled().

◆ checkExprHasSubLink()

bool checkExprHasSubLink ( Node node)

Definition at line 295 of file rewriteManip.c.

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

References checkExprHasSubLink_walker(), 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().

◆ CombineRangeTables()

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

Definition at line 350 of file rewriteManip.c.

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

References lfirst_node, list_concat(), list_length(), and RangeTblEntry::perminfoindex.

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  (void *) &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_windowfuncs()

bool contain_windowfuncs ( Node node)

Definition at line 215 of file rewriteManip.c.

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

References contain_windowfuncs_walker(), and query_or_expression_tree_walker.

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

◆ getInsertSelectQuery()

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

Definition at line 985 of file rewriteManip.c.

986 {
987  Query *selectquery;
988  RangeTblEntry *selectrte;
989  RangeTblRef *rtr;
990 
991  if (subquery_ptr)
992  *subquery_ptr = NULL;
993 
994  if (parsetree == NULL)
995  return parsetree;
996  if (parsetree->commandType != CMD_INSERT)
997  return parsetree;
998 
999  /*
1000  * Currently, this is ONLY applied to rule-action queries, and so we
1001  * expect to find the OLD and NEW placeholder entries in the given query.
1002  * If they're not there, it must be an INSERT/SELECT in which they've been
1003  * pushed down to the SELECT.
1004  */
1005  if (list_length(parsetree->rtable) >= 2 &&
1006  strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->aliasname,
1007  "old") == 0 &&
1008  strcmp(rt_fetch(PRS2_NEW_VARNO, parsetree->rtable)->eref->aliasname,
1009  "new") == 0)
1010  return parsetree;
1011  Assert(parsetree->jointree && IsA(parsetree->jointree, FromExpr));
1012  if (list_length(parsetree->jointree->fromlist) != 1)
1013  elog(ERROR, "expected to find SELECT subquery");
1014  rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
1015  Assert(IsA(rtr, RangeTblRef));
1016  selectrte = rt_fetch(rtr->rtindex, parsetree->rtable);
1017  selectquery = selectrte->subquery;
1018  if (!(selectquery && IsA(selectquery, Query) &&
1019  selectquery->commandType == CMD_SELECT))
1020  elog(ERROR, "expected to find SELECT subquery");
1021  if (list_length(selectquery->rtable) >= 2 &&
1022  strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->aliasname,
1023  "old") == 0 &&
1024  strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->aliasname,
1025  "new") == 0)
1026  {
1027  if (subquery_ptr)
1028  *subquery_ptr = &(selectrte->subquery);
1029  return selectquery;
1030  }
1031  elog(ERROR, "could not find rule placeholders");
1032  return NULL; /* not reached */
1033 }
@ CMD_INSERT
Definition: nodes.h:278
@ CMD_SELECT
Definition: nodes.h:276
#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:219
#define PRS2_NEW_VARNO
Definition: primnodes.h:220
List * fromlist
Definition: primnodes.h:1840
List * rtable
Definition: parsenodes.h:175
Query * subquery
Definition: parsenodes.h:1080

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

838 {
840 
841  context.delta_sublevels_up = delta_sublevels_up;
842  context.min_sublevels_up = min_sublevels_up;
843 
844  /*
845  * Must be prepared to start with a Query or a bare expression tree; if
846  * it's a Query, we don't want to increment sublevels_up.
847  */
850  (void *) &context,
852 }
#define QTW_EXAMINE_RTES_BEFORE
Definition: nodeFuncs.h:27
static bool IncrementVarSublevelsUp_walker(Node *node, IncrementVarSublevelsUp_context *context)
Definition: rewriteManip.c:763

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_join_alias_vars_mutator(), inline_cte_walker(), pull_up_simple_subquery(), pullup_replace_vars_callback(), replace_outer_agg(), replace_outer_grouping(), 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 859 of file rewriteManip.c.

861 {
863 
864  context.delta_sublevels_up = delta_sublevels_up;
865  context.min_sublevels_up = min_sublevels_up;
866 
867  range_table_walker(rtable,
869  (void *) &context,
871 }
#define range_table_walker(rt, w, c, f)
Definition: nodeFuncs.h:161

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

◆ 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  (void *) &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_windowfunc()

int locate_windowfunc ( Node node)

Definition at line 253 of file rewriteManip.c.

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

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

Referenced by checkTargetlistEntrySQL92(), and transformWindowFuncCall().

◆ map_variable_attnos()

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

◆ OffsetVarNodes()

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

Definition at line 480 of file rewriteManip.c.

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

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

◆ rangeTableEntry_used()

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

Definition at line 953 of file rewriteManip.c.

954 {
956 
957  context.rt_index = rt_index;
958  context.sublevels_up = sublevels_up;
959 
960  /*
961  * Must be prepared to start with a Query or a bare expression tree; if
962  * it's a Query, we don't want to increment sublevels_up.
963  */
966  (void *) &context,
967  0);
968 }
static bool rangeTableEntry_used_walker(Node *node, rangeTableEntry_used_context *context)
Definition: rewriteManip.c:886

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

◆ remove_nulling_relids()

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

Definition at line 1218 of file rewriteManip.c.

1221 {
1223 
1224  context.removable_relids = removable_relids;
1225  context.except_relids = except_relids;
1226  context.sublevels_up = 0;
1229  &context,
1230  0);
1231 }
static Node * remove_nulling_relids_mutator(Node *node, remove_nulling_relids_context *context)
const Bitmapset * removable_relids
Definition: rewriteManip.c:52
const Bitmapset * except_relids
Definition: rewriteManip.c:53

References remove_nulling_relids_context::except_relids, query_or_expression_tree_mutator, remove_nulling_relids_context::removable_relids, remove_nulling_relids_mutator(), and remove_nulling_relids_context::sublevels_up.

Referenced by deconstruct_distribute_oj_quals(), have_partkey_equi_join(), reconsider_full_join_clause(), reduce_outer_joins(), and remove_useless_result_rtes().

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

1341 {
1342  Node *result;
1344 
1345  context.callback = callback;
1346  context.callback_arg = callback_arg;
1347  context.target_varno = target_varno;
1348  context.sublevels_up = sublevels_up;
1349 
1350  /*
1351  * We try to initialize inserted_sublink to true if there is no need to
1352  * detect new sublinks because the query already has some.
1353  */
1354  if (node && IsA(node, Query))
1355  context.inserted_sublink = ((Query *) node)->hasSubLinks;
1356  else if (outer_hasSubLinks)
1357  context.inserted_sublink = *outer_hasSubLinks;
1358  else
1359  context.inserted_sublink = false;
1360 
1361  /*
1362  * Must be prepared to start with a Query or a bare expression tree; if
1363  * it's a Query, we don't want to increment sublevels_up.
1364  */
1365  result = query_or_expression_tree_mutator(node,
1367  (void *) &context,
1368  0);
1369 
1370  if (context.inserted_sublink)
1371  {
1372  if (result && IsA(result, Query))
1373  ((Query *) result)->hasSubLinks = true;
1374  else if (outer_hasSubLinks)
1375  *outer_hasSubLinks = true;
1376  else
1377  elog(ERROR, "replace_rte_variables inserted a SubLink, but has noplace to record it");
1378  }
1379 
1380  return result;
1381 }
Node * replace_rte_variables_mutator(Node *node, replace_rte_variables_context *context)
replace_rte_variables_callback callback
Definition: rewriteManip.h:29
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46

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

1386 {
1387  if (node == NULL)
1388  return NULL;
1389  if (IsA(node, Var))
1390  {
1391  Var *var = (Var *) node;
1392 
1393  if (var->varno == context->target_varno &&
1394  var->varlevelsup == context->sublevels_up)
1395  {
1396  /* Found a matching variable, make the substitution */
1397  Node *newnode;
1398 
1399  newnode = context->callback(var, context);
1400  /* Detect if we are adding a sublink to query */
1401  if (!context->inserted_sublink)
1402  context->inserted_sublink = checkExprHasSubLink(newnode);
1403  return newnode;
1404  }
1405  /* otherwise fall through to copy the var normally */
1406  }
1407  else if (IsA(node, CurrentOfExpr))
1408  {
1409  CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
1410 
1411  if (cexpr->cvarno == context->target_varno &&
1412  context->sublevels_up == 0)
1413  {
1414  /*
1415  * We get here if a WHERE CURRENT OF expression turns out to apply
1416  * to a view. Someday we might be able to translate the
1417  * expression to apply to an underlying table of the view, but
1418  * right now it's not implemented.
1419  */
1420  ereport(ERROR,
1421  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1422  errmsg("WHERE CURRENT OF on a view is not implemented")));
1423  }
1424  /* otherwise fall through to copy the expr normally */
1425  }
1426  else if (IsA(node, Query))
1427  {
1428  /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1429  Query *newnode;
1430  bool save_inserted_sublink;
1431 
1432  context->sublevels_up++;
1433  save_inserted_sublink = context->inserted_sublink;
1434  context->inserted_sublink = ((Query *) node)->hasSubLinks;
1435  newnode = query_tree_mutator((Query *) node,
1437  (void *) context,
1438  0);
1439  newnode->hasSubLinks |= context->inserted_sublink;
1440  context->inserted_sublink = save_inserted_sublink;
1441  context->sublevels_up--;
1442  return (Node *) newnode;
1443  }
1445  (void *) context);
1446 }
#define expression_tree_mutator(n, m, c)
Definition: nodeFuncs.h:153
#define query_tree_mutator(q, m, c, f)
Definition: nodeFuncs.h:158
Definition: primnodes.h:223
int varno
Definition: primnodes.h:230
Index varlevelsup
Definition: primnodes.h:255

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_context::sublevels_up, replace_rte_variables_context::target_varno, Var::varlevelsup, and Var::varno.

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

◆ ReplaceVarsFromTargetList()

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

1771 {
1773 
1774  context.target_rte = target_rte;
1775  context.targetlist = targetlist;
1776  context.nomatch_option = nomatch_option;
1777  context.nomatch_varno = nomatch_varno;
1778 
1779  return replace_rte_variables(node, target_varno, sublevels_up,
1781  (void *) &context,
1782  outer_hasSubLinks);
1783 }
Node * replace_rte_variables(Node *node, int target_varno, int sublevels_up, replace_rte_variables_callback callback, void *callback_arg, bool *outer_hasSubLinks)
static Node * ReplaceVarsFromTargetList_callback(Var *var, replace_rte_variables_context *context)
ReplaceVarsNoMatchOption nomatch_option

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