Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * rewriteManip.c
4 : *
5 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
6 : * Portions Copyright (c) 1994, Regents of the University of California
7 : *
8 : *
9 : * IDENTIFICATION
10 : * src/backend/rewrite/rewriteManip.c
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 : #include "postgres.h"
15 :
16 : #include "access/attmap.h"
17 : #include "catalog/pg_type.h"
18 : #include "nodes/makefuncs.h"
19 : #include "nodes/nodeFuncs.h"
20 : #include "nodes/pathnodes.h"
21 : #include "nodes/plannodes.h"
22 : #include "parser/parse_coerce.h"
23 : #include "parser/parse_relation.h"
24 : #include "parser/parsetree.h"
25 : #include "rewrite/rewriteManip.h"
26 : #include "utils/lsyscache.h"
27 :
28 :
29 : typedef struct
30 : {
31 : int sublevels_up;
32 : } contain_aggs_of_level_context;
33 :
34 : typedef struct
35 : {
36 : int agg_location;
37 : int sublevels_up;
38 : } locate_agg_of_level_context;
39 :
40 : typedef struct
41 : {
42 : int win_location;
43 : } locate_windowfunc_context;
44 :
45 : typedef struct
46 : {
47 : const Bitmapset *target_relids;
48 : const Bitmapset *added_relids;
49 : int sublevels_up;
50 : } add_nulling_relids_context;
51 :
52 : typedef struct
53 : {
54 : const Bitmapset *removable_relids;
55 : const Bitmapset *except_relids;
56 : int sublevels_up;
57 : } remove_nulling_relids_context;
58 :
59 : static bool contain_aggs_of_level_walker(Node *node,
60 : contain_aggs_of_level_context *context);
61 : static bool locate_agg_of_level_walker(Node *node,
62 : locate_agg_of_level_context *context);
63 : static bool contain_windowfuncs_walker(Node *node, void *context);
64 : static bool locate_windowfunc_walker(Node *node,
65 : locate_windowfunc_context *context);
66 : static bool checkExprHasSubLink_walker(Node *node, void *context);
67 : static Relids offset_relid_set(Relids relids, int offset);
68 : static Node *add_nulling_relids_mutator(Node *node,
69 : add_nulling_relids_context *context);
70 : static Node *remove_nulling_relids_mutator(Node *node,
71 : remove_nulling_relids_context *context);
72 :
73 :
74 : /*
75 : * contain_aggs_of_level -
76 : * Check if an expression contains an aggregate function call of a
77 : * specified query level.
78 : *
79 : * The objective of this routine is to detect whether there are aggregates
80 : * belonging to the given query level. Aggregates belonging to subqueries
81 : * or outer queries do NOT cause a true result. We must recurse into
82 : * subqueries to detect outer-reference aggregates that logically belong to
83 : * the specified query level.
84 : */
85 : bool
86 566 : contain_aggs_of_level(Node *node, int levelsup)
87 : {
88 : contain_aggs_of_level_context context;
89 :
90 566 : context.sublevels_up = levelsup;
91 :
92 : /*
93 : * Must be prepared to start with a Query or a bare expression tree; if
94 : * it's a Query, we don't want to increment sublevels_up.
95 : */
96 566 : return query_or_expression_tree_walker(node,
97 : contain_aggs_of_level_walker,
98 : &context,
99 : 0);
100 : }
101 :
102 : static bool
103 1282 : contain_aggs_of_level_walker(Node *node,
104 : contain_aggs_of_level_context *context)
105 : {
106 1282 : if (node == NULL)
107 316 : return false;
108 966 : if (IsA(node, Aggref))
109 : {
110 36 : if (((Aggref *) node)->agglevelsup == context->sublevels_up)
111 36 : return true; /* abort the tree traversal and return true */
112 : /* else fall through to examine argument */
113 : }
114 930 : if (IsA(node, GroupingFunc))
115 : {
116 0 : if (((GroupingFunc *) node)->agglevelsup == context->sublevels_up)
117 0 : return true;
118 : /* else fall through to examine argument */
119 : }
120 930 : if (IsA(node, Query))
121 : {
122 : /* Recurse into subselects */
123 : bool result;
124 :
125 18 : context->sublevels_up++;
126 18 : result = query_tree_walker((Query *) node,
127 : contain_aggs_of_level_walker,
128 : context, 0);
129 18 : context->sublevels_up--;
130 18 : return result;
131 : }
132 912 : return expression_tree_walker(node, contain_aggs_of_level_walker,
133 : context);
134 : }
135 :
136 : /*
137 : * locate_agg_of_level -
138 : * Find the parse location of any aggregate of the specified query level.
139 : *
140 : * Returns -1 if no such agg is in the querytree, or if they all have
141 : * unknown parse location. (The former case is probably caller error,
142 : * but we don't bother to distinguish it from the latter case.)
143 : *
144 : * Note: it might seem appropriate to merge this functionality into
145 : * contain_aggs_of_level, but that would complicate that function's API.
146 : * Currently, the only uses of this function are for error reporting,
147 : * and so shaving cycles probably isn't very important.
148 : */
149 : int
150 40 : locate_agg_of_level(Node *node, int levelsup)
151 : {
152 : locate_agg_of_level_context context;
153 :
154 40 : context.agg_location = -1; /* in case we find nothing */
155 40 : context.sublevels_up = levelsup;
156 :
157 : /*
158 : * Must be prepared to start with a Query or a bare expression tree; if
159 : * it's a Query, we don't want to increment sublevels_up.
160 : */
161 40 : (void) query_or_expression_tree_walker(node,
162 : locate_agg_of_level_walker,
163 : &context,
164 : 0);
165 :
166 40 : return context.agg_location;
167 : }
168 :
169 : static bool
170 160 : locate_agg_of_level_walker(Node *node,
171 : locate_agg_of_level_context *context)
172 : {
173 160 : if (node == NULL)
174 8 : return false;
175 152 : if (IsA(node, Aggref))
176 : {
177 36 : if (((Aggref *) node)->agglevelsup == context->sublevels_up &&
178 32 : ((Aggref *) node)->location >= 0)
179 : {
180 32 : context->agg_location = ((Aggref *) node)->location;
181 32 : return true; /* abort the tree traversal and return true */
182 : }
183 : /* else fall through to examine argument */
184 : }
185 120 : if (IsA(node, GroupingFunc))
186 : {
187 0 : if (((GroupingFunc *) node)->agglevelsup == context->sublevels_up &&
188 0 : ((GroupingFunc *) node)->location >= 0)
189 : {
190 0 : context->agg_location = ((GroupingFunc *) node)->location;
191 0 : return true; /* abort the tree traversal and return true */
192 : }
193 : }
194 120 : if (IsA(node, Query))
195 : {
196 : /* Recurse into subselects */
197 : bool result;
198 :
199 8 : context->sublevels_up++;
200 8 : result = query_tree_walker((Query *) node,
201 : locate_agg_of_level_walker,
202 : context, 0);
203 8 : context->sublevels_up--;
204 8 : return result;
205 : }
206 112 : return expression_tree_walker(node, locate_agg_of_level_walker, context);
207 : }
208 :
209 : /*
210 : * contain_windowfuncs -
211 : * Check if an expression contains a window function call of the
212 : * current query level.
213 : */
214 : bool
215 8091 : contain_windowfuncs(Node *node)
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 : */
221 8091 : return query_or_expression_tree_walker(node,
222 : contain_windowfuncs_walker,
223 : NULL,
224 : 0);
225 : }
226 :
227 : static bool
228 8863 : contain_windowfuncs_walker(Node *node, void *context)
229 : {
230 8863 : if (node == NULL)
231 112 : return false;
232 8751 : if (IsA(node, WindowFunc))
233 13 : return true; /* abort the tree traversal and return true */
234 : /* Mustn't recurse into subselects */
235 8738 : return expression_tree_walker(node, contain_windowfuncs_walker, context);
236 : }
237 :
238 : /*
239 : * locate_windowfunc -
240 : * Find the parse location of any windowfunc of the current query level.
241 : *
242 : * Returns -1 if no such windowfunc is in the querytree, or if they all have
243 : * unknown parse location. (The former case is probably caller error,
244 : * but we don't bother to distinguish it from the latter case.)
245 : *
246 : * Note: it might seem appropriate to merge this functionality into
247 : * contain_windowfuncs, but that would complicate that function's API.
248 : * Currently, the only uses of this function are for error reporting,
249 : * and so shaving cycles probably isn't very important.
250 : */
251 : int
252 4 : locate_windowfunc(Node *node)
253 : {
254 : locate_windowfunc_context context;
255 :
256 4 : context.win_location = -1; /* in case we find nothing */
257 :
258 : /*
259 : * Must be prepared to start with a Query or a bare expression tree; if
260 : * it's a Query, we don't want to increment sublevels_up.
261 : */
262 4 : (void) query_or_expression_tree_walker(node,
263 : locate_windowfunc_walker,
264 : &context,
265 : 0);
266 :
267 4 : return context.win_location;
268 : }
269 :
270 : static bool
271 4 : locate_windowfunc_walker(Node *node, locate_windowfunc_context *context)
272 : {
273 4 : if (node == NULL)
274 0 : return false;
275 4 : if (IsA(node, WindowFunc))
276 : {
277 4 : if (((WindowFunc *) node)->location >= 0)
278 : {
279 4 : context->win_location = ((WindowFunc *) node)->location;
280 4 : return true; /* abort the tree traversal and return true */
281 : }
282 : /* else fall through to examine argument */
283 : }
284 : /* Mustn't recurse into subselects */
285 0 : return expression_tree_walker(node, locate_windowfunc_walker, context);
286 : }
287 :
288 : /*
289 : * checkExprHasSubLink -
290 : * Check if an expression contains a SubLink.
291 : */
292 : bool
293 101130 : checkExprHasSubLink(Node *node)
294 : {
295 : /*
296 : * If a Query is passed, examine it --- but we should not recurse into
297 : * sub-Queries that are in its rangetable or CTE list.
298 : */
299 101130 : return query_or_expression_tree_walker(node,
300 : checkExprHasSubLink_walker,
301 : NULL,
302 : QTW_IGNORE_RC_SUBQUERIES);
303 : }
304 :
305 : static bool
306 172631 : checkExprHasSubLink_walker(Node *node, void *context)
307 : {
308 172631 : if (node == NULL)
309 3161 : return false;
310 169470 : if (IsA(node, SubLink))
311 1291 : return true; /* abort the tree traversal and return true */
312 168179 : return expression_tree_walker(node, checkExprHasSubLink_walker, context);
313 : }
314 :
315 : /*
316 : * Check for MULTIEXPR Param within expression tree
317 : *
318 : * We intentionally don't descend into SubLinks: only Params at the current
319 : * query level are of interest.
320 : */
321 : static bool
322 157371 : contains_multiexpr_param(Node *node, void *context)
323 : {
324 157371 : if (node == NULL)
325 2560 : return false;
326 154811 : if (IsA(node, Param))
327 : {
328 401 : if (((Param *) node)->paramkind == PARAM_MULTIEXPR)
329 0 : return true; /* abort the tree traversal and return true */
330 401 : return false;
331 : }
332 154410 : return expression_tree_walker(node, contains_multiexpr_param, context);
333 : }
334 :
335 : /*
336 : * CombineRangeTables
337 : * Adds the RTEs of 'src_rtable' into 'dst_rtable'
338 : *
339 : * This also adds the RTEPermissionInfos of 'src_perminfos' (belonging to the
340 : * RTEs in 'src_rtable') into *dst_perminfos and also updates perminfoindex of
341 : * the RTEs in 'src_rtable' to now point to the perminfos' indexes in
342 : * *dst_perminfos.
343 : *
344 : * Note that this changes both 'dst_rtable' and 'dst_perminfos' destructively,
345 : * so the caller should have better passed safe-to-modify copies.
346 : */
347 : void
348 39245 : CombineRangeTables(List **dst_rtable, List **dst_perminfos,
349 : List *src_rtable, List *src_perminfos)
350 : {
351 : ListCell *l;
352 39245 : int offset = list_length(*dst_perminfos);
353 :
354 39245 : if (offset > 0)
355 : {
356 97533 : foreach(l, src_rtable)
357 : {
358 64842 : RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
359 :
360 64842 : if (rte->perminfoindex > 0)
361 30824 : rte->perminfoindex += offset;
362 : }
363 : }
364 :
365 39245 : *dst_perminfos = list_concat(*dst_perminfos, src_perminfos);
366 39245 : *dst_rtable = list_concat(*dst_rtable, src_rtable);
367 39245 : }
368 :
369 : /*
370 : * OffsetVarNodes - adjust Vars when appending one query's RT to another
371 : *
372 : * Find all Var nodes in the given tree with varlevelsup == sublevels_up,
373 : * and increment their varno fields (rangetable indexes) by 'offset'.
374 : * The varnosyn fields are adjusted similarly. Also, adjust other nodes
375 : * that contain rangetable indexes, such as RangeTblRef and JoinExpr.
376 : *
377 : * NOTE: although this has the form of a walker, we cheat and modify the
378 : * nodes in-place. The given expression tree should have been copied
379 : * earlier to ensure that no unwanted side-effects occur!
380 : */
381 :
382 : typedef struct
383 : {
384 : int offset;
385 : int sublevels_up;
386 : } OffsetVarNodes_context;
387 :
388 : static bool
389 1870246 : OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
390 : {
391 1870246 : if (node == NULL)
392 613904 : return false;
393 1256342 : if (IsA(node, Var))
394 : {
395 641626 : Var *var = (Var *) node;
396 :
397 641626 : if (var->varlevelsup == context->sublevels_up)
398 : {
399 569975 : var->varno += context->offset;
400 569975 : var->varnullingrels = offset_relid_set(var->varnullingrels,
401 : context->offset);
402 569975 : if (var->varnosyn > 0)
403 569975 : var->varnosyn += context->offset;
404 : }
405 641626 : return false;
406 : }
407 614716 : if (IsA(node, CurrentOfExpr))
408 : {
409 0 : CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
410 :
411 0 : if (context->sublevels_up == 0)
412 0 : cexpr->cvarno += context->offset;
413 0 : return false;
414 : }
415 614716 : if (IsA(node, RangeTblRef))
416 : {
417 52945 : RangeTblRef *rtr = (RangeTblRef *) node;
418 :
419 52945 : if (context->sublevels_up == 0)
420 47872 : rtr->rtindex += context->offset;
421 : /* the subquery itself is visited separately */
422 52945 : return false;
423 : }
424 561771 : if (IsA(node, JoinExpr))
425 : {
426 11123 : JoinExpr *j = (JoinExpr *) node;
427 :
428 11123 : if (j->rtindex && context->sublevels_up == 0)
429 10113 : j->rtindex += context->offset;
430 : /* fall through to examine children */
431 : }
432 561771 : if (IsA(node, PlaceHolderVar))
433 : {
434 389 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
435 :
436 389 : if (phv->phlevelsup == context->sublevels_up)
437 : {
438 299 : phv->phrels = offset_relid_set(phv->phrels,
439 : context->offset);
440 299 : phv->phnullingrels = offset_relid_set(phv->phnullingrels,
441 : context->offset);
442 : }
443 : /* fall through to examine children */
444 : }
445 561771 : if (IsA(node, AppendRelInfo))
446 : {
447 731 : AppendRelInfo *appinfo = (AppendRelInfo *) node;
448 :
449 731 : if (context->sublevels_up == 0)
450 : {
451 731 : appinfo->parent_relid += context->offset;
452 731 : appinfo->child_relid += context->offset;
453 : }
454 : /* fall through to examine children */
455 : }
456 : /* Shouldn't need to handle other planner auxiliary nodes here */
457 : Assert(!IsA(node, PlanRowMark));
458 : Assert(!IsA(node, SpecialJoinInfo));
459 : Assert(!IsA(node, PlaceHolderInfo));
460 : Assert(!IsA(node, MinMaxAggInfo));
461 :
462 561771 : if (IsA(node, Query))
463 : {
464 : /* Recurse into subselects */
465 : bool result;
466 :
467 4171 : context->sublevels_up++;
468 4171 : result = query_tree_walker((Query *) node, OffsetVarNodes_walker,
469 : context, 0);
470 4171 : context->sublevels_up--;
471 4171 : return result;
472 : }
473 557600 : return expression_tree_walker(node, OffsetVarNodes_walker, context);
474 : }
475 :
476 : void
477 70450 : OffsetVarNodes(Node *node, int offset, int sublevels_up)
478 : {
479 : OffsetVarNodes_context context;
480 :
481 70450 : context.offset = offset;
482 70450 : context.sublevels_up = sublevels_up;
483 :
484 : /*
485 : * Must be prepared to start with a Query or a bare expression tree; if
486 : * it's a Query, go straight to query_tree_walker to make sure that
487 : * sublevels_up doesn't get incremented prematurely.
488 : */
489 70450 : if (node && IsA(node, Query))
490 35225 : {
491 35225 : Query *qry = (Query *) node;
492 :
493 : /*
494 : * If we are starting at a Query, and sublevels_up is zero, then we
495 : * must also fix rangetable indexes in the Query itself --- namely
496 : * resultRelation, mergeTargetRelation, exclRelIndex and rowMarks
497 : * entries. sublevels_up cannot be zero when recursing into a
498 : * subquery, so there's no need to have the same logic inside
499 : * OffsetVarNodes_walker.
500 : */
501 35225 : if (sublevels_up == 0)
502 : {
503 : ListCell *l;
504 :
505 35225 : if (qry->resultRelation)
506 868 : qry->resultRelation += offset;
507 :
508 35225 : if (qry->mergeTargetRelation)
509 0 : qry->mergeTargetRelation += offset;
510 :
511 35225 : if (qry->onConflict && qry->onConflict->exclRelIndex)
512 44 : qry->onConflict->exclRelIndex += offset;
513 :
514 35333 : foreach(l, qry->rowMarks)
515 : {
516 108 : RowMarkClause *rc = (RowMarkClause *) lfirst(l);
517 :
518 108 : rc->rti += offset;
519 : }
520 : }
521 35225 : query_tree_walker(qry, OffsetVarNodes_walker, &context, 0);
522 : }
523 : else
524 35225 : OffsetVarNodes_walker(node, &context);
525 70450 : }
526 :
527 : static Relids
528 570573 : offset_relid_set(Relids relids, int offset)
529 : {
530 570573 : Relids result = NULL;
531 : int rtindex;
532 :
533 570573 : rtindex = -1;
534 661376 : while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
535 90803 : result = bms_add_member(result, rtindex + offset);
536 570573 : return result;
537 : }
538 :
539 : /*
540 : * ChangeVarNodes - adjust Var nodes for a specific change of RT index
541 : *
542 : * Find all Var nodes in the given tree belonging to a specific relation
543 : * (identified by sublevels_up and rt_index), and change their varno fields
544 : * to 'new_index'. The varnosyn fields are changed too. Also, adjust other
545 : * nodes that contain rangetable indexes, such as RangeTblRef and JoinExpr.
546 : *
547 : * NOTE: although this has the form of a walker, we cheat and modify the
548 : * nodes in-place. The given expression tree should have been copied
549 : * earlier to ensure that no unwanted side-effects occur!
550 : */
551 :
552 : static bool
553 279594 : ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
554 : {
555 279594 : if (node == NULL)
556 90963 : return false;
557 :
558 188631 : if (context->callback && context->callback(node, context))
559 3620 : return false;
560 :
561 185011 : if (IsA(node, Var))
562 : {
563 66041 : Var *var = (Var *) node;
564 :
565 66041 : if (var->varlevelsup == context->sublevels_up)
566 : {
567 63739 : if (var->varno == context->rt_index)
568 46504 : var->varno = context->new_index;
569 63739 : var->varnullingrels = adjust_relid_set(var->varnullingrels,
570 : context->rt_index,
571 : context->new_index);
572 63739 : if (var->varnosyn == context->rt_index)
573 46504 : var->varnosyn = context->new_index;
574 : }
575 66041 : return false;
576 : }
577 118970 : if (IsA(node, CurrentOfExpr))
578 : {
579 0 : CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
580 :
581 0 : if (context->sublevels_up == 0 &&
582 0 : cexpr->cvarno == context->rt_index)
583 0 : cexpr->cvarno = context->new_index;
584 0 : return false;
585 : }
586 118970 : if (IsA(node, RangeTblRef))
587 : {
588 3690 : RangeTblRef *rtr = (RangeTblRef *) node;
589 :
590 3690 : if (context->sublevels_up == 0 &&
591 2178 : rtr->rtindex == context->rt_index)
592 1146 : rtr->rtindex = context->new_index;
593 : /* the subquery itself is visited separately */
594 3690 : return false;
595 : }
596 115280 : if (IsA(node, JoinExpr))
597 : {
598 518 : JoinExpr *j = (JoinExpr *) node;
599 :
600 518 : if (context->sublevels_up == 0 &&
601 518 : j->rtindex == context->rt_index)
602 0 : j->rtindex = context->new_index;
603 : /* fall through to examine children */
604 : }
605 115280 : if (IsA(node, PlaceHolderVar))
606 : {
607 80 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
608 :
609 80 : if (phv->phlevelsup == context->sublevels_up)
610 : {
611 80 : phv->phrels = adjust_relid_set(phv->phrels,
612 : context->rt_index,
613 : context->new_index);
614 80 : phv->phnullingrels = adjust_relid_set(phv->phnullingrels,
615 : context->rt_index,
616 : context->new_index);
617 : }
618 : /* fall through to examine children */
619 : }
620 115280 : if (IsA(node, PlanRowMark))
621 : {
622 0 : PlanRowMark *rowmark = (PlanRowMark *) node;
623 :
624 0 : if (context->sublevels_up == 0)
625 : {
626 0 : if (rowmark->rti == context->rt_index)
627 0 : rowmark->rti = context->new_index;
628 0 : if (rowmark->prti == context->rt_index)
629 0 : rowmark->prti = context->new_index;
630 : }
631 0 : return false;
632 : }
633 115280 : if (IsA(node, AppendRelInfo))
634 : {
635 0 : AppendRelInfo *appinfo = (AppendRelInfo *) node;
636 :
637 0 : if (context->sublevels_up == 0)
638 : {
639 0 : if (appinfo->parent_relid == context->rt_index)
640 0 : appinfo->parent_relid = context->new_index;
641 0 : if (appinfo->child_relid == context->rt_index)
642 0 : appinfo->child_relid = context->new_index;
643 : }
644 : /* fall through to examine children */
645 : }
646 : /* Shouldn't need to handle other planner auxiliary nodes here */
647 : Assert(!IsA(node, SpecialJoinInfo));
648 : Assert(!IsA(node, PlaceHolderInfo));
649 : Assert(!IsA(node, MinMaxAggInfo));
650 :
651 115280 : if (IsA(node, Query))
652 : {
653 : /* Recurse into subselects */
654 : bool result;
655 :
656 1729 : context->sublevels_up++;
657 1729 : result = query_tree_walker((Query *) node, ChangeVarNodes_walker,
658 : context, 0);
659 1729 : context->sublevels_up--;
660 1729 : return result;
661 : }
662 113551 : return expression_tree_walker(node, ChangeVarNodes_walker, context);
663 : }
664 :
665 : /*
666 : * ChangeVarNodesExtended - similar to ChangeVarNodes, but with an additional
667 : * 'callback' param
668 : *
669 : * ChangeVarNodes changes a given node and all of its underlying nodes. This
670 : * version of function additionally takes a callback, which has a chance to
671 : * process a node before ChangeVarNodes_walker. A callback returns a boolean
672 : * value indicating if the given node should be skipped from further processing
673 : * by ChangeVarNodes_walker. The callback is called only for expressions and
674 : * other children nodes of a Query processed by a walker. Initial processing
675 : * of the root Query node doesn't invoke the callback.
676 : */
677 : void
678 40871 : ChangeVarNodesExtended(Node *node, int rt_index, int new_index,
679 : int sublevels_up, ChangeVarNodes_callback callback)
680 : {
681 : ChangeVarNodes_context context;
682 :
683 40871 : context.rt_index = rt_index;
684 40871 : context.new_index = new_index;
685 40871 : context.sublevels_up = sublevels_up;
686 40871 : context.callback = callback;
687 :
688 : /*
689 : * Must be prepared to start with a Query or a bare expression tree; if
690 : * it's a Query, go straight to query_tree_walker to make sure that
691 : * sublevels_up doesn't get incremented prematurely.
692 : */
693 40871 : if (node && IsA(node, Query))
694 3622 : {
695 3622 : Query *qry = (Query *) node;
696 :
697 : /*
698 : * If we are starting at a Query, and sublevels_up is zero, then we
699 : * must also fix rangetable indexes in the Query itself --- namely
700 : * resultRelation, mergeTargetRelation, exclRelIndex and rowMarks
701 : * entries. sublevels_up cannot be zero when recursing into a
702 : * subquery, so there's no need to have the same logic inside
703 : * ChangeVarNodes_walker.
704 : */
705 3622 : if (sublevels_up == 0)
706 : {
707 : ListCell *l;
708 :
709 3622 : if (qry->resultRelation == rt_index)
710 2210 : qry->resultRelation = new_index;
711 :
712 3622 : if (qry->mergeTargetRelation == rt_index)
713 568 : qry->mergeTargetRelation = new_index;
714 :
715 : /* this is unlikely to ever be used, but ... */
716 3622 : if (qry->onConflict && qry->onConflict->exclRelIndex == rt_index)
717 0 : qry->onConflict->exclRelIndex = new_index;
718 :
719 3720 : foreach(l, qry->rowMarks)
720 : {
721 98 : RowMarkClause *rc = (RowMarkClause *) lfirst(l);
722 :
723 98 : if (rc->rti == rt_index)
724 36 : rc->rti = new_index;
725 : }
726 : }
727 3622 : query_tree_walker(qry, ChangeVarNodes_walker, &context, 0);
728 : }
729 : else
730 37249 : ChangeVarNodes_walker(node, &context);
731 40871 : }
732 :
733 : void
734 31633 : ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
735 : {
736 31633 : ChangeVarNodesExtended(node, rt_index, new_index, sublevels_up, NULL);
737 31633 : }
738 :
739 : /*
740 : * ChangeVarNodesWalkExpression - process subexpression within a callback
741 : * function passed to ChangeVarNodesExtended.
742 : *
743 : * This is intended to be used by a callback that needs to recursively
744 : * process subexpressions of some node being visited by an outer
745 : * ChangeVarNodesExtended call, instead of relying on ChangeVarNodes_walker's
746 : * default recursion. We invoke ChangeVarNodes_walker directly rather than
747 : * via expression_tree_walker, because expression_tree_walker only visits
748 : * child nodes and would fail to process the passed node itself --
749 : * for example, a bare Var node would not get its varno adjusted.
750 : *
751 : * Because this calls ChangeVarNodes_walker directly, if the passed node is
752 : * a Query, it will be treated as a sub-Query: sublevels_up is incremented
753 : * before recursing into it, and Query-level fields (resultRelation,
754 : * mergeTargetRelation, rowMarks, etc.) will not be adjusted. Do not apply
755 : * this to a top-level Query node; use ChangeVarNodesExtended for that.
756 : */
757 : bool
758 2906 : ChangeVarNodesWalkExpression(Node *node, ChangeVarNodes_context *context)
759 : {
760 2906 : return ChangeVarNodes_walker(node, context);
761 : }
762 :
763 : /*
764 : * adjust_relid_set - substitute newrelid for oldrelid in a Relid set
765 : *
766 : * Attempt to remove oldrelid from a Relid set (as long as it's not a special
767 : * varno). If oldrelid was found and removed, insert newrelid into a Relid
768 : * set (as long as it's not a special varno). Therefore, when oldrelid is
769 : * a special varno, this function does nothing. When newrelid is a special
770 : * varno, this function behaves as delete.
771 : */
772 : Relids
773 201253 : adjust_relid_set(Relids relids, int oldrelid, int newrelid)
774 : {
775 201253 : if (!IS_SPECIAL_VARNO(oldrelid) && bms_is_member(oldrelid, relids))
776 : {
777 : /* Ensure we have a modifiable copy */
778 70584 : relids = bms_copy(relids);
779 : /* Remove old, add new */
780 70584 : relids = bms_del_member(relids, oldrelid);
781 70584 : if (!IS_SPECIAL_VARNO(newrelid))
782 8046 : relids = bms_add_member(relids, newrelid);
783 : }
784 201253 : return relids;
785 : }
786 :
787 : /*
788 : * IncrementVarSublevelsUp - adjust Var nodes when pushing them down in tree
789 : *
790 : * Find all Var nodes in the given tree having varlevelsup >= min_sublevels_up,
791 : * and add delta_sublevels_up to their varlevelsup value. This is needed when
792 : * an expression that's correct for some nesting level is inserted into a
793 : * subquery. Ordinarily the initial call has min_sublevels_up == 0 so that
794 : * all Vars are affected. The point of min_sublevels_up is that we can
795 : * increment it when we recurse into a sublink, so that local variables in
796 : * that sublink are not affected, only outer references to vars that belong
797 : * to the expression's original query level or parents thereof.
798 : *
799 : * Likewise for other nodes containing levelsup fields, such as Aggref.
800 : *
801 : * NOTE: although this has the form of a walker, we cheat and modify the
802 : * Var nodes in-place. The given expression tree should have been copied
803 : * earlier to ensure that no unwanted side-effects occur!
804 : */
805 :
806 : typedef struct
807 : {
808 : int delta_sublevels_up;
809 : int min_sublevels_up;
810 : } IncrementVarSublevelsUp_context;
811 :
812 : static bool
813 2635862 : IncrementVarSublevelsUp_walker(Node *node,
814 : IncrementVarSublevelsUp_context *context)
815 : {
816 2635862 : if (node == NULL)
817 827996 : return false;
818 1807866 : if (IsA(node, Var))
819 : {
820 876005 : Var *var = (Var *) node;
821 :
822 876005 : if (var->varlevelsup >= context->min_sublevels_up)
823 11008 : var->varlevelsup += context->delta_sublevels_up;
824 876005 : return false; /* done here */
825 : }
826 931861 : if (IsA(node, CurrentOfExpr))
827 : {
828 : /* this should not happen */
829 0 : if (context->min_sublevels_up == 0)
830 0 : elog(ERROR, "cannot push down CurrentOfExpr");
831 0 : return false;
832 : }
833 931861 : if (IsA(node, Aggref))
834 : {
835 2210 : Aggref *agg = (Aggref *) node;
836 :
837 2210 : if (agg->agglevelsup >= context->min_sublevels_up)
838 77 : agg->agglevelsup += context->delta_sublevels_up;
839 : /* fall through to recurse into argument */
840 : }
841 931861 : if (IsA(node, GroupingFunc))
842 : {
843 57 : GroupingFunc *grp = (GroupingFunc *) node;
844 :
845 57 : if (grp->agglevelsup >= context->min_sublevels_up)
846 57 : grp->agglevelsup += context->delta_sublevels_up;
847 : /* fall through to recurse into argument */
848 : }
849 931861 : if (IsA(node, PlaceHolderVar))
850 : {
851 778 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
852 :
853 778 : if (phv->phlevelsup >= context->min_sublevels_up)
854 479 : phv->phlevelsup += context->delta_sublevels_up;
855 : /* fall through to recurse into argument */
856 : }
857 931861 : if (IsA(node, ReturningExpr))
858 : {
859 108 : ReturningExpr *rexpr = (ReturningExpr *) node;
860 :
861 108 : if (rexpr->retlevelsup >= context->min_sublevels_up)
862 108 : rexpr->retlevelsup += context->delta_sublevels_up;
863 : /* fall through to recurse into argument */
864 : }
865 931861 : if (IsA(node, RangeTblEntry))
866 : {
867 102079 : RangeTblEntry *rte = (RangeTblEntry *) node;
868 :
869 102079 : if (rte->rtekind == RTE_CTE)
870 : {
871 3800 : if (rte->ctelevelsup >= context->min_sublevels_up)
872 3775 : rte->ctelevelsup += context->delta_sublevels_up;
873 : }
874 102079 : return false; /* allow range_table_walker to continue */
875 : }
876 829782 : if (IsA(node, Query))
877 : {
878 : /* Recurse into subselects */
879 : bool result;
880 :
881 17554 : context->min_sublevels_up++;
882 17554 : result = query_tree_walker((Query *) node,
883 : IncrementVarSublevelsUp_walker,
884 : context,
885 : QTW_EXAMINE_RTES_BEFORE);
886 17554 : context->min_sublevels_up--;
887 17554 : return result;
888 : }
889 812228 : return expression_tree_walker(node, IncrementVarSublevelsUp_walker, context);
890 : }
891 :
892 : void
893 73981 : IncrementVarSublevelsUp(Node *node, int delta_sublevels_up,
894 : int min_sublevels_up)
895 : {
896 : IncrementVarSublevelsUp_context context;
897 :
898 73981 : context.delta_sublevels_up = delta_sublevels_up;
899 73981 : context.min_sublevels_up = min_sublevels_up;
900 :
901 : /*
902 : * Must be prepared to start with a Query or a bare expression tree; if
903 : * it's a Query, we don't want to increment sublevels_up.
904 : */
905 73981 : query_or_expression_tree_walker(node,
906 : IncrementVarSublevelsUp_walker,
907 : &context,
908 : QTW_EXAMINE_RTES_BEFORE);
909 73981 : }
910 :
911 : /*
912 : * IncrementVarSublevelsUp_rtable -
913 : * Same as IncrementVarSublevelsUp, but to be invoked on a range table.
914 : */
915 : void
916 4050 : IncrementVarSublevelsUp_rtable(List *rtable, int delta_sublevels_up,
917 : int min_sublevels_up)
918 : {
919 : IncrementVarSublevelsUp_context context;
920 :
921 4050 : context.delta_sublevels_up = delta_sublevels_up;
922 4050 : context.min_sublevels_up = min_sublevels_up;
923 :
924 4050 : range_table_walker(rtable,
925 : IncrementVarSublevelsUp_walker,
926 : &context,
927 : QTW_EXAMINE_RTES_BEFORE);
928 4050 : }
929 :
930 : /*
931 : * SetVarReturningType - adjust Var nodes for a specified varreturningtype.
932 : *
933 : * Find all Var nodes referring to the specified result relation in the given
934 : * expression and set their varreturningtype to the specified value.
935 : *
936 : * NOTE: although this has the form of a walker, we cheat and modify the
937 : * Var nodes in-place. The given expression tree should have been copied
938 : * earlier to ensure that no unwanted side-effects occur!
939 : */
940 :
941 : typedef struct
942 : {
943 : int result_relation;
944 : int sublevels_up;
945 : VarReturningType returning_type;
946 : } SetVarReturningType_context;
947 :
948 : static bool
949 1542 : SetVarReturningType_walker(Node *node, SetVarReturningType_context *context)
950 : {
951 1542 : if (node == NULL)
952 416 : return false;
953 1126 : if (IsA(node, Var))
954 : {
955 698 : Var *var = (Var *) node;
956 :
957 698 : if (var->varno == context->result_relation &&
958 658 : var->varlevelsup == context->sublevels_up)
959 658 : var->varreturningtype = context->returning_type;
960 :
961 698 : return false;
962 : }
963 :
964 428 : if (IsA(node, Query))
965 : {
966 : /* Recurse into subselects */
967 : bool result;
968 :
969 32 : context->sublevels_up++;
970 32 : result = query_tree_walker((Query *) node, SetVarReturningType_walker,
971 : context, 0);
972 32 : context->sublevels_up--;
973 32 : return result;
974 : }
975 396 : return expression_tree_walker(node, SetVarReturningType_walker, context);
976 : }
977 :
978 : static void
979 826 : SetVarReturningType(Node *node, int result_relation, int sublevels_up,
980 : VarReturningType returning_type)
981 : {
982 : SetVarReturningType_context context;
983 :
984 826 : context.result_relation = result_relation;
985 826 : context.sublevels_up = sublevels_up;
986 826 : context.returning_type = returning_type;
987 :
988 : /* Expect to start with an expression */
989 826 : SetVarReturningType_walker(node, &context);
990 826 : }
991 :
992 : /*
993 : * rangeTableEntry_used - detect whether an RTE is referenced somewhere
994 : * in var nodes or join or setOp trees of a query or expression.
995 : */
996 :
997 : typedef struct
998 : {
999 : int rt_index;
1000 : int sublevels_up;
1001 : } rangeTableEntry_used_context;
1002 :
1003 : static bool
1004 2845814 : rangeTableEntry_used_walker(Node *node,
1005 : rangeTableEntry_used_context *context)
1006 : {
1007 2845814 : if (node == NULL)
1008 567142 : return false;
1009 2278672 : if (IsA(node, Var))
1010 : {
1011 662987 : Var *var = (Var *) node;
1012 :
1013 662987 : if (var->varlevelsup == context->sublevels_up &&
1014 1055054 : (var->varno == context->rt_index ||
1015 419942 : bms_is_member(context->rt_index, var->varnullingrels)))
1016 215170 : return true;
1017 447817 : return false;
1018 : }
1019 1615685 : if (IsA(node, CurrentOfExpr))
1020 : {
1021 8 : CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
1022 :
1023 8 : if (context->sublevels_up == 0 &&
1024 8 : cexpr->cvarno == context->rt_index)
1025 0 : return true;
1026 8 : return false;
1027 : }
1028 1615677 : if (IsA(node, RangeTblRef))
1029 : {
1030 95614 : RangeTblRef *rtr = (RangeTblRef *) node;
1031 :
1032 95614 : if (rtr->rtindex == context->rt_index &&
1033 49002 : context->sublevels_up == 0)
1034 47321 : return true;
1035 : /* the subquery itself is visited separately */
1036 48293 : return false;
1037 : }
1038 1520063 : if (IsA(node, JoinExpr))
1039 : {
1040 33497 : JoinExpr *j = (JoinExpr *) node;
1041 :
1042 33497 : if (j->rtindex == context->rt_index &&
1043 52 : context->sublevels_up == 0)
1044 0 : return true;
1045 : /* fall through to examine children */
1046 : }
1047 : /* Shouldn't need to handle planner auxiliary nodes here */
1048 : Assert(!IsA(node, PlaceHolderVar));
1049 : Assert(!IsA(node, PlanRowMark));
1050 : Assert(!IsA(node, SpecialJoinInfo));
1051 : Assert(!IsA(node, AppendRelInfo));
1052 : Assert(!IsA(node, PlaceHolderInfo));
1053 : Assert(!IsA(node, MinMaxAggInfo));
1054 :
1055 1520063 : if (IsA(node, Query))
1056 : {
1057 : /* Recurse into subselects */
1058 : bool result;
1059 :
1060 10581 : context->sublevels_up++;
1061 10581 : result = query_tree_walker((Query *) node, rangeTableEntry_used_walker,
1062 : context, 0);
1063 10581 : context->sublevels_up--;
1064 10581 : return result;
1065 : }
1066 1509482 : return expression_tree_walker(node, rangeTableEntry_used_walker, context);
1067 : }
1068 :
1069 : bool
1070 273018 : rangeTableEntry_used(Node *node, int rt_index, int sublevels_up)
1071 : {
1072 : rangeTableEntry_used_context context;
1073 :
1074 273018 : context.rt_index = rt_index;
1075 273018 : context.sublevels_up = sublevels_up;
1076 :
1077 : /*
1078 : * Must be prepared to start with a Query or a bare expression tree; if
1079 : * it's a Query, we don't want to increment sublevels_up.
1080 : */
1081 273018 : return query_or_expression_tree_walker(node,
1082 : rangeTableEntry_used_walker,
1083 : &context,
1084 : 0);
1085 : }
1086 :
1087 :
1088 : /*
1089 : * If the given Query is an INSERT ... SELECT construct, extract and
1090 : * return the sub-Query node that represents the SELECT part. Otherwise
1091 : * return the given Query.
1092 : *
1093 : * If subquery_ptr is not NULL, then *subquery_ptr is set to the location
1094 : * of the link to the SELECT subquery inside parsetree, or NULL if not an
1095 : * INSERT ... SELECT.
1096 : *
1097 : * This is a hack needed because transformations on INSERT ... SELECTs that
1098 : * appear in rule actions should be applied to the source SELECT, not to the
1099 : * INSERT part. Perhaps this can be cleaned up with redesigned querytrees.
1100 : */
1101 : Query *
1102 2315 : getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
1103 : {
1104 : Query *selectquery;
1105 : RangeTblEntry *selectrte;
1106 : RangeTblRef *rtr;
1107 :
1108 2315 : if (subquery_ptr)
1109 944 : *subquery_ptr = NULL;
1110 :
1111 2315 : if (parsetree == NULL)
1112 0 : return parsetree;
1113 2315 : if (parsetree->commandType != CMD_INSERT)
1114 997 : return parsetree;
1115 :
1116 : /*
1117 : * Currently, this is ONLY applied to rule-action queries, and so we
1118 : * expect to find the OLD and NEW placeholder entries in the given query.
1119 : * If they're not there, it must be an INSERT/SELECT in which they've been
1120 : * pushed down to the SELECT.
1121 : */
1122 1318 : if (list_length(parsetree->rtable) >= 2 &&
1123 1318 : strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->aliasname,
1124 1202 : "old") == 0 &&
1125 1202 : strcmp(rt_fetch(PRS2_NEW_VARNO, parsetree->rtable)->eref->aliasname,
1126 : "new") == 0)
1127 1202 : return parsetree;
1128 : Assert(parsetree->jointree && IsA(parsetree->jointree, FromExpr));
1129 116 : if (list_length(parsetree->jointree->fromlist) != 1)
1130 0 : elog(ERROR, "expected to find SELECT subquery");
1131 116 : rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
1132 116 : if (!IsA(rtr, RangeTblRef))
1133 0 : elog(ERROR, "expected to find SELECT subquery");
1134 116 : selectrte = rt_fetch(rtr->rtindex, parsetree->rtable);
1135 116 : if (!(selectrte->rtekind == RTE_SUBQUERY &&
1136 116 : selectrte->subquery &&
1137 116 : IsA(selectrte->subquery, Query) &&
1138 116 : selectrte->subquery->commandType == CMD_SELECT))
1139 0 : elog(ERROR, "expected to find SELECT subquery");
1140 116 : selectquery = selectrte->subquery;
1141 116 : if (list_length(selectquery->rtable) >= 2 &&
1142 116 : strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->aliasname,
1143 116 : "old") == 0 &&
1144 116 : strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->aliasname,
1145 : "new") == 0)
1146 : {
1147 116 : if (subquery_ptr)
1148 40 : *subquery_ptr = &(selectrte->subquery);
1149 116 : return selectquery;
1150 : }
1151 0 : elog(ERROR, "could not find rule placeholders");
1152 : return NULL; /* not reached */
1153 : }
1154 :
1155 :
1156 : /*
1157 : * Add the given qualifier condition to the query's WHERE clause
1158 : */
1159 : void
1160 3345 : AddQual(Query *parsetree, Node *qual)
1161 : {
1162 : Node *copy;
1163 :
1164 3345 : if (qual == NULL)
1165 1200 : return;
1166 :
1167 2145 : if (parsetree->commandType == CMD_UTILITY)
1168 : {
1169 : /*
1170 : * There's noplace to put the qual on a utility statement.
1171 : *
1172 : * If it's a NOTIFY, silently ignore the qual; this means that the
1173 : * NOTIFY will execute, whether or not there are any qualifying rows.
1174 : * While clearly wrong, this is much more useful than refusing to
1175 : * execute the rule at all, and extra NOTIFY events are harmless for
1176 : * typical uses of NOTIFY.
1177 : *
1178 : * If it isn't a NOTIFY, error out, since unconditional execution of
1179 : * other utility stmts is unlikely to be wanted. (This case is not
1180 : * currently allowed anyway, but keep the test for safety.)
1181 : */
1182 0 : if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
1183 0 : return;
1184 : else
1185 0 : ereport(ERROR,
1186 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1187 : errmsg("conditional utility statements are not implemented")));
1188 : }
1189 :
1190 2145 : if (parsetree->setOperations != NULL)
1191 : {
1192 : /*
1193 : * There's noplace to put the qual on a setop statement, either. (This
1194 : * could be fixed, but right now the planner simply ignores any qual
1195 : * condition on a setop query.)
1196 : */
1197 0 : ereport(ERROR,
1198 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1199 : errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
1200 : }
1201 :
1202 : /* INTERSECT wants the original, but we need to copy - Jan */
1203 2145 : copy = copyObject(qual);
1204 :
1205 2145 : parsetree->jointree->quals = make_and_qual(parsetree->jointree->quals,
1206 : copy);
1207 :
1208 : /*
1209 : * We had better not have stuck an aggregate into the WHERE clause.
1210 : */
1211 : Assert(!contain_aggs_of_level(copy, 0));
1212 :
1213 : /*
1214 : * Make sure query is marked correctly if added qual has sublinks. Need
1215 : * not search qual when query is already marked.
1216 : */
1217 2145 : if (!parsetree->hasSubLinks)
1218 2117 : parsetree->hasSubLinks = checkExprHasSubLink(copy);
1219 : }
1220 :
1221 :
1222 : /*
1223 : * Invert the given clause and add it to the WHERE qualifications of the
1224 : * given querytree. Inversion means "x IS NOT TRUE", not just "NOT x",
1225 : * else we will do the wrong thing when x evaluates to NULL.
1226 : */
1227 : void
1228 296 : AddInvertedQual(Query *parsetree, Node *qual)
1229 : {
1230 : BooleanTest *invqual;
1231 :
1232 296 : if (qual == NULL)
1233 0 : return;
1234 :
1235 : /* Need not copy input qual, because AddQual will... */
1236 296 : invqual = makeNode(BooleanTest);
1237 296 : invqual->arg = (Expr *) qual;
1238 296 : invqual->booltesttype = IS_NOT_TRUE;
1239 296 : invqual->location = -1;
1240 :
1241 296 : AddQual(parsetree, (Node *) invqual);
1242 : }
1243 :
1244 :
1245 : /*
1246 : * add_nulling_relids() finds Vars and PlaceHolderVars that belong to any
1247 : * of the target_relids, and adds added_relids to their varnullingrels
1248 : * and phnullingrels fields. If target_relids is NULL, all level-zero
1249 : * Vars and PHVs are modified.
1250 : */
1251 : Node *
1252 5570 : add_nulling_relids(Node *node,
1253 : const Bitmapset *target_relids,
1254 : const Bitmapset *added_relids)
1255 : {
1256 : add_nulling_relids_context context;
1257 :
1258 5570 : context.target_relids = target_relids;
1259 5570 : context.added_relids = added_relids;
1260 5570 : context.sublevels_up = 0;
1261 5570 : return query_or_expression_tree_mutator(node,
1262 : add_nulling_relids_mutator,
1263 : &context,
1264 : 0);
1265 : }
1266 :
1267 : static Node *
1268 23458 : add_nulling_relids_mutator(Node *node,
1269 : add_nulling_relids_context *context)
1270 : {
1271 23458 : if (node == NULL)
1272 950 : return NULL;
1273 22508 : if (IsA(node, Var))
1274 : {
1275 8454 : Var *var = (Var *) node;
1276 :
1277 8454 : if (var->varlevelsup == context->sublevels_up &&
1278 16728 : (context->target_relids == NULL ||
1279 8279 : bms_is_member(var->varno, context->target_relids)))
1280 : {
1281 4762 : Relids newnullingrels = bms_union(var->varnullingrels,
1282 : context->added_relids);
1283 :
1284 : /* Copy the Var ... */
1285 4762 : var = copyObject(var);
1286 : /* ... and replace the copy's varnullingrels field */
1287 4762 : var->varnullingrels = newnullingrels;
1288 4762 : return (Node *) var;
1289 : }
1290 : /* Otherwise fall through to copy the Var normally */
1291 : }
1292 14054 : else if (IsA(node, PlaceHolderVar))
1293 : {
1294 827 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
1295 :
1296 827 : if (phv->phlevelsup == context->sublevels_up &&
1297 1654 : (context->target_relids == NULL ||
1298 827 : bms_overlap(phv->phrels, context->target_relids)))
1299 : {
1300 827 : Relids newnullingrels = bms_union(phv->phnullingrels,
1301 : context->added_relids);
1302 :
1303 : /*
1304 : * We don't modify the contents of the PHV's expression, only add
1305 : * to phnullingrels. This corresponds to assuming that the PHV
1306 : * will be evaluated at the same level as before, then perhaps be
1307 : * nulled as it bubbles up. Hence, just flat-copy the node ...
1308 : */
1309 827 : phv = makeNode(PlaceHolderVar);
1310 827 : memcpy(phv, node, sizeof(PlaceHolderVar));
1311 : /* ... and replace the copy's phnullingrels field */
1312 827 : phv->phnullingrels = newnullingrels;
1313 827 : return (Node *) phv;
1314 : }
1315 : /* Otherwise fall through to copy the PlaceHolderVar normally */
1316 : }
1317 13227 : else if (IsA(node, Query))
1318 : {
1319 : /* Recurse into RTE or sublink subquery */
1320 : Query *newnode;
1321 :
1322 40 : context->sublevels_up++;
1323 40 : newnode = query_tree_mutator((Query *) node,
1324 : add_nulling_relids_mutator,
1325 : context,
1326 : 0);
1327 40 : context->sublevels_up--;
1328 40 : return (Node *) newnode;
1329 : }
1330 16879 : return expression_tree_mutator(node, add_nulling_relids_mutator, context);
1331 : }
1332 :
1333 : /*
1334 : * remove_nulling_relids() removes mentions of the specified RT index(es)
1335 : * in Var.varnullingrels and PlaceHolderVar.phnullingrels fields within
1336 : * the given expression, except in nodes belonging to rels listed in
1337 : * except_relids.
1338 : */
1339 : Node *
1340 296206 : remove_nulling_relids(Node *node,
1341 : const Bitmapset *removable_relids,
1342 : const Bitmapset *except_relids)
1343 : {
1344 : remove_nulling_relids_context context;
1345 :
1346 296206 : context.removable_relids = removable_relids;
1347 296206 : context.except_relids = except_relids;
1348 296206 : context.sublevels_up = 0;
1349 296206 : return query_or_expression_tree_mutator(node,
1350 : remove_nulling_relids_mutator,
1351 : &context,
1352 : 0);
1353 : }
1354 :
1355 : static Node *
1356 697299 : remove_nulling_relids_mutator(Node *node,
1357 : remove_nulling_relids_context *context)
1358 : {
1359 697299 : if (node == NULL)
1360 84392 : return NULL;
1361 612907 : if (IsA(node, Var))
1362 : {
1363 363455 : Var *var = (Var *) node;
1364 :
1365 363455 : if (var->varlevelsup == context->sublevels_up &&
1366 712465 : !bms_is_member(var->varno, context->except_relids) &&
1367 356196 : bms_overlap(var->varnullingrels, context->removable_relids))
1368 : {
1369 : /* Copy the Var ... */
1370 12756 : var = copyObject(var);
1371 : /* ... and replace the copy's varnullingrels field */
1372 12756 : var->varnullingrels = bms_difference(var->varnullingrels,
1373 : context->removable_relids);
1374 12756 : return (Node *) var;
1375 : }
1376 : /* Otherwise fall through to copy the Var normally */
1377 : }
1378 249452 : else if (IsA(node, PlaceHolderVar))
1379 : {
1380 3879 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
1381 :
1382 3879 : if (phv->phlevelsup == context->sublevels_up &&
1383 3879 : !bms_overlap(phv->phrels, context->except_relids))
1384 : {
1385 : /*
1386 : * Note: it might seem desirable to remove the PHV altogether if
1387 : * phnullingrels goes to empty. Currently we dare not do that
1388 : * because we use PHVs in some cases to enforce separate identity
1389 : * of subexpressions; see wrap_option usages in prepjointree.c.
1390 : */
1391 : /* Copy the PlaceHolderVar and mutate what's below ... */
1392 : phv = (PlaceHolderVar *)
1393 3879 : expression_tree_mutator(node,
1394 : remove_nulling_relids_mutator,
1395 : context);
1396 : /* ... and replace the copy's phnullingrels field */
1397 3879 : phv->phnullingrels = bms_difference(phv->phnullingrels,
1398 : context->removable_relids);
1399 : /* We must also update phrels, if it contains a removable RTI */
1400 3879 : phv->phrels = bms_difference(phv->phrels,
1401 : context->removable_relids);
1402 : Assert(!bms_is_empty(phv->phrels));
1403 3879 : return (Node *) phv;
1404 : }
1405 : /* Otherwise fall through to copy the PlaceHolderVar normally */
1406 : }
1407 245573 : else if (IsA(node, Query))
1408 : {
1409 : /* Recurse into RTE or sublink subquery */
1410 : Query *newnode;
1411 :
1412 742 : context->sublevels_up++;
1413 742 : newnode = query_tree_mutator((Query *) node,
1414 : remove_nulling_relids_mutator,
1415 : context,
1416 : 0);
1417 742 : context->sublevels_up--;
1418 742 : return (Node *) newnode;
1419 : }
1420 595530 : return expression_tree_mutator(node, remove_nulling_relids_mutator, context);
1421 : }
1422 :
1423 :
1424 : /*
1425 : * replace_rte_variables() finds all Vars in an expression tree
1426 : * that reference a particular RTE, and replaces them with substitute
1427 : * expressions obtained from a caller-supplied callback function.
1428 : *
1429 : * When invoking replace_rte_variables on a portion of a Query, pass the
1430 : * address of the containing Query's hasSubLinks field as outer_hasSubLinks.
1431 : * Otherwise, pass NULL, but inserting a SubLink into a non-Query expression
1432 : * will then cause an error.
1433 : *
1434 : * Note: the business with inserted_sublink is needed to update hasSubLinks
1435 : * in subqueries when the replacement adds a subquery inside a subquery.
1436 : * Messy, isn't it? We do not need to do similar pushups for hasAggs,
1437 : * because it isn't possible for this transformation to insert a level-zero
1438 : * aggregate reference into a subquery --- it could only insert outer aggs.
1439 : * Likewise for hasWindowFuncs.
1440 : *
1441 : * Note: usually, we'd not expose the mutator function or context struct
1442 : * for a function like this. We do so because callbacks often find it
1443 : * convenient to recurse directly to the mutator on sub-expressions of
1444 : * what they will return.
1445 : */
1446 : Node *
1447 170397 : replace_rte_variables(Node *node, int target_varno, int sublevels_up,
1448 : replace_rte_variables_callback callback,
1449 : void *callback_arg,
1450 : bool *outer_hasSubLinks)
1451 : {
1452 : Node *result;
1453 : replace_rte_variables_context context;
1454 :
1455 170397 : context.callback = callback;
1456 170397 : context.callback_arg = callback_arg;
1457 170397 : context.target_varno = target_varno;
1458 170397 : context.sublevels_up = sublevels_up;
1459 :
1460 : /*
1461 : * We try to initialize inserted_sublink to true if there is no need to
1462 : * detect new sublinks because the query already has some.
1463 : */
1464 170397 : if (node && IsA(node, Query))
1465 4311 : context.inserted_sublink = ((Query *) node)->hasSubLinks;
1466 166086 : else if (outer_hasSubLinks)
1467 165725 : context.inserted_sublink = *outer_hasSubLinks;
1468 : else
1469 361 : context.inserted_sublink = false;
1470 :
1471 : /*
1472 : * Must be prepared to start with a Query or a bare expression tree; if
1473 : * it's a Query, we don't want to increment sublevels_up.
1474 : */
1475 170397 : result = query_or_expression_tree_mutator(node,
1476 : replace_rte_variables_mutator,
1477 : &context,
1478 : 0);
1479 :
1480 170393 : if (context.inserted_sublink)
1481 : {
1482 19199 : if (result && IsA(result, Query))
1483 150 : ((Query *) result)->hasSubLinks = true;
1484 19049 : else if (outer_hasSubLinks)
1485 19049 : *outer_hasSubLinks = true;
1486 : else
1487 0 : elog(ERROR, "replace_rte_variables inserted a SubLink, but has noplace to record it");
1488 : }
1489 :
1490 170393 : return result;
1491 : }
1492 :
1493 : Node *
1494 759562 : replace_rte_variables_mutator(Node *node,
1495 : replace_rte_variables_context *context)
1496 : {
1497 759562 : if (node == NULL)
1498 226849 : return NULL;
1499 532713 : if (IsA(node, Var))
1500 : {
1501 212891 : Var *var = (Var *) node;
1502 :
1503 212891 : if (var->varno == context->target_varno &&
1504 110425 : var->varlevelsup == context->sublevels_up)
1505 : {
1506 : /* Found a matching variable, make the substitution */
1507 : Node *newnode;
1508 :
1509 104053 : newnode = context->callback(var, context);
1510 : /* Detect if we are adding a sublink to query */
1511 104053 : if (!context->inserted_sublink)
1512 93981 : context->inserted_sublink = checkExprHasSubLink(newnode);
1513 104053 : return newnode;
1514 : }
1515 : /* otherwise fall through to copy the var normally */
1516 : }
1517 319822 : else if (IsA(node, CurrentOfExpr))
1518 : {
1519 4 : CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
1520 :
1521 4 : if (cexpr->cvarno == context->target_varno &&
1522 4 : context->sublevels_up == 0)
1523 : {
1524 : /*
1525 : * We get here if a WHERE CURRENT OF expression turns out to apply
1526 : * to a view. Someday we might be able to translate the
1527 : * expression to apply to an underlying table of the view, but
1528 : * right now it's not implemented.
1529 : */
1530 4 : ereport(ERROR,
1531 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1532 : errmsg("WHERE CURRENT OF on a view is not implemented")));
1533 : }
1534 : /* otherwise fall through to copy the expr normally */
1535 : }
1536 319818 : else if (IsA(node, Query))
1537 : {
1538 : /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1539 : Query *newnode;
1540 : bool save_inserted_sublink;
1541 :
1542 2340 : context->sublevels_up++;
1543 2340 : save_inserted_sublink = context->inserted_sublink;
1544 2340 : context->inserted_sublink = ((Query *) node)->hasSubLinks;
1545 2340 : newnode = query_tree_mutator((Query *) node,
1546 : replace_rte_variables_mutator,
1547 : context,
1548 : 0);
1549 2340 : newnode->hasSubLinks |= context->inserted_sublink;
1550 2340 : context->inserted_sublink = save_inserted_sublink;
1551 2340 : context->sublevels_up--;
1552 2340 : return (Node *) newnode;
1553 : }
1554 426316 : return expression_tree_mutator(node, replace_rte_variables_mutator, context);
1555 : }
1556 :
1557 :
1558 : /*
1559 : * map_variable_attnos() finds all user-column Vars in an expression tree
1560 : * that reference a particular RTE, and adjusts their varattnos according
1561 : * to the given mapping array (varattno n is replaced by attno_map[n-1]).
1562 : * Vars for system columns are not modified.
1563 : *
1564 : * A zero in the mapping array represents a dropped column, which should not
1565 : * appear in the expression.
1566 : *
1567 : * If the expression tree contains a whole-row Var for the target RTE,
1568 : * *found_whole_row is set to true. In addition, if to_rowtype is
1569 : * not InvalidOid, we replace the Var with a Var of that vartype, inserting
1570 : * a ConvertRowtypeExpr to map back to the rowtype expected by the expression.
1571 : * (Therefore, to_rowtype had better be a child rowtype of the rowtype of the
1572 : * RTE we're changing references to.) Callers that don't provide to_rowtype
1573 : * should report an error if *found_whole_row is true; we don't do that here
1574 : * because we don't know exactly what wording for the error message would
1575 : * be most appropriate. The caller will be aware of the context.
1576 : *
1577 : * This could be built using replace_rte_variables and a callback function,
1578 : * but since we don't ever need to insert sublinks, replace_rte_variables is
1579 : * overly complicated.
1580 : */
1581 :
1582 : typedef struct
1583 : {
1584 : int target_varno; /* RTE index to search for */
1585 : int sublevels_up; /* (current) nesting depth */
1586 : const AttrMap *attno_map; /* map array for user attnos */
1587 : Oid to_rowtype; /* change whole-row Vars to this type */
1588 : bool *found_whole_row; /* output flag */
1589 : } map_variable_attnos_context;
1590 :
1591 : static Node *
1592 83799 : map_variable_attnos_mutator(Node *node,
1593 : map_variable_attnos_context *context)
1594 : {
1595 83799 : if (node == NULL)
1596 112 : return NULL;
1597 83687 : if (IsA(node, Var))
1598 : {
1599 19285 : Var *var = (Var *) node;
1600 :
1601 19285 : if (var->varno == context->target_varno &&
1602 19125 : var->varlevelsup == context->sublevels_up)
1603 : {
1604 : /* Found a matching variable, make the substitution */
1605 19125 : Var *newvar = palloc_object(Var);
1606 19125 : int attno = var->varattno;
1607 :
1608 19125 : *newvar = *var; /* initially copy all fields of the Var */
1609 :
1610 19125 : if (attno > 0)
1611 : {
1612 : /* user-defined column, replace attno */
1613 18857 : if (attno > context->attno_map->maplen ||
1614 18857 : context->attno_map->attnums[attno - 1] == 0)
1615 0 : elog(ERROR, "unexpected varattno %d in expression to be mapped",
1616 : attno);
1617 18857 : newvar->varattno = context->attno_map->attnums[attno - 1];
1618 : /* If the syntactic referent is same RTE, fix it too */
1619 18857 : if (newvar->varnosyn == context->target_varno)
1620 18797 : newvar->varattnosyn = newvar->varattno;
1621 : }
1622 268 : else if (attno == 0)
1623 : {
1624 : /* whole-row variable, warn caller */
1625 40 : *(context->found_whole_row) = true;
1626 :
1627 : /* If the caller expects us to convert the Var, do so. */
1628 40 : if (OidIsValid(context->to_rowtype) &&
1629 36 : context->to_rowtype != var->vartype)
1630 : {
1631 : ConvertRowtypeExpr *r;
1632 :
1633 : /* This certainly won't work for a RECORD variable. */
1634 : Assert(var->vartype != RECORDOID);
1635 :
1636 : /* Var itself is changed to the requested type. */
1637 36 : newvar->vartype = context->to_rowtype;
1638 :
1639 : /*
1640 : * Add a conversion node on top to convert back to the
1641 : * original type expected by the expression.
1642 : */
1643 36 : r = makeNode(ConvertRowtypeExpr);
1644 36 : r->arg = (Expr *) newvar;
1645 36 : r->resulttype = var->vartype;
1646 36 : r->convertformat = COERCE_IMPLICIT_CAST;
1647 36 : r->location = -1;
1648 :
1649 36 : return (Node *) r;
1650 : }
1651 : }
1652 19089 : return (Node *) newvar;
1653 : }
1654 : /* otherwise fall through to copy the var normally */
1655 : }
1656 64402 : else if (IsA(node, ConvertRowtypeExpr))
1657 : {
1658 32 : ConvertRowtypeExpr *r = (ConvertRowtypeExpr *) node;
1659 32 : Var *var = (Var *) r->arg;
1660 :
1661 : /*
1662 : * If this is coercing a whole-row Var that we need to convert, then
1663 : * just convert the Var without adding an extra ConvertRowtypeExpr.
1664 : * Effectively we're simplifying var::parenttype::grandparenttype into
1665 : * just var::grandparenttype. This avoids building stacks of CREs if
1666 : * this function is applied repeatedly.
1667 : */
1668 32 : if (IsA(var, Var) &&
1669 24 : var->varno == context->target_varno &&
1670 20 : var->varlevelsup == context->sublevels_up &&
1671 20 : var->varattno == 0 &&
1672 20 : OidIsValid(context->to_rowtype) &&
1673 20 : context->to_rowtype != var->vartype)
1674 : {
1675 : ConvertRowtypeExpr *newnode;
1676 20 : Var *newvar = palloc_object(Var);
1677 :
1678 : /* whole-row variable, warn caller */
1679 20 : *(context->found_whole_row) = true;
1680 :
1681 20 : *newvar = *var; /* initially copy all fields of the Var */
1682 :
1683 : /* This certainly won't work for a RECORD variable. */
1684 : Assert(var->vartype != RECORDOID);
1685 :
1686 : /* Var itself is changed to the requested type. */
1687 20 : newvar->vartype = context->to_rowtype;
1688 :
1689 20 : newnode = palloc_object(ConvertRowtypeExpr);
1690 20 : *newnode = *r; /* initially copy all fields of the CRE */
1691 20 : newnode->arg = (Expr *) newvar;
1692 :
1693 20 : return (Node *) newnode;
1694 : }
1695 : /* otherwise fall through to process the expression normally */
1696 : }
1697 64370 : else if (IsA(node, Query))
1698 : {
1699 : /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1700 : Query *newnode;
1701 :
1702 0 : context->sublevels_up++;
1703 0 : newnode = query_tree_mutator((Query *) node,
1704 : map_variable_attnos_mutator,
1705 : context,
1706 : 0);
1707 0 : context->sublevels_up--;
1708 0 : return (Node *) newnode;
1709 : }
1710 64542 : return expression_tree_mutator(node, map_variable_attnos_mutator, context);
1711 : }
1712 :
1713 : Node *
1714 6953 : map_variable_attnos(Node *node,
1715 : int target_varno, int sublevels_up,
1716 : const AttrMap *attno_map,
1717 : Oid to_rowtype, bool *found_whole_row)
1718 : {
1719 : map_variable_attnos_context context;
1720 :
1721 6953 : context.target_varno = target_varno;
1722 6953 : context.sublevels_up = sublevels_up;
1723 6953 : context.attno_map = attno_map;
1724 6953 : context.to_rowtype = to_rowtype;
1725 6953 : context.found_whole_row = found_whole_row;
1726 :
1727 6953 : *found_whole_row = false;
1728 :
1729 : /*
1730 : * Must be prepared to start with a Query or a bare expression tree; if
1731 : * it's a Query, we don't want to increment sublevels_up.
1732 : */
1733 6953 : return query_or_expression_tree_mutator(node,
1734 : map_variable_attnos_mutator,
1735 : &context,
1736 : 0);
1737 : }
1738 :
1739 :
1740 : /*
1741 : * ReplaceVarsFromTargetList - replace Vars with items from a targetlist
1742 : *
1743 : * Vars matching target_varno and sublevels_up are replaced by the
1744 : * entry with matching resno from targetlist, if there is one.
1745 : *
1746 : * If there is no matching resno for such a Var, the action depends on the
1747 : * nomatch_option:
1748 : * REPLACEVARS_REPORT_ERROR: throw an error
1749 : * REPLACEVARS_CHANGE_VARNO: change Var's varno to nomatch_varno
1750 : * REPLACEVARS_SUBSTITUTE_NULL: replace Var with a NULL Const of same type
1751 : *
1752 : * The caller must also provide target_rte, the RTE describing the target
1753 : * relation. This is needed to handle whole-row Vars referencing the target.
1754 : * We expand such Vars into RowExpr constructs.
1755 : *
1756 : * In addition, for INSERT/UPDATE/DELETE/MERGE queries, the caller must
1757 : * provide result_relation, the index of the result relation in the rewritten
1758 : * query. This is needed to handle OLD/NEW RETURNING list Vars referencing
1759 : * target_varno. When such Vars are expanded, their varreturningtype is
1760 : * copied onto any replacement Vars referencing result_relation. In addition,
1761 : * if the replacement expression from the targetlist is not simply a Var
1762 : * referencing result_relation, it is wrapped in a ReturningExpr node (causing
1763 : * the executor to return NULL if the OLD/NEW row doesn't exist).
1764 : *
1765 : * Note that ReplaceVarFromTargetList always generates the replacement
1766 : * expression with varlevelsup = 0. The caller is responsible for adjusting
1767 : * the varlevelsup if needed. This simplifies the caller's life if it wants to
1768 : * cache the replacement expressions.
1769 : *
1770 : * outer_hasSubLinks works the same as for replace_rte_variables().
1771 : */
1772 :
1773 : typedef struct
1774 : {
1775 : RangeTblEntry *target_rte;
1776 : List *targetlist;
1777 : int result_relation;
1778 : ReplaceVarsNoMatchOption nomatch_option;
1779 : int nomatch_varno;
1780 : } ReplaceVarsFromTargetList_context;
1781 :
1782 : static Node *
1783 9348 : ReplaceVarsFromTargetList_callback(const Var *var,
1784 : replace_rte_variables_context *context)
1785 : {
1786 9348 : ReplaceVarsFromTargetList_context *rcon = (ReplaceVarsFromTargetList_context *) context->callback_arg;
1787 : Node *newnode;
1788 :
1789 9348 : newnode = ReplaceVarFromTargetList(var,
1790 : rcon->target_rte,
1791 : rcon->targetlist,
1792 : rcon->result_relation,
1793 : rcon->nomatch_option,
1794 : rcon->nomatch_varno);
1795 :
1796 : /* Must adjust varlevelsup if replaced Var is within a subquery */
1797 9348 : if (var->varlevelsup > 0)
1798 172 : IncrementVarSublevelsUp(newnode, var->varlevelsup, 0);
1799 :
1800 9348 : return newnode;
1801 : }
1802 :
1803 : Node *
1804 103269 : ReplaceVarFromTargetList(const Var *var,
1805 : RangeTblEntry *target_rte,
1806 : List *targetlist,
1807 : int result_relation,
1808 : ReplaceVarsNoMatchOption nomatch_option,
1809 : int nomatch_varno)
1810 : {
1811 : TargetEntry *tle;
1812 :
1813 103269 : if (var->varattno == InvalidAttrNumber)
1814 : {
1815 : /* Must expand whole-tuple reference into RowExpr */
1816 : RowExpr *rowexpr;
1817 : List *colnames;
1818 : List *fields;
1819 : ListCell *lc;
1820 :
1821 : /*
1822 : * If generating an expansion for a var of a named rowtype (ie, this
1823 : * is a plain relation RTE), then we must include dummy items for
1824 : * dropped columns. If the var is RECORD (ie, this is a JOIN), then
1825 : * omit dropped columns. In the latter case, attach column names to
1826 : * the RowExpr for use of the executor and ruleutils.c.
1827 : *
1828 : * In order to be able to cache the results, we always generate the
1829 : * expansion with varlevelsup = 0. The caller is responsible for
1830 : * adjusting it if needed.
1831 : *
1832 : * The varreturningtype is copied onto each individual field Var, so
1833 : * that it is handled correctly when we recurse.
1834 : */
1835 610 : expandRTE(target_rte,
1836 610 : var->varno, 0 /* not varlevelsup */ ,
1837 610 : var->varreturningtype, var->location,
1838 610 : (var->vartype != RECORDOID),
1839 : &colnames, &fields);
1840 610 : rowexpr = makeNode(RowExpr);
1841 : /* the fields will be set below */
1842 610 : rowexpr->args = NIL;
1843 610 : rowexpr->row_typeid = var->vartype;
1844 610 : rowexpr->row_format = COERCE_IMPLICIT_CAST;
1845 610 : rowexpr->colnames = (var->vartype == RECORDOID) ? colnames : NIL;
1846 610 : rowexpr->location = var->location;
1847 : /* Adjust the generated per-field Vars... */
1848 2244 : foreach(lc, fields)
1849 : {
1850 1634 : Node *field = lfirst(lc);
1851 :
1852 1634 : if (field && IsA(field, Var))
1853 1634 : field = ReplaceVarFromTargetList((Var *) field,
1854 : target_rte,
1855 : targetlist,
1856 : result_relation,
1857 : nomatch_option,
1858 : nomatch_varno);
1859 1634 : rowexpr->args = lappend(rowexpr->args, field);
1860 : }
1861 :
1862 : /* Wrap it in a ReturningExpr, if needed, per comments above */
1863 610 : if (var->varreturningtype != VAR_RETURNING_DEFAULT)
1864 : {
1865 68 : ReturningExpr *rexpr = makeNode(ReturningExpr);
1866 :
1867 68 : rexpr->retlevelsup = 0;
1868 68 : rexpr->retold = (var->varreturningtype == VAR_RETURNING_OLD);
1869 68 : rexpr->retexpr = (Expr *) rowexpr;
1870 :
1871 68 : return (Node *) rexpr;
1872 : }
1873 :
1874 542 : return (Node *) rowexpr;
1875 : }
1876 :
1877 : /* Normal case referencing one targetlist element */
1878 102659 : tle = get_tle_by_resno(targetlist, var->varattno);
1879 :
1880 102659 : if (tle == NULL || tle->resjunk)
1881 : {
1882 : /* Failed to find column in targetlist */
1883 412 : switch (nomatch_option)
1884 : {
1885 0 : case REPLACEVARS_REPORT_ERROR:
1886 : /* fall through, throw error below */
1887 0 : break;
1888 :
1889 312 : case REPLACEVARS_CHANGE_VARNO:
1890 : {
1891 312 : Var *newvar = copyObject(var);
1892 :
1893 312 : newvar->varno = nomatch_varno;
1894 312 : newvar->varlevelsup = 0;
1895 : /* we leave the syntactic referent alone */
1896 312 : return (Node *) newvar;
1897 : }
1898 :
1899 100 : case REPLACEVARS_SUBSTITUTE_NULL:
1900 : {
1901 : /*
1902 : * If Var is of domain type, we must add a CoerceToDomain
1903 : * node, in case there is a NOT NULL domain constraint.
1904 : */
1905 : int16 vartyplen;
1906 : bool vartypbyval;
1907 :
1908 100 : get_typlenbyval(var->vartype, &vartyplen, &vartypbyval);
1909 100 : return coerce_null_to_domain(var->vartype,
1910 100 : var->vartypmod,
1911 100 : var->varcollid,
1912 : vartyplen,
1913 : vartypbyval);
1914 : }
1915 : }
1916 0 : elog(ERROR, "could not find replacement targetlist entry for attno %d",
1917 : var->varattno);
1918 : return NULL; /* keep compiler quiet */
1919 : }
1920 : else
1921 : {
1922 : /* Make a copy of the tlist item to return */
1923 102247 : Expr *newnode = copyObject(tle->expr);
1924 :
1925 : /*
1926 : * Check to see if the tlist item contains a PARAM_MULTIEXPR Param,
1927 : * and throw error if so. This case could only happen when expanding
1928 : * an ON UPDATE rule's NEW variable and the referenced tlist item in
1929 : * the original UPDATE command is part of a multiple assignment. There
1930 : * seems no practical way to handle such cases without multiple
1931 : * evaluation of the multiple assignment's sub-select, which would
1932 : * create semantic oddities that users of rules would probably prefer
1933 : * not to cope with. So treat it as an unimplemented feature.
1934 : */
1935 102247 : if (contains_multiexpr_param((Node *) newnode, NULL))
1936 0 : ereport(ERROR,
1937 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1938 : errmsg("NEW variables in ON UPDATE rules cannot reference columns that are part of a multiple assignment in the subject UPDATE command")));
1939 :
1940 : /* Handle any OLD/NEW RETURNING list Vars */
1941 102247 : if (var->varreturningtype != VAR_RETURNING_DEFAULT)
1942 : {
1943 : /*
1944 : * Copy varreturningtype onto any Vars in the tlist item that
1945 : * refer to result_relation (which had better be non-zero).
1946 : */
1947 826 : if (result_relation == 0)
1948 0 : elog(ERROR, "variable returning old/new found outside RETURNING list");
1949 :
1950 826 : SetVarReturningType((Node *) newnode, result_relation,
1951 826 : 0, var->varreturningtype);
1952 :
1953 : /* Wrap it in a ReturningExpr, if needed, per comments above */
1954 826 : if (!IsA(newnode, Var) ||
1955 620 : ((Var *) newnode)->varno != result_relation ||
1956 580 : ((Var *) newnode)->varlevelsup != 0)
1957 : {
1958 246 : ReturningExpr *rexpr = makeNode(ReturningExpr);
1959 :
1960 246 : rexpr->retlevelsup = 0;
1961 246 : rexpr->retold = (var->varreturningtype == VAR_RETURNING_OLD);
1962 246 : rexpr->retexpr = newnode;
1963 :
1964 246 : newnode = (Expr *) rexpr;
1965 : }
1966 : }
1967 :
1968 102247 : return (Node *) newnode;
1969 : }
1970 : }
1971 :
1972 : Node *
1973 6669 : ReplaceVarsFromTargetList(Node *node,
1974 : int target_varno, int sublevels_up,
1975 : RangeTblEntry *target_rte,
1976 : List *targetlist,
1977 : int result_relation,
1978 : ReplaceVarsNoMatchOption nomatch_option,
1979 : int nomatch_varno,
1980 : bool *outer_hasSubLinks)
1981 : {
1982 : ReplaceVarsFromTargetList_context context;
1983 :
1984 6669 : context.target_rte = target_rte;
1985 6669 : context.targetlist = targetlist;
1986 6669 : context.result_relation = result_relation;
1987 6669 : context.nomatch_option = nomatch_option;
1988 6669 : context.nomatch_varno = nomatch_varno;
1989 :
1990 6669 : return replace_rte_variables(node, target_varno, sublevels_up,
1991 : ReplaceVarsFromTargetList_callback,
1992 : &context,
1993 : outer_hasSubLinks);
1994 : }
|
