PostgreSQL Source Code git master
rewriteManip.h File Reference
#include "nodes/parsenodes.h"
#include "nodes/pathnodes.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

Relids adjust_relid_set (Relids relids, int oldrelid, int newrelid)
 
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 ChangeVarNodesExtended (Node *node, int rt_index, int new_index, int sublevels_up, bool change_RangeTblRef)
 
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)
 
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)
 

Typedef Documentation

◆ replace_rte_variables_callback

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

Definition at line 25 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 37 of file rewriteManip.h.

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

Function Documentation

◆ add_nulling_relids()

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

Definition at line 1287 of file rewriteManip.c.

1290{
1292
1293 context.target_relids = target_relids;
1294 context.added_relids = added_relids;
1295 context.sublevels_up = 0;
1298 &context,
1299 0);
1300}
#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().

◆ AddInvertedQual()

void AddInvertedQual ( Query parsetree,
Node qual 
)

Definition at line 1263 of file rewriteManip.c.

1264{
1265 BooleanTest *invqual;
1266
1267 if (qual == NULL)
1268 return;
1269
1270 /* Need not copy input qual, because AddQual will... */
1271 invqual = makeNode(BooleanTest);
1272 invqual->arg = (Expr *) qual;
1273 invqual->booltesttype = IS_NOT_TRUE;
1274 invqual->location = -1;
1275
1276 AddQual(parsetree, (Node *) invqual);
1277}
#define makeNode(_type_)
Definition: nodes.h:157
@ 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
Definition: nodes.h:131

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

1196{
1197 Node *copy;
1198
1199 if (qual == NULL)
1200 return;
1201
1202 if (parsetree->commandType == CMD_UTILITY)
1203 {
1204 /*
1205 * There's noplace to put the qual on a utility statement.
1206 *
1207 * If it's a NOTIFY, silently ignore the qual; this means that the
1208 * NOTIFY will execute, whether or not there are any qualifying rows.
1209 * While clearly wrong, this is much more useful than refusing to
1210 * execute the rule at all, and extra NOTIFY events are harmless for
1211 * typical uses of NOTIFY.
1212 *
1213 * If it isn't a NOTIFY, error out, since unconditional execution of
1214 * other utility stmts is unlikely to be wanted. (This case is not
1215 * currently allowed anyway, but keep the test for safety.)
1216 */
1217 if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
1218 return;
1219 else
1220 ereport(ERROR,
1221 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1222 errmsg("conditional utility statements are not implemented")));
1223 }
1224
1225 if (parsetree->setOperations != NULL)
1226 {
1227 /*
1228 * There's noplace to put the qual on a setop statement, either. (This
1229 * could be fixed, but right now the planner simply ignores any qual
1230 * condition on a setop query.)
1231 */
1232 ereport(ERROR,
1233 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1234 errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
1235 }
1236
1237 /* INTERSECT wants the original, but we need to copy - Jan */
1238 copy = copyObject(qual);
1239
1240 parsetree->jointree->quals = make_and_qual(parsetree->jointree->quals,
1241 copy);
1242
1243 /*
1244 * We had better not have stuck an aggregate into the WHERE clause.
1245 */
1246 Assert(!contain_aggs_of_level(copy, 0));
1247
1248 /*
1249 * Make sure query is marked correctly if added qual has sublinks. Need
1250 * not search qual when query is already marked.
1251 */
1252 if (!parsetree->hasSubLinks)
1253 parsetree->hasSubLinks = checkExprHasSubLink(copy);
1254}
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#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
#define IsA(nodeptr, _type_)
Definition: nodes.h:160
#define copyObject(obj)
Definition: nodes.h:226
@ CMD_UTILITY
Definition: nodes.h:272
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 808 of file rewriteManip.c.

809{
810 if (!IS_SPECIAL_VARNO(oldrelid) && bms_is_member(oldrelid, relids))
811 {
812 /* Ensure we have a modifiable copy */
813 relids = bms_copy(relids);
814 /* Remove old, add new */
815 relids = bms_del_member(relids, oldrelid);
816 if (!IS_SPECIAL_VARNO(newrelid))
817 relids = bms_add_member(relids, newrelid);
818 }
819 return relids;
820}
Bitmapset * bms_del_member(Bitmapset *a, int x)
Definition: bitmapset.c:868
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
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(), and update_eclasses().

◆ ChangeVarNodes()

◆ ChangeVarNodesExtended()

void ChangeVarNodesExtended ( Node node,
int  rt_index,
int  new_index,
int  sublevels_up,
bool  change_RangeTblRef 
)

Definition at line 751 of file rewriteManip.c.

753{
755
756 context.rt_index = rt_index;
757 context.new_index = new_index;
758 context.sublevels_up = sublevels_up;
759 context.change_RangeTblRef = change_RangeTblRef;
760
761 if (node && IsA(node, Query))
762 {
763 Query *qry = (Query *) node;
764
765 if (sublevels_up == 0)
766 {
767 ListCell *l;
768
769 if (qry->resultRelation == rt_index)
770 qry->resultRelation = new_index;
771
772 if (qry->mergeTargetRelation == rt_index)
773 qry->mergeTargetRelation = new_index;
774
775 if (qry->onConflict && qry->onConflict->exclRelIndex == rt_index)
776 qry->onConflict->exclRelIndex = new_index;
777
778 foreach(l, qry->rowMarks)
779 {
781
782 if (rc->rti == rt_index)
783 rc->rti = new_index;
784 }
785 }
786 query_tree_walker(qry, ChangeVarNodes_walker, &context, 0);
787 }
788 else
789 ChangeVarNodes_walker(node, &context);
790}
#define query_tree_walker(q, w, c, f)
Definition: nodeFuncs.h:158
#define lfirst(lc)
Definition: pg_list.h:172
static bool ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
Definition: rewriteManip.c:562
List * rowMarks
Definition: parsenodes.h:228
OnConflictExpr * onConflict
Definition: parsenodes.h:198

References ChangeVarNodes_context::change_RangeTblRef, 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(), and remove_self_join_rel().

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

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

◆ getInsertSelectQuery()

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

Definition at line 1137 of file rewriteManip.c.

1138{
1139 Query *selectquery;
1140 RangeTblEntry *selectrte;
1141 RangeTblRef *rtr;
1142
1143 if (subquery_ptr)
1144 *subquery_ptr = NULL;
1145
1146 if (parsetree == NULL)
1147 return parsetree;
1148 if (parsetree->commandType != CMD_INSERT)
1149 return parsetree;
1150
1151 /*
1152 * Currently, this is ONLY applied to rule-action queries, and so we
1153 * expect to find the OLD and NEW placeholder entries in the given query.
1154 * If they're not there, it must be an INSERT/SELECT in which they've been
1155 * pushed down to the SELECT.
1156 */
1157 if (list_length(parsetree->rtable) >= 2 &&
1158 strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->aliasname,
1159 "old") == 0 &&
1160 strcmp(rt_fetch(PRS2_NEW_VARNO, parsetree->rtable)->eref->aliasname,
1161 "new") == 0)
1162 return parsetree;
1163 Assert(parsetree->jointree && IsA(parsetree->jointree, FromExpr));
1164 if (list_length(parsetree->jointree->fromlist) != 1)
1165 elog(ERROR, "expected to find SELECT subquery");
1166 rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
1167 if (!IsA(rtr, RangeTblRef))
1168 elog(ERROR, "expected to find SELECT subquery");
1169 selectrte = rt_fetch(rtr->rtindex, parsetree->rtable);
1170 if (!(selectrte->rtekind == RTE_SUBQUERY &&
1171 selectrte->subquery &&
1172 IsA(selectrte->subquery, Query) &&
1173 selectrte->subquery->commandType == CMD_SELECT))
1174 elog(ERROR, "expected to find SELECT subquery");
1175 selectquery = selectrte->subquery;
1176 if (list_length(selectquery->rtable) >= 2 &&
1177 strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->aliasname,
1178 "old") == 0 &&
1179 strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->aliasname,
1180 "new") == 0)
1181 {
1182 if (subquery_ptr)
1183 *subquery_ptr = &(selectrte->subquery);
1184 return selectquery;
1185 }
1186 elog(ERROR, "could not find rule placeholders");
1187 return NULL; /* not reached */
1188}
#define elog(elevel,...)
Definition: elog.h:225
@ CMD_INSERT
Definition: nodes.h:269
@ CMD_SELECT
Definition: nodes.h:267
@ 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:1113
RTEKind rtekind
Definition: parsenodes.h:1056

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

930{
932
933 context.delta_sublevels_up = delta_sublevels_up;
934 context.min_sublevels_up = min_sublevels_up;
935
936 /*
937 * Must be prepared to start with a Query or a bare expression tree; if
938 * it's a Query, we don't want to increment sublevels_up.
939 */
942 &context,
944}
#define QTW_EXAMINE_RTES_BEFORE
Definition: nodeFuncs.h:27
static bool IncrementVarSublevelsUp_walker(Node *node, IncrementVarSublevelsUp_context *context)
Definition: rewriteManip.c:848

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

953{
955
956 context.delta_sublevels_up = delta_sublevels_up;
957 context.min_sublevels_up = min_sublevels_up;
958
959 range_table_walker(rtable,
961 &context,
963}
#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().

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

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

◆ rangeTableEntry_used()

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

Definition at line 1105 of file rewriteManip.c.

1106{
1108
1109 context.rt_index = rt_index;
1110 context.sublevels_up = sublevels_up;
1111
1112 /*
1113 * Must be prepared to start with a Query or a bare expression tree; if
1114 * it's a Query, we don't want to increment sublevels_up.
1115 */
1118 &context,
1119 0);
1120}
static bool rangeTableEntry_used_walker(Node *node, rangeTableEntry_used_context *context)

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 
)

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

1486{
1487 Node *result;
1489
1490 context.callback = callback;
1491 context.callback_arg = callback_arg;
1492 context.target_varno = target_varno;
1493 context.sublevels_up = sublevels_up;
1494
1495 /*
1496 * We try to initialize inserted_sublink to true if there is no need to
1497 * detect new sublinks because the query already has some.
1498 */
1499 if (node && IsA(node, Query))
1500 context.inserted_sublink = ((Query *) node)->hasSubLinks;
1501 else if (outer_hasSubLinks)
1502 context.inserted_sublink = *outer_hasSubLinks;
1503 else
1504 context.inserted_sublink = false;
1505
1506 /*
1507 * Must be prepared to start with a Query or a bare expression tree; if
1508 * it's a Query, we don't want to increment sublevels_up.
1509 */
1512 &context,
1513 0);
1514
1515 if (context.inserted_sublink)
1516 {
1517 if (result && IsA(result, Query))
1518 ((Query *) result)->hasSubLinks = true;
1519 else if (outer_hasSubLinks)
1520 *outer_hasSubLinks = true;
1521 else
1522 elog(ERROR, "replace_rte_variables inserted a SubLink, but has noplace to record it");
1523 }
1524
1525 return result;
1526}
Node * replace_rte_variables_mutator(Node *node, replace_rte_variables_context *context)
replace_rte_variables_callback callback
Definition: rewriteManip.h:30
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 1529 of file rewriteManip.c.

1531{
1532 if (node == NULL)
1533 return NULL;
1534 if (IsA(node, Var))
1535 {
1536 Var *var = (Var *) node;
1537
1538 if (var->varno == context->target_varno &&
1539 var->varlevelsup == context->sublevels_up)
1540 {
1541 /* Found a matching variable, make the substitution */
1542 Node *newnode;
1543
1544 newnode = context->callback(var, context);
1545 /* Detect if we are adding a sublink to query */
1546 if (!context->inserted_sublink)
1547 context->inserted_sublink = checkExprHasSubLink(newnode);
1548 return newnode;
1549 }
1550 /* otherwise fall through to copy the var normally */
1551 }
1552 else if (IsA(node, CurrentOfExpr))
1553 {
1554 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
1555
1556 if (cexpr->cvarno == context->target_varno &&
1557 context->sublevels_up == 0)
1558 {
1559 /*
1560 * We get here if a WHERE CURRENT OF expression turns out to apply
1561 * to a view. Someday we might be able to translate the
1562 * expression to apply to an underlying table of the view, but
1563 * right now it's not implemented.
1564 */
1565 ereport(ERROR,
1566 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1567 errmsg("WHERE CURRENT OF on a view is not implemented")));
1568 }
1569 /* otherwise fall through to copy the expr normally */
1570 }
1571 else if (IsA(node, Query))
1572 {
1573 /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1574 Query *newnode;
1575 bool save_inserted_sublink;
1576
1577 context->sublevels_up++;
1578 save_inserted_sublink = context->inserted_sublink;
1579 context->inserted_sublink = ((Query *) node)->hasSubLinks;
1580 newnode = query_tree_mutator((Query *) node,
1582 context,
1583 0);
1584 newnode->hasSubLinks |= context->inserted_sublink;
1585 context->inserted_sublink = save_inserted_sublink;
1586 context->sublevels_up--;
1587 return (Node *) newnode;
1588 }
1590}
#define expression_tree_mutator(n, m, c)
Definition: nodeFuncs.h:155
#define query_tree_mutator(q, m, c, f)
Definition: nodeFuncs.h:160
Definition: primnodes.h:262
int varno
Definition: primnodes.h:269
Index varlevelsup
Definition: primnodes.h:294

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

1845{
1846 TargetEntry *tle;
1847
1848 if (var->varattno == InvalidAttrNumber)
1849 {
1850 /* Must expand whole-tuple reference into RowExpr */
1851 RowExpr *rowexpr;
1852 List *colnames;
1853 List *fields;
1854 ListCell *lc;
1855
1856 /*
1857 * If generating an expansion for a var of a named rowtype (ie, this
1858 * is a plain relation RTE), then we must include dummy items for
1859 * dropped columns. If the var is RECORD (ie, this is a JOIN), then
1860 * omit dropped columns. In the latter case, attach column names to
1861 * the RowExpr for use of the executor and ruleutils.c.
1862 *
1863 * In order to be able to cache the results, we always generate the
1864 * expansion with varlevelsup = 0. The caller is responsible for
1865 * adjusting it if needed.
1866 *
1867 * The varreturningtype is copied onto each individual field Var, so
1868 * that it is handled correctly when we recurse.
1869 */
1870 expandRTE(target_rte,
1871 var->varno, 0 /* not varlevelsup */ ,
1872 var->varreturningtype, var->location,
1873 (var->vartype != RECORDOID),
1874 &colnames, &fields);
1875 rowexpr = makeNode(RowExpr);
1876 /* the fields will be set below */
1877 rowexpr->args = NIL;
1878 rowexpr->row_typeid = var->vartype;
1879 rowexpr->row_format = COERCE_IMPLICIT_CAST;
1880 rowexpr->colnames = (var->vartype == RECORDOID) ? colnames : NIL;
1881 rowexpr->location = var->location;
1882 /* Adjust the generated per-field Vars... */
1883 foreach(lc, fields)
1884 {
1885 Node *field = lfirst(lc);
1886
1887 if (field && IsA(field, Var))
1888 field = ReplaceVarFromTargetList((Var *) field,
1889 target_rte,
1890 targetlist,
1891 result_relation,
1892 nomatch_option,
1893 nomatch_varno);
1894 rowexpr->args = lappend(rowexpr->args, field);
1895 }
1896
1897 /* Wrap it in a ReturningExpr, if needed, per comments above */
1899 {
1901
1902 rexpr->retlevelsup = 0;
1903 rexpr->retold = (var->varreturningtype == VAR_RETURNING_OLD);
1904 rexpr->retexpr = (Expr *) rowexpr;
1905
1906 return (Node *) rexpr;
1907 }
1908
1909 return (Node *) rowexpr;
1910 }
1911
1912 /* Normal case referencing one targetlist element */
1913 tle = get_tle_by_resno(targetlist, var->varattno);
1914
1915 if (tle == NULL || tle->resjunk)
1916 {
1917 /* Failed to find column in targetlist */
1918 switch (nomatch_option)
1919 {
1921 /* fall through, throw error below */
1922 break;
1923
1925 var = copyObject(var);
1926 var->varno = nomatch_varno;
1927 var->varlevelsup = 0;
1928 /* we leave the syntactic referent alone */
1929 return (Node *) var;
1930
1932 {
1933 /*
1934 * If Var is of domain type, we must add a CoerceToDomain
1935 * node, in case there is a NOT NULL domain constraint.
1936 */
1937 int16 vartyplen;
1938 bool vartypbyval;
1939
1940 get_typlenbyval(var->vartype, &vartyplen, &vartypbyval);
1941 return coerce_null_to_domain(var->vartype,
1942 var->vartypmod,
1943 var->varcollid,
1944 vartyplen,
1945 vartypbyval);
1946 }
1947 }
1948 elog(ERROR, "could not find replacement targetlist entry for attno %d",
1949 var->varattno);
1950 return NULL; /* keep compiler quiet */
1951 }
1952 else
1953 {
1954 /* Make a copy of the tlist item to return */
1955 Expr *newnode = copyObject(tle->expr);
1956
1957 /*
1958 * Check to see if the tlist item contains a PARAM_MULTIEXPR Param,
1959 * and throw error if so. This case could only happen when expanding
1960 * an ON UPDATE rule's NEW variable and the referenced tlist item in
1961 * the original UPDATE command is part of a multiple assignment. There
1962 * seems no practical way to handle such cases without multiple
1963 * evaluation of the multiple assignment's sub-select, which would
1964 * create semantic oddities that users of rules would probably prefer
1965 * not to cope with. So treat it as an unimplemented feature.
1966 */
1967 if (contains_multiexpr_param((Node *) newnode, NULL))
1968 ereport(ERROR,
1969 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1970 errmsg("NEW variables in ON UPDATE rules cannot reference columns that are part of a multiple assignment in the subject UPDATE command")));
1971
1972 /* Handle any OLD/NEW RETURNING list Vars */
1974 {
1975 /*
1976 * Copy varreturningtype onto any Vars in the tlist item that
1977 * refer to result_relation (which had better be non-zero).
1978 */
1979 if (result_relation == 0)
1980 elog(ERROR, "variable returning old/new found outside RETURNING list");
1981
1982 SetVarReturningType((Node *) newnode, result_relation,
1983 0, var->varreturningtype);
1984
1985 /* Wrap it in a ReturningExpr, if needed, per comments above */
1986 if (!IsA(newnode, Var) ||
1987 ((Var *) newnode)->varno != result_relation ||
1988 ((Var *) newnode)->varlevelsup != 0)
1989 {
1991
1992 rexpr->retlevelsup = 0;
1993 rexpr->retold = (var->varreturningtype == VAR_RETURNING_OLD);
1994 rexpr->retexpr = newnode;
1995
1996 newnode = (Expr *) rexpr;
1997 }
1998 }
1999
2000 return (Node *) newnode;
2001 }
2002}
#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:2334
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
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:753
static bool contains_multiexpr_param(Node *node, void *context)
Definition: rewriteManip.c:321
static void SetVarReturningType(Node *node, int result_relation, int sublevels_up, VarReturningType returning_type)
Node * ReplaceVarFromTargetList(Var *var, RangeTblEntry *target_rte, List *targetlist, int result_relation, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno)
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
AttrNumber varattno
Definition: primnodes.h:274
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 2005 of file rewriteManip.c.

2013{
2015
2016 context.target_rte = target_rte;
2017 context.targetlist = targetlist;
2018 context.result_relation = result_relation;
2019 context.nomatch_option = nomatch_option;
2020 context.nomatch_varno = nomatch_varno;
2021
2022 return replace_rte_variables(node, target_varno, sublevels_up,
2024 &context,
2025 outer_hasSubLinks);
2026}
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().