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