Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * rewriteManip.c
4 : : *
5 : : * Portions Copyright (c) 1996-2024, 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 "catalog/pg_type.h"
17 : : #include "nodes/makefuncs.h"
18 : : #include "nodes/nodeFuncs.h"
19 : : #include "nodes/pathnodes.h"
20 : : #include "nodes/plannodes.h"
21 : : #include "parser/parse_coerce.h"
22 : : #include "parser/parse_relation.h"
23 : : #include "parser/parsetree.h"
24 : : #include "rewrite/rewriteManip.h"
25 : :
26 : :
27 : : typedef struct
28 : : {
29 : : int sublevels_up;
30 : : } contain_aggs_of_level_context;
31 : :
32 : : typedef struct
33 : : {
34 : : int agg_location;
35 : : int sublevels_up;
36 : : } locate_agg_of_level_context;
37 : :
38 : : typedef struct
39 : : {
40 : : int win_location;
41 : : } locate_windowfunc_context;
42 : :
43 : : typedef struct
44 : : {
45 : : const Bitmapset *target_relids;
46 : : const Bitmapset *added_relids;
47 : : int sublevels_up;
48 : : } add_nulling_relids_context;
49 : :
50 : : typedef struct
51 : : {
52 : : const Bitmapset *removable_relids;
53 : : const Bitmapset *except_relids;
54 : : int sublevels_up;
55 : : } remove_nulling_relids_context;
56 : :
57 : : static bool contain_aggs_of_level_walker(Node *node,
58 : : contain_aggs_of_level_context *context);
59 : : static bool locate_agg_of_level_walker(Node *node,
60 : : locate_agg_of_level_context *context);
61 : : static bool contain_windowfuncs_walker(Node *node, void *context);
62 : : static bool locate_windowfunc_walker(Node *node,
63 : : locate_windowfunc_context *context);
64 : : static bool checkExprHasSubLink_walker(Node *node, void *context);
65 : : static Relids offset_relid_set(Relids relids, int offset);
66 : : static Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid);
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
5714 tgl@sss.pgh.pa.us 85 :CBC 1276 : contain_aggs_of_level(Node *node, int levelsup)
86 : : {
87 : : contain_aggs_of_level_context context;
88 : :
89 : 1276 : 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 : : */
7758 95 : 1276 : return query_or_expression_tree_walker(node,
96 : : contain_aggs_of_level_walker,
97 : : (void *) &context,
98 : : 0);
99 : : }
100 : :
101 : : static bool
5714 102 : 5983 : contain_aggs_of_level_walker(Node *node,
103 : : contain_aggs_of_level_context *context)
104 : : {
8795 105 [ + + ]: 5983 : if (node == NULL)
106 : 702 : return false;
107 [ - + ]: 5281 : if (IsA(node, Aggref))
108 : : {
7618 tgl@sss.pgh.pa.us 109 [ # # ]:UBC 0 : if (((Aggref *) node)->agglevelsup == context->sublevels_up)
6756 bruce@momjian.us 110 : 0 : return true; /* abort the tree traversal and return true */
111 : : /* else fall through to examine argument */
112 : : }
3256 andres@anarazel.de 113 [ - + ]:CBC 5281 : if (IsA(node, GroupingFunc))
114 : : {
3256 andres@anarazel.de 115 [ # # ]:UBC 0 : if (((GroupingFunc *) node)->agglevelsup == context->sublevels_up)
116 : 0 : return true;
117 : : /* else fall through to examine argument */
118 : : }
7618 tgl@sss.pgh.pa.us 119 [ + + ]:CBC 5281 : if (IsA(node, Query))
120 : : {
121 : : /* Recurse into subselects */
122 : : bool result;
123 : :
124 : 50 : context->sublevels_up++;
125 : 50 : result = query_tree_walker((Query *) node,
126 : : contain_aggs_of_level_walker,
127 : : (void *) context, 0);
128 : 50 : context->sublevels_up--;
129 : 50 : return result;
130 : : }
5714 131 : 5231 : return expression_tree_walker(node, contain_aggs_of_level_walker,
132 : : (void *) 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
5704 149 : 30 : locate_agg_of_level(Node *node, int levelsup)
150 : : {
151 : : locate_agg_of_level_context context;
152 : :
5421 bruce@momjian.us 153 : 30 : context.agg_location = -1; /* in case we find nothing */
5704 tgl@sss.pgh.pa.us 154 : 30 : 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 : 30 : (void) query_or_expression_tree_walker(node,
161 : : locate_agg_of_level_walker,
162 : : (void *) &context,
163 : : 0);
164 : :
165 : 30 : return context.agg_location;
166 : : }
167 : :
168 : : static bool
169 : 120 : locate_agg_of_level_walker(Node *node,
170 : : locate_agg_of_level_context *context)
171 : : {
172 [ + + ]: 120 : if (node == NULL)
173 : 6 : return false;
174 [ + + ]: 114 : if (IsA(node, Aggref))
175 : : {
176 [ + + ]: 27 : if (((Aggref *) node)->agglevelsup == context->sublevels_up &&
177 [ + - ]: 24 : ((Aggref *) node)->location >= 0)
178 : : {
179 : 24 : context->agg_location = ((Aggref *) node)->location;
180 : 24 : return true; /* abort the tree traversal and return true */
181 : : }
182 : : /* else fall through to examine argument */
183 : : }
3256 andres@anarazel.de 184 [ - + ]: 90 : if (IsA(node, GroupingFunc))
185 : : {
3256 andres@anarazel.de 186 [ # # ]:UBC 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 : : }
5704 tgl@sss.pgh.pa.us 193 [ + + ]:CBC 90 : if (IsA(node, Query))
194 : : {
195 : : /* Recurse into subselects */
196 : : bool result;
197 : :
198 : 6 : context->sublevels_up++;
199 : 6 : result = query_tree_walker((Query *) node,
200 : : locate_agg_of_level_walker,
201 : : (void *) context, 0);
202 : 6 : context->sublevels_up--;
203 : 6 : return result;
204 : : }
205 : 84 : return expression_tree_walker(node, locate_agg_of_level_walker,
206 : : (void *) 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
4265 215 : 4542 : 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 : : */
5586 221 : 4542 : return query_or_expression_tree_walker(node,
222 : : contain_windowfuncs_walker,
223 : : NULL,
224 : : 0);
225 : : }
226 : :
227 : : static bool
228 : 4977 : contain_windowfuncs_walker(Node *node, void *context)
229 : : {
230 [ + + ]: 4977 : if (node == NULL)
231 : 84 : return false;
232 [ + + ]: 4893 : if (IsA(node, WindowFunc))
5421 bruce@momjian.us 233 : 6 : return true; /* abort the tree traversal and return true */
234 : : /* Mustn't recurse into subselects */
5586 tgl@sss.pgh.pa.us 235 : 4887 : return expression_tree_walker(node, contain_windowfuncs_walker,
236 : : (void *) context);
237 : : }
238 : :
239 : : /*
240 : : * locate_windowfunc -
241 : : * Find the parse location of any windowfunc of the current query level.
242 : : *
243 : : * Returns -1 if no such windowfunc is in the querytree, or if they all have
244 : : * unknown parse location. (The former case is probably caller error,
245 : : * but we don't bother to distinguish it from the latter case.)
246 : : *
247 : : * Note: it might seem appropriate to merge this functionality into
248 : : * contain_windowfuncs, but that would complicate that function's API.
249 : : * Currently, the only uses of this function are for error reporting,
250 : : * and so shaving cycles probably isn't very important.
251 : : */
252 : : int
253 : 3 : locate_windowfunc(Node *node)
254 : : {
255 : : locate_windowfunc_context context;
256 : :
5421 bruce@momjian.us 257 : 3 : context.win_location = -1; /* in case we find nothing */
258 : :
259 : : /*
260 : : * Must be prepared to start with a Query or a bare expression tree; if
261 : : * it's a Query, we don't want to increment sublevels_up.
262 : : */
5586 tgl@sss.pgh.pa.us 263 : 3 : (void) query_or_expression_tree_walker(node,
264 : : locate_windowfunc_walker,
265 : : (void *) &context,
266 : : 0);
267 : :
268 : 3 : return context.win_location;
269 : : }
270 : :
271 : : static bool
272 : 3 : locate_windowfunc_walker(Node *node, locate_windowfunc_context *context)
273 : : {
274 [ - + ]: 3 : if (node == NULL)
5586 tgl@sss.pgh.pa.us 275 :UBC 0 : return false;
5586 tgl@sss.pgh.pa.us 276 [ + - ]:CBC 3 : if (IsA(node, WindowFunc))
277 : : {
278 [ + - ]: 3 : if (((WindowFunc *) node)->location >= 0)
279 : : {
280 : 3 : context->win_location = ((WindowFunc *) node)->location;
281 : 3 : return true; /* abort the tree traversal and return true */
282 : : }
283 : : /* else fall through to examine argument */
284 : : }
285 : : /* Mustn't recurse into subselects */
5586 tgl@sss.pgh.pa.us 286 :UBC 0 : return expression_tree_walker(node, locate_windowfunc_walker,
287 : : (void *) context);
288 : : }
289 : :
290 : : /*
291 : : * checkExprHasSubLink -
292 : : * Check if an expression contains a SubLink.
293 : : */
294 : : bool
8795 tgl@sss.pgh.pa.us 295 :CBC 53113 : checkExprHasSubLink(Node *node)
296 : : {
297 : : /*
298 : : * If a Query is passed, examine it --- but we should not recurse into
299 : : * sub-Queries that are in its rangetable or CTE list.
300 : : */
7758 301 : 53113 : return query_or_expression_tree_walker(node,
302 : : checkExprHasSubLink_walker,
303 : : NULL,
304 : : QTW_IGNORE_RC_SUBQUERIES);
305 : : }
306 : :
307 : : static bool
8795 308 : 88773 : checkExprHasSubLink_walker(Node *node, void *context)
309 : : {
310 [ + + ]: 88773 : if (node == NULL)
311 : 1810 : return false;
312 [ + + ]: 86963 : if (IsA(node, SubLink))
6756 bruce@momjian.us 313 : 782 : return true; /* abort the tree traversal and return true */
8795 tgl@sss.pgh.pa.us 314 : 86181 : return expression_tree_walker(node, checkExprHasSubLink_walker, context);
315 : : }
316 : :
317 : : /*
318 : : * Check for MULTIEXPR Param within expression tree
319 : : *
320 : : * We intentionally don't descend into SubLinks: only Params at the current
321 : : * query level are of interest.
322 : : */
323 : : static bool
3588 324 : 4879 : contains_multiexpr_param(Node *node, void *context)
325 : : {
326 [ + + ]: 4879 : if (node == NULL)
327 : 9 : return false;
328 [ - + ]: 4870 : if (IsA(node, Param))
329 : : {
3588 tgl@sss.pgh.pa.us 330 [ # # ]:UBC 0 : if (((Param *) node)->paramkind == PARAM_MULTIEXPR)
331 : 0 : return true; /* abort the tree traversal and return true */
332 : 0 : return false;
333 : : }
3588 tgl@sss.pgh.pa.us 334 :CBC 4870 : return expression_tree_walker(node, contains_multiexpr_param, context);
335 : : }
336 : :
337 : : /*
338 : : * CombineRangeTables
339 : : * Adds the RTEs of 'src_rtable' into 'dst_rtable'
340 : : *
341 : : * This also adds the RTEPermissionInfos of 'src_perminfos' (belonging to the
342 : : * RTEs in 'src_rtable') into *dst_perminfos and also updates perminfoindex of
343 : : * the RTEs in 'src_rtable' to now point to the perminfos' indexes in
344 : : * *dst_perminfos.
345 : : *
346 : : * Note that this changes both 'dst_rtable' and 'dst_perminfos' destructively,
347 : : * so the caller should have better passed safe-to-modify copies.
348 : : */
349 : : void
495 alvherre@alvh.no-ip. 350 : 18224 : CombineRangeTables(List **dst_rtable, List **dst_perminfos,
351 : : List *src_rtable, List *src_perminfos)
352 : : {
353 : : ListCell *l;
354 : 18224 : int offset = list_length(*dst_perminfos);
355 : :
356 [ + + ]: 18224 : if (offset > 0)
357 : : {
358 [ + + + + : 44769 : foreach(l, src_rtable)
+ + ]
359 : : {
360 : 30180 : RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
361 : :
362 [ + + ]: 30180 : if (rte->perminfoindex > 0)
363 : 15541 : rte->perminfoindex += offset;
364 : : }
365 : : }
366 : :
367 : 18224 : *dst_perminfos = list_concat(*dst_perminfos, src_perminfos);
368 : 18224 : *dst_rtable = list_concat(*dst_rtable, src_rtable);
369 : 18224 : }
370 : :
371 : : /*
372 : : * OffsetVarNodes - adjust Vars when appending one query's RT to another
373 : : *
374 : : * Find all Var nodes in the given tree with varlevelsup == sublevels_up,
375 : : * and increment their varno fields (rangetable indexes) by 'offset'.
376 : : * The varnosyn fields are adjusted similarly. Also, adjust other nodes
377 : : * that contain rangetable indexes, such as RangeTblRef and JoinExpr.
378 : : *
379 : : * NOTE: although this has the form of a walker, we cheat and modify the
380 : : * nodes in-place. The given expression tree should have been copied
381 : : * earlier to ensure that no unwanted side-effects occur!
382 : : */
383 : :
384 : : typedef struct
385 : : {
386 : : int offset;
387 : : int sublevels_up;
388 : : } OffsetVarNodes_context;
389 : :
390 : : static bool
8962 tgl@sss.pgh.pa.us 391 : 954803 : OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
392 : : {
393 [ + + ]: 954803 : if (node == NULL)
394 : 284520 : return false;
395 [ + + ]: 670283 : if (IsA(node, Var))
396 : : {
397 : 356104 : Var *var = (Var *) node;
398 : :
399 [ + + ]: 356104 : if (var->varlevelsup == context->sublevels_up)
400 : : {
401 : 347811 : var->varno += context->offset;
440 402 : 347811 : var->varnullingrels = offset_relid_set(var->varnullingrels,
403 : : context->offset);
1557 404 [ + - ]: 347811 : if (var->varnosyn > 0)
405 : 347811 : var->varnosyn += context->offset;
406 : : }
8962 407 : 356104 : return false;
408 : : }
6152 409 [ - + ]: 314179 : if (IsA(node, CurrentOfExpr))
410 : : {
6152 tgl@sss.pgh.pa.us 411 :UBC 0 : CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
412 : :
413 [ # # ]: 0 : if (context->sublevels_up == 0)
414 : 0 : cexpr->cvarno += context->offset;
415 : 0 : return false;
416 : : }
8615 tgl@sss.pgh.pa.us 417 [ + + ]:CBC 314179 : if (IsA(node, RangeTblRef))
418 : : {
8424 bruce@momjian.us 419 : 26778 : RangeTblRef *rtr = (RangeTblRef *) node;
420 : :
8615 tgl@sss.pgh.pa.us 421 [ + + ]: 26778 : if (context->sublevels_up == 0)
422 : 24598 : rtr->rtindex += context->offset;
423 : : /* the subquery itself is visited separately */
8962 424 : 26778 : return false;
425 : : }
8069 426 [ + + ]: 287401 : if (IsA(node, JoinExpr))
427 : : {
7893 bruce@momjian.us 428 : 6626 : JoinExpr *j = (JoinExpr *) node;
429 : :
5527 tgl@sss.pgh.pa.us 430 [ + + + + ]: 6626 : if (j->rtindex && context->sublevels_up == 0)
8069 431 : 6313 : j->rtindex += context->offset;
432 : : /* fall through to examine children */
433 : : }
5654 434 [ + + ]: 287401 : if (IsA(node, PlaceHolderVar))
435 : : {
436 : 208 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
437 : :
438 [ + + ]: 208 : if (phv->phlevelsup == context->sublevels_up)
439 : : {
440 : 166 : phv->phrels = offset_relid_set(phv->phrels,
441 : : context->offset);
440 442 : 166 : phv->phnullingrels = offset_relid_set(phv->phnullingrels,
443 : : context->offset);
444 : : }
445 : : /* fall through to examine children */
446 : : }
6648 447 [ + + ]: 287401 : if (IsA(node, AppendRelInfo))
448 : : {
449 : 316 : AppendRelInfo *appinfo = (AppendRelInfo *) node;
450 : :
451 [ + - ]: 316 : if (context->sublevels_up == 0)
452 : : {
453 : 316 : appinfo->parent_relid += context->offset;
454 : 316 : appinfo->child_relid += context->offset;
455 : : }
456 : : /* fall through to examine children */
457 : : }
458 : : /* Shouldn't need to handle other planner auxiliary nodes here */
4607 459 [ - + ]: 287401 : Assert(!IsA(node, PlanRowMark));
5653 460 [ - + ]: 287401 : Assert(!IsA(node, SpecialJoinInfo));
461 [ - + ]: 287401 : Assert(!IsA(node, PlaceHolderInfo));
4910 462 [ - + ]: 287401 : Assert(!IsA(node, MinMaxAggInfo));
463 : :
8962 464 [ + + ]: 287401 : if (IsA(node, Query))
465 : : {
466 : : /* Recurse into subselects */
467 : : bool result;
468 : :
8615 469 : 1939 : context->sublevels_up++;
470 : 1939 : result = query_tree_walker((Query *) node, OffsetVarNodes_walker,
471 : : (void *) context, 0);
472 : 1939 : context->sublevels_up--;
473 : 1939 : return result;
474 : : }
8962 475 : 285462 : return expression_tree_walker(node, OffsetVarNodes_walker,
476 : : (void *) context);
477 : : }
478 : :
479 : : void
480 : 34952 : OffsetVarNodes(Node *node, int offset, int sublevels_up)
481 : : {
482 : : OffsetVarNodes_context context;
483 : :
484 : 34952 : context.offset = offset;
485 : 34952 : context.sublevels_up = sublevels_up;
486 : :
487 : : /*
488 : : * Must be prepared to start with a Query or a bare expression tree; if
489 : : * it's a Query, go straight to query_tree_walker to make sure that
490 : : * sublevels_up doesn't get incremented prematurely.
491 : : */
8615 492 [ + + + + ]: 34952 : if (node && IsA(node, Query))
8530 493 : 17476 : {
8424 bruce@momjian.us 494 : 17476 : Query *qry = (Query *) node;
495 : :
496 : : /*
497 : : * If we are starting at a Query, and sublevels_up is zero, then we
498 : : * must also fix rangetable indexes in the Query itself --- namely
499 : : * resultRelation, mergeTargetRelation, exclRelIndex and rowMarks
500 : : * entries. sublevels_up cannot be zero when recursing into a
501 : : * subquery, so there's no need to have the same logic inside
502 : : * OffsetVarNodes_walker.
503 : : */
8530 tgl@sss.pgh.pa.us 504 [ + - ]: 17476 : if (sublevels_up == 0)
505 : : {
506 : : ListCell *l;
507 : :
508 [ + + ]: 17476 : if (qry->resultRelation)
509 : 618 : qry->resultRelation += offset;
510 : :
45 dean.a.rasheed@gmail 511 [ - + ]:GNC 17476 : if (qry->mergeTargetRelation)
45 dean.a.rasheed@gmail 512 :UNC 0 : qry->mergeTargetRelation += offset;
513 : :
3259 andres@anarazel.de 514 [ + + + + ]:CBC 17476 : if (qry->onConflict && qry->onConflict->exclRelIndex)
515 : 18 : qry->onConflict->exclRelIndex += offset;
516 : :
8530 tgl@sss.pgh.pa.us 517 [ + + + + : 17550 : foreach(l, qry->rowMarks)
+ + ]
518 : : {
6559 519 : 74 : RowMarkClause *rc = (RowMarkClause *) lfirst(l);
520 : :
521 : 74 : rc->rti += offset;
522 : : }
523 : : }
8530 524 : 17476 : query_tree_walker(qry, OffsetVarNodes_walker,
525 : : (void *) &context, 0);
526 : : }
527 : : else
8615 528 : 17476 : OffsetVarNodes_walker(node, &context);
8962 529 : 34952 : }
530 : :
531 : : static Relids
7736 532 : 348143 : offset_relid_set(Relids relids, int offset)
533 : : {
534 : 348143 : Relids result = NULL;
535 : : int rtindex;
536 : :
3425 537 : 348143 : rtindex = -1;
538 [ + + ]: 398965 : while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
7736 539 : 50822 : result = bms_add_member(result, rtindex + offset);
540 : 348143 : return result;
541 : : }
542 : :
543 : : /*
544 : : * ChangeVarNodes - adjust Var nodes for a specific change of RT index
545 : : *
546 : : * Find all Var nodes in the given tree belonging to a specific relation
547 : : * (identified by sublevels_up and rt_index), and change their varno fields
548 : : * to 'new_index'. The varnosyn fields are changed too. Also, adjust other
549 : : * nodes that contain rangetable indexes, such as RangeTblRef and JoinExpr.
550 : : *
551 : : * NOTE: although this has the form of a walker, we cheat and modify the
552 : : * nodes in-place. The given expression tree should have been copied
553 : : * earlier to ensure that no unwanted side-effects occur!
554 : : */
555 : :
556 : : typedef struct
557 : : {
558 : : int rt_index;
559 : : int new_index;
560 : : int sublevels_up;
561 : : } ChangeVarNodes_context;
562 : :
563 : : static bool
8962 564 : 131932 : ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
565 : : {
566 [ + + ]: 131932 : if (node == NULL)
567 : 49165 : return false;
568 [ + + ]: 82767 : if (IsA(node, Var))
569 : : {
570 : 22611 : Var *var = (Var *) node;
571 : :
440 572 [ + + ]: 22611 : if (var->varlevelsup == context->sublevels_up)
573 : : {
574 [ + + ]: 21072 : if (var->varno == context->rt_index)
575 : 15469 : var->varno = context->new_index;
576 : 21072 : var->varnullingrels = adjust_relid_set(var->varnullingrels,
577 : : context->rt_index,
578 : : context->new_index);
1557 579 [ + + ]: 21072 : if (var->varnosyn == context->rt_index)
580 : 15469 : var->varnosyn = context->new_index;
581 : : }
8962 582 : 22611 : return false;
583 : : }
6152 584 [ - + ]: 60156 : if (IsA(node, CurrentOfExpr))
585 : : {
6152 tgl@sss.pgh.pa.us 586 :UBC 0 : CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
587 : :
588 [ # # ]: 0 : if (context->sublevels_up == 0 &&
589 [ # # ]: 0 : cexpr->cvarno == context->rt_index)
590 : 0 : cexpr->cvarno = context->new_index;
591 : 0 : return false;
592 : : }
8615 tgl@sss.pgh.pa.us 593 [ + + ]:CBC 60156 : if (IsA(node, RangeTblRef))
594 : : {
8424 bruce@momjian.us 595 : 2546 : RangeTblRef *rtr = (RangeTblRef *) node;
596 : :
8615 tgl@sss.pgh.pa.us 597 [ + + ]: 2546 : if (context->sublevels_up == 0 &&
598 [ + + ]: 1514 : rtr->rtindex == context->rt_index)
599 : 829 : rtr->rtindex = context->new_index;
600 : : /* the subquery itself is visited separately */
8962 601 : 2546 : return false;
602 : : }
8069 603 [ - + ]: 57610 : if (IsA(node, JoinExpr))
604 : : {
7893 bruce@momjian.us 605 :UBC 0 : JoinExpr *j = (JoinExpr *) node;
606 : :
8069 tgl@sss.pgh.pa.us 607 [ # # ]: 0 : if (context->sublevels_up == 0 &&
608 [ # # ]: 0 : j->rtindex == context->rt_index)
609 : 0 : j->rtindex = context->new_index;
610 : : /* fall through to examine children */
611 : : }
5654 tgl@sss.pgh.pa.us 612 [ - + ]:CBC 57610 : if (IsA(node, PlaceHolderVar))
613 : : {
5654 tgl@sss.pgh.pa.us 614 :UBC 0 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
615 : :
616 [ # # ]: 0 : if (phv->phlevelsup == context->sublevels_up)
617 : : {
618 : 0 : phv->phrels = adjust_relid_set(phv->phrels,
619 : : context->rt_index,
620 : : context->new_index);
440 621 : 0 : phv->phnullingrels = adjust_relid_set(phv->phnullingrels,
622 : : context->rt_index,
623 : : context->new_index);
624 : : }
625 : : /* fall through to examine children */
626 : : }
4607 tgl@sss.pgh.pa.us 627 [ - + ]:CBC 57610 : if (IsA(node, PlanRowMark))
628 : : {
4607 tgl@sss.pgh.pa.us 629 :UBC 0 : PlanRowMark *rowmark = (PlanRowMark *) node;
630 : :
631 [ # # ]: 0 : if (context->sublevels_up == 0)
632 : : {
633 [ # # ]: 0 : if (rowmark->rti == context->rt_index)
634 : 0 : rowmark->rti = context->new_index;
635 [ # # ]: 0 : if (rowmark->prti == context->rt_index)
636 : 0 : rowmark->prti = context->new_index;
637 : : }
638 : 0 : return false;
639 : : }
6648 tgl@sss.pgh.pa.us 640 [ - + ]:CBC 57610 : if (IsA(node, AppendRelInfo))
641 : : {
6648 tgl@sss.pgh.pa.us 642 :UBC 0 : AppendRelInfo *appinfo = (AppendRelInfo *) node;
643 : :
644 [ # # ]: 0 : if (context->sublevels_up == 0)
645 : : {
646 [ # # ]: 0 : if (appinfo->parent_relid == context->rt_index)
647 : 0 : appinfo->parent_relid = context->new_index;
648 [ # # ]: 0 : if (appinfo->child_relid == context->rt_index)
649 : 0 : appinfo->child_relid = context->new_index;
650 : : }
651 : : /* fall through to examine children */
652 : : }
653 : : /* Shouldn't need to handle other planner auxiliary nodes here */
5653 tgl@sss.pgh.pa.us 654 [ - + ]:CBC 57610 : Assert(!IsA(node, SpecialJoinInfo));
655 [ - + ]: 57610 : Assert(!IsA(node, PlaceHolderInfo));
4910 656 [ - + ]: 57610 : Assert(!IsA(node, MinMaxAggInfo));
657 : :
8962 658 [ + + ]: 57610 : if (IsA(node, Query))
659 : : {
660 : : /* Recurse into subselects */
661 : : bool result;
662 : :
8615 663 : 1035 : context->sublevels_up++;
664 : 1035 : result = query_tree_walker((Query *) node, ChangeVarNodes_walker,
665 : : (void *) context, 0);
666 : 1035 : context->sublevels_up--;
667 : 1035 : return result;
668 : : }
8962 669 : 56575 : return expression_tree_walker(node, ChangeVarNodes_walker,
670 : : (void *) context);
671 : : }
672 : :
673 : : void
674 : 11313 : ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
675 : : {
676 : : ChangeVarNodes_context context;
677 : :
678 : 11313 : context.rt_index = rt_index;
679 : 11313 : context.new_index = new_index;
680 : 11313 : context.sublevels_up = sublevels_up;
681 : :
682 : : /*
683 : : * Must be prepared to start with a Query or a bare expression tree; if
684 : : * it's a Query, go straight to query_tree_walker to make sure that
685 : : * sublevels_up doesn't get incremented prematurely.
686 : : */
8615 687 [ + + + + ]: 11313 : if (node && IsA(node, Query))
8530 688 : 2209 : {
8424 bruce@momjian.us 689 : 2209 : Query *qry = (Query *) node;
690 : :
691 : : /*
692 : : * If we are starting at a Query, and sublevels_up is zero, then we
693 : : * must also fix rangetable indexes in the Query itself --- namely
694 : : * resultRelation, mergeTargetRelation, exclRelIndex and rowMarks
695 : : * entries. sublevels_up cannot be zero when recursing into a
696 : : * subquery, so there's no need to have the same logic inside
697 : : * ChangeVarNodes_walker.
698 : : */
8530 tgl@sss.pgh.pa.us 699 [ + - ]: 2209 : if (sublevels_up == 0)
700 : : {
701 : : ListCell *l;
702 : :
703 [ + + ]: 2209 : if (qry->resultRelation == rt_index)
704 : 1537 : qry->resultRelation = new_index;
705 : :
45 dean.a.rasheed@gmail 706 [ + + ]:GNC 2209 : if (qry->mergeTargetRelation == rt_index)
707 : 396 : qry->mergeTargetRelation = new_index;
708 : :
709 : : /* this is unlikely to ever be used, but ... */
3259 andres@anarazel.de 710 [ + + - + ]:CBC 2209 : if (qry->onConflict && qry->onConflict->exclRelIndex == rt_index)
3259 andres@anarazel.de 711 :UBC 0 : qry->onConflict->exclRelIndex = new_index;
712 : :
8530 tgl@sss.pgh.pa.us 713 [ + + + + :CBC 2215 : foreach(l, qry->rowMarks)
+ + ]
714 : : {
6559 715 : 6 : RowMarkClause *rc = (RowMarkClause *) lfirst(l);
716 : :
717 [ - + ]: 6 : if (rc->rti == rt_index)
6559 tgl@sss.pgh.pa.us 718 :UBC 0 : rc->rti = new_index;
719 : : }
720 : : }
8530 tgl@sss.pgh.pa.us 721 :CBC 2209 : query_tree_walker(qry, ChangeVarNodes_walker,
722 : : (void *) &context, 0);
723 : : }
724 : : else
8615 725 : 9104 : ChangeVarNodes_walker(node, &context);
8962 726 : 11313 : }
727 : :
728 : : /*
729 : : * Substitute newrelid for oldrelid in a Relid set
730 : : *
731 : : * Note: some extensions may pass a special varno such as INDEX_VAR for
732 : : * oldrelid. bms_is_member won't like that, but we should tolerate it.
733 : : * (Perhaps newrelid could also be a special varno, but there had better
734 : : * not be a reason to inject that into a nullingrels or phrels set.)
735 : : */
736 : : static Relids
7736 737 : 21072 : adjust_relid_set(Relids relids, int oldrelid, int newrelid)
738 : : {
311 739 [ + - - + ]: 21072 : if (!IS_SPECIAL_VARNO(oldrelid) && bms_is_member(oldrelid, relids))
740 : : {
741 : : /* Ensure we have a modifiable copy */
7736 tgl@sss.pgh.pa.us 742 :UBC 0 : relids = bms_copy(relids);
743 : : /* Remove old, add new */
744 : 0 : relids = bms_del_member(relids, oldrelid);
745 : 0 : relids = bms_add_member(relids, newrelid);
746 : : }
7736 tgl@sss.pgh.pa.us 747 :CBC 21072 : return relids;
748 : : }
749 : :
750 : : /*
751 : : * IncrementVarSublevelsUp - adjust Var nodes when pushing them down in tree
752 : : *
753 : : * Find all Var nodes in the given tree having varlevelsup >= min_sublevels_up,
754 : : * and add delta_sublevels_up to their varlevelsup value. This is needed when
755 : : * an expression that's correct for some nesting level is inserted into a
756 : : * subquery. Ordinarily the initial call has min_sublevels_up == 0 so that
757 : : * all Vars are affected. The point of min_sublevels_up is that we can
758 : : * increment it when we recurse into a sublink, so that local variables in
759 : : * that sublink are not affected, only outer references to vars that belong
760 : : * to the expression's original query level or parents thereof.
761 : : *
762 : : * Likewise for other nodes containing levelsup fields, such as Aggref.
763 : : *
764 : : * NOTE: although this has the form of a walker, we cheat and modify the
765 : : * Var nodes in-place. The given expression tree should have been copied
766 : : * earlier to ensure that no unwanted side-effects occur!
767 : : */
768 : :
769 : : typedef struct
770 : : {
771 : : int delta_sublevels_up;
772 : : int min_sublevels_up;
773 : : } IncrementVarSublevelsUp_context;
774 : :
775 : : static bool
8795 776 : 1097102 : IncrementVarSublevelsUp_walker(Node *node,
777 : : IncrementVarSublevelsUp_context *context)
778 : : {
779 [ + + ]: 1097102 : if (node == NULL)
780 : 322503 : return false;
781 [ + + ]: 774599 : if (IsA(node, Var))
782 : : {
783 : 383314 : Var *var = (Var *) node;
784 : :
785 [ + + ]: 383314 : if (var->varlevelsup >= context->min_sublevels_up)
786 : 4499 : var->varlevelsup += context->delta_sublevels_up;
7618 787 : 383314 : return false; /* done here */
788 : : }
6152 789 [ - + ]: 391285 : if (IsA(node, CurrentOfExpr))
790 : : {
791 : : /* this should not happen */
6152 tgl@sss.pgh.pa.us 792 [ # # ]:UBC 0 : if (context->min_sublevels_up == 0)
793 [ # # ]: 0 : elog(ERROR, "cannot push down CurrentOfExpr");
794 : 0 : return false;
795 : : }
7618 tgl@sss.pgh.pa.us 796 [ + + ]:CBC 391285 : if (IsA(node, Aggref))
797 : : {
798 : 1099 : Aggref *agg = (Aggref *) node;
799 : :
800 [ + + ]: 1099 : if (agg->agglevelsup >= context->min_sublevels_up)
801 : 35 : agg->agglevelsup += context->delta_sublevels_up;
802 : : /* fall through to recurse into argument */
803 : : }
3256 andres@anarazel.de 804 [ + + ]: 391285 : if (IsA(node, GroupingFunc))
805 : : {
3249 bruce@momjian.us 806 : 32 : GroupingFunc *grp = (GroupingFunc *) node;
807 : :
3256 andres@anarazel.de 808 [ + - ]: 32 : if (grp->agglevelsup >= context->min_sublevels_up)
809 : 32 : grp->agglevelsup += context->delta_sublevels_up;
810 : : /* fall through to recurse into argument */
811 : : }
5654 tgl@sss.pgh.pa.us 812 [ + + ]: 391285 : if (IsA(node, PlaceHolderVar))
813 : : {
814 : 386 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
815 : :
816 [ + + ]: 386 : if (phv->phlevelsup >= context->min_sublevels_up)
817 : 220 : phv->phlevelsup += context->delta_sublevels_up;
818 : : /* fall through to recurse into argument */
819 : : }
5671 820 [ + + ]: 391285 : if (IsA(node, RangeTblEntry))
821 : : {
822 : 40060 : RangeTblEntry *rte = (RangeTblEntry *) node;
823 : :
824 [ + + ]: 40060 : if (rte->rtekind == RTE_CTE)
825 : : {
826 [ + + ]: 1899 : if (rte->ctelevelsup >= context->min_sublevels_up)
827 : 1884 : rte->ctelevelsup += context->delta_sublevels_up;
828 : : }
829 : 40060 : return false; /* allow range_table_walker to continue */
830 : : }
8615 831 [ + + ]: 351225 : if (IsA(node, Query))
832 : : {
833 : : /* Recurse into subselects */
834 : : bool result;
835 : :
836 : 4573 : context->min_sublevels_up++;
837 : 4573 : result = query_tree_walker((Query *) node,
838 : : IncrementVarSublevelsUp_walker,
839 : : (void *) context,
840 : : QTW_EXAMINE_RTES_BEFORE);
841 : 4573 : context->min_sublevels_up--;
842 : 4573 : return result;
843 : : }
844 : 346652 : return expression_tree_walker(node, IncrementVarSublevelsUp_walker,
845 : : (void *) context);
846 : : }
847 : :
848 : : void
849 : 36657 : IncrementVarSublevelsUp(Node *node, int delta_sublevels_up,
850 : : int min_sublevels_up)
851 : : {
852 : : IncrementVarSublevelsUp_context context;
853 : :
854 : 36657 : context.delta_sublevels_up = delta_sublevels_up;
855 : 36657 : context.min_sublevels_up = min_sublevels_up;
856 : :
857 : : /*
858 : : * Must be prepared to start with a Query or a bare expression tree; if
859 : : * it's a Query, we don't want to increment sublevels_up.
860 : : */
7758 861 : 36657 : query_or_expression_tree_walker(node,
862 : : IncrementVarSublevelsUp_walker,
863 : : (void *) &context,
864 : : QTW_EXAMINE_RTES_BEFORE);
8615 865 : 36657 : }
866 : :
867 : : /*
868 : : * IncrementVarSublevelsUp_rtable -
869 : : * Same as IncrementVarSublevelsUp, but to be invoked on a range table.
870 : : */
871 : : void
5722 heikki.linnakangas@i 872 : 767 : IncrementVarSublevelsUp_rtable(List *rtable, int delta_sublevels_up,
873 : : int min_sublevels_up)
874 : : {
875 : : IncrementVarSublevelsUp_context context;
876 : :
877 : 767 : context.delta_sublevels_up = delta_sublevels_up;
878 : 767 : context.min_sublevels_up = min_sublevels_up;
879 : :
880 : 767 : range_table_walker(rtable,
881 : : IncrementVarSublevelsUp_walker,
882 : : (void *) &context,
883 : : QTW_EXAMINE_RTES_BEFORE);
884 : 767 : }
885 : :
886 : :
887 : : /*
888 : : * rangeTableEntry_used - detect whether an RTE is referenced somewhere
889 : : * in var nodes or join or setOp trees of a query or expression.
890 : : */
891 : :
892 : : typedef struct
893 : : {
894 : : int rt_index;
895 : : int sublevels_up;
896 : : } rangeTableEntry_used_context;
897 : :
898 : : static bool
8615 tgl@sss.pgh.pa.us 899 : 1678932 : rangeTableEntry_used_walker(Node *node,
900 : : rangeTableEntry_used_context *context)
901 : : {
902 [ + + ]: 1678932 : if (node == NULL)
903 : 314821 : return false;
904 [ + + ]: 1364111 : if (IsA(node, Var))
905 : : {
906 : 396062 : Var *var = (Var *) node;
907 : :
908 [ + + ]: 396062 : if (var->varlevelsup == context->sublevels_up &&
440 909 [ + + - + ]: 628364 : (var->varno == context->rt_index ||
910 : 247300 : bms_is_member(context->rt_index, var->varnullingrels)))
8795 911 : 133764 : return true;
912 : 262298 : return false;
913 : : }
6152 914 [ + + ]: 968049 : if (IsA(node, CurrentOfExpr))
915 : : {
916 : 6 : CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
917 : :
918 [ + - ]: 6 : if (context->sublevels_up == 0 &&
919 [ - + ]: 6 : cexpr->cvarno == context->rt_index)
6152 tgl@sss.pgh.pa.us 920 :UBC 0 : return true;
6152 tgl@sss.pgh.pa.us 921 :CBC 6 : return false;
922 : : }
8615 923 [ + + ]: 968043 : if (IsA(node, RangeTblRef))
924 : : {
925 : 56884 : RangeTblRef *rtr = (RangeTblRef *) node;
926 : :
927 [ + + ]: 56884 : if (rtr->rtindex == context->rt_index &&
928 [ + + ]: 30066 : context->sublevels_up == 0)
8795 929 : 28995 : return true;
930 : : /* the subquery itself is visited separately */
8615 931 : 27889 : return false;
932 : : }
8069 933 [ + + ]: 911159 : if (IsA(node, JoinExpr))
934 : : {
7893 bruce@momjian.us 935 : 18575 : JoinExpr *j = (JoinExpr *) node;
936 : :
8069 tgl@sss.pgh.pa.us 937 [ + + ]: 18575 : if (j->rtindex == context->rt_index &&
938 [ - + ]: 33 : context->sublevels_up == 0)
8069 tgl@sss.pgh.pa.us 939 :UBC 0 : return true;
940 : : /* fall through to examine children */
941 : : }
942 : : /* Shouldn't need to handle planner auxiliary nodes here */
5654 tgl@sss.pgh.pa.us 943 [ - + ]:CBC 911159 : Assert(!IsA(node, PlaceHolderVar));
4607 944 [ - + ]: 911159 : Assert(!IsA(node, PlanRowMark));
5722 945 [ - + ]: 911159 : Assert(!IsA(node, SpecialJoinInfo));
6648 946 [ - + ]: 911159 : Assert(!IsA(node, AppendRelInfo));
5654 947 [ - + ]: 911159 : Assert(!IsA(node, PlaceHolderInfo));
4910 948 [ - + ]: 911159 : Assert(!IsA(node, MinMaxAggInfo));
949 : :
8615 950 [ + + ]: 911159 : if (IsA(node, Query))
951 : : {
952 : : /* Recurse into subselects */
953 : : bool result;
954 : :
955 : 6249 : context->sublevels_up++;
956 : 6249 : result = query_tree_walker((Query *) node, rangeTableEntry_used_walker,
957 : : (void *) context, 0);
958 : 6249 : context->sublevels_up--;
959 : 6249 : return result;
960 : : }
961 : 904910 : return expression_tree_walker(node, rangeTableEntry_used_walker,
962 : : (void *) context);
963 : : }
964 : :
965 : : bool
966 : 170326 : rangeTableEntry_used(Node *node, int rt_index, int sublevels_up)
967 : : {
968 : : rangeTableEntry_used_context context;
969 : :
970 : 170326 : context.rt_index = rt_index;
971 : 170326 : context.sublevels_up = sublevels_up;
972 : :
973 : : /*
974 : : * Must be prepared to start with a Query or a bare expression tree; if
975 : : * it's a Query, we don't want to increment sublevels_up.
976 : : */
7758 977 : 170326 : return query_or_expression_tree_walker(node,
978 : : rangeTableEntry_used_walker,
979 : : (void *) &context,
980 : : 0);
981 : : }
982 : :
983 : :
984 : : /*
985 : : * If the given Query is an INSERT ... SELECT construct, extract and
986 : : * return the sub-Query node that represents the SELECT part. Otherwise
987 : : * return the given Query.
988 : : *
989 : : * If subquery_ptr is not NULL, then *subquery_ptr is set to the location
990 : : * of the link to the SELECT subquery inside parsetree, or NULL if not an
991 : : * INSERT ... SELECT.
992 : : *
993 : : * This is a hack needed because transformations on INSERT ... SELECTs that
994 : : * appear in rule actions should be applied to the source SELECT, not to the
995 : : * INSERT part. Perhaps this can be cleaned up with redesigned querytrees.
996 : : */
997 : : Query *
8531 998 : 1700 : getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
999 : : {
1000 : : Query *selectquery;
1001 : : RangeTblEntry *selectrte;
1002 : : RangeTblRef *rtr;
1003 : :
1004 [ + + ]: 1700 : if (subquery_ptr)
1005 : 672 : *subquery_ptr = NULL;
1006 : :
1007 [ - + ]: 1700 : if (parsetree == NULL)
8531 tgl@sss.pgh.pa.us 1008 :UBC 0 : return parsetree;
8531 tgl@sss.pgh.pa.us 1009 [ + + ]:CBC 1700 : if (parsetree->commandType != CMD_INSERT)
1010 : 718 : return parsetree;
1011 : :
1012 : : /*
1013 : : * Currently, this is ONLY applied to rule-action queries, and so we
1014 : : * expect to find the OLD and NEW placeholder entries in the given query.
1015 : : * If they're not there, it must be an INSERT/SELECT in which they've been
1016 : : * pushed down to the SELECT.
1017 : : */
7259 neilc@samurai.com 1018 [ + - ]: 982 : if (list_length(parsetree->rtable) >= 2 &&
6756 bruce@momjian.us 1019 [ + + ]: 982 : strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->aliasname,
5274 tgl@sss.pgh.pa.us 1020 : 894 : "old") == 0 &&
6756 bruce@momjian.us 1021 [ + - ]: 894 : strcmp(rt_fetch(PRS2_NEW_VARNO, parsetree->rtable)->eref->aliasname,
1022 : : "new") == 0)
8531 tgl@sss.pgh.pa.us 1023 : 894 : return parsetree;
1024 [ + - - + ]: 88 : Assert(parsetree->jointree && IsA(parsetree->jointree, FromExpr));
7259 neilc@samurai.com 1025 [ - + ]: 88 : if (list_length(parsetree->jointree->fromlist) != 1)
7569 tgl@sss.pgh.pa.us 1026 [ # # ]:UBC 0 : elog(ERROR, "expected to find SELECT subquery");
7263 neilc@samurai.com 1027 :CBC 88 : rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
416 dean.a.rasheed@gmail 1028 [ - + ]: 88 : if (!IsA(rtr, RangeTblRef))
416 dean.a.rasheed@gmail 1029 [ # # ]:UBC 0 : elog(ERROR, "expected to find SELECT subquery");
8531 tgl@sss.pgh.pa.us 1030 :CBC 88 : selectrte = rt_fetch(rtr->rtindex, parsetree->rtable);
416 dean.a.rasheed@gmail 1031 [ + - ]: 88 : if (!(selectrte->rtekind == RTE_SUBQUERY &&
1032 [ + - ]: 88 : selectrte->subquery &&
1033 [ + - ]: 88 : IsA(selectrte->subquery, Query) &&
1034 [ - + ]: 88 : selectrte->subquery->commandType == CMD_SELECT))
7569 tgl@sss.pgh.pa.us 1035 [ # # ]:UBC 0 : elog(ERROR, "expected to find SELECT subquery");
416 dean.a.rasheed@gmail 1036 :CBC 88 : selectquery = selectrte->subquery;
7259 neilc@samurai.com 1037 [ + - ]: 88 : if (list_length(selectquery->rtable) >= 2 &&
6756 bruce@momjian.us 1038 [ + - ]: 88 : strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->aliasname,
5274 tgl@sss.pgh.pa.us 1039 : 88 : "old") == 0 &&
6756 bruce@momjian.us 1040 [ + - ]: 88 : strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->aliasname,
1041 : : "new") == 0)
1042 : : {
8531 tgl@sss.pgh.pa.us 1043 [ + + ]: 88 : if (subquery_ptr)
8424 bruce@momjian.us 1044 : 30 : *subquery_ptr = &(selectrte->subquery);
8531 tgl@sss.pgh.pa.us 1045 : 88 : return selectquery;
1046 : : }
7569 tgl@sss.pgh.pa.us 1047 [ # # ]:UBC 0 : elog(ERROR, "could not find rule placeholders");
1048 : : return NULL; /* not reached */
1049 : : }
1050 : :
1051 : :
1052 : : /*
1053 : : * Add the given qualifier condition to the query's WHERE clause
1054 : : */
1055 : : void
9715 bruce@momjian.us 1056 :CBC 1789 : AddQual(Query *parsetree, Node *qual)
1057 : : {
1058 : : Node *copy;
1059 : :
9716 1060 [ + + ]: 1789 : if (qual == NULL)
1061 : 843 : return;
1062 : :
8478 tgl@sss.pgh.pa.us 1063 [ - + ]: 946 : if (parsetree->commandType == CMD_UTILITY)
1064 : : {
1065 : : /*
1066 : : * There's noplace to put the qual on a utility statement.
1067 : : *
1068 : : * If it's a NOTIFY, silently ignore the qual; this means that the
1069 : : * NOTIFY will execute, whether or not there are any qualifying rows.
1070 : : * While clearly wrong, this is much more useful than refusing to
1071 : : * execute the rule at all, and extra NOTIFY events are harmless for
1072 : : * typical uses of NOTIFY.
1073 : : *
1074 : : * If it isn't a NOTIFY, error out, since unconditional execution of
1075 : : * other utility stmts is unlikely to be wanted. (This case is not
1076 : : * currently allowed anyway, but keep the test for safety.)
1077 : : */
8478 tgl@sss.pgh.pa.us 1078 [ # # # # ]:UBC 0 : if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
8255 1079 : 0 : return;
1080 : : else
7569 1081 [ # # ]: 0 : ereport(ERROR,
1082 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1083 : : errmsg("conditional utility statements are not implemented")));
1084 : : }
1085 : :
7578 tgl@sss.pgh.pa.us 1086 [ - + ]:CBC 946 : if (parsetree->setOperations != NULL)
1087 : : {
1088 : : /*
1089 : : * There's noplace to put the qual on a setop statement, either. (This
1090 : : * could be fixed, but right now the planner simply ignores any qual
1091 : : * condition on a setop query.)
1092 : : */
7569 tgl@sss.pgh.pa.us 1093 [ # # ]:UBC 0 : ereport(ERROR,
1094 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1095 : : errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
1096 : : }
1097 : :
1098 : : /* INTERSECT wants the original, but we need to copy - Jan */
9197 JanWieck@Yahoo.com 1099 :CBC 946 : copy = copyObject(qual);
1100 : :
8598 tgl@sss.pgh.pa.us 1101 : 946 : parsetree->jointree->quals = make_and_qual(parsetree->jointree->quals,
1102 : : copy);
1103 : :
1104 : : /*
1105 : : * We had better not have stuck an aggregate into the WHERE clause.
1106 : : */
4265 1107 [ - + ]: 946 : Assert(!contain_aggs_of_level(copy, 0));
1108 : :
1109 : : /*
1110 : : * Make sure query is marked correctly if added qual has sublinks. Need
1111 : : * not search qual when query is already marked.
1112 : : */
7482 1113 [ + + ]: 946 : if (!parsetree->hasSubLinks)
1114 : 943 : parsetree->hasSubLinks = checkExprHasSubLink(copy);
1115 : : }
1116 : :
1117 : :
1118 : : /*
1119 : : * Invert the given clause and add it to the WHERE qualifications of the
1120 : : * given querytree. Inversion means "x IS NOT TRUE", not just "NOT x",
1121 : : * else we will do the wrong thing when x evaluates to NULL.
1122 : : */
1123 : : void
7847 1124 : 222 : AddInvertedQual(Query *parsetree, Node *qual)
1125 : : {
1126 : : BooleanTest *invqual;
1127 : :
9716 bruce@momjian.us 1128 [ - + ]: 222 : if (qual == NULL)
9716 bruce@momjian.us 1129 :UBC 0 : return;
1130 : :
1131 : : /* Need not copy input qual, because AddQual will... */
7847 tgl@sss.pgh.pa.us 1132 :CBC 222 : invqual = makeNode(BooleanTest);
7794 1133 : 222 : invqual->arg = (Expr *) qual;
7847 1134 : 222 : invqual->booltesttype = IS_NOT_TRUE;
3339 1135 : 222 : invqual->location = -1;
1136 : :
7847 1137 : 222 : AddQual(parsetree, (Node *) invqual);
1138 : : }
1139 : :
1140 : :
1141 : : /*
1142 : : * add_nulling_relids() finds Vars and PlaceHolderVars that belong to any
1143 : : * of the target_relids, and adds added_relids to their varnullingrels
1144 : : * and phnullingrels fields.
1145 : : */
1146 : : Node *
440 1147 : 2381 : add_nulling_relids(Node *node,
1148 : : const Bitmapset *target_relids,
1149 : : const Bitmapset *added_relids)
1150 : : {
1151 : : add_nulling_relids_context context;
1152 : :
1153 : 2381 : context.target_relids = target_relids;
1154 : 2381 : context.added_relids = added_relids;
1155 : 2381 : context.sublevels_up = 0;
1156 : 2381 : return query_or_expression_tree_mutator(node,
1157 : : add_nulling_relids_mutator,
1158 : : &context,
1159 : : 0);
1160 : : }
1161 : :
1162 : : static Node *
1163 : 11959 : add_nulling_relids_mutator(Node *node,
1164 : : add_nulling_relids_context *context)
1165 : : {
1166 [ - + ]: 11959 : if (node == NULL)
440 tgl@sss.pgh.pa.us 1167 :UBC 0 : return NULL;
440 tgl@sss.pgh.pa.us 1168 [ + + ]:CBC 11959 : if (IsA(node, Var))
1169 : : {
1170 : 4714 : Var *var = (Var *) node;
1171 : :
1172 [ + - + + ]: 9428 : if (var->varlevelsup == context->sublevels_up &&
1173 : 4714 : bms_is_member(var->varno, context->target_relids))
1174 : : {
1175 : 2408 : Relids newnullingrels = bms_union(var->varnullingrels,
1176 : : context->added_relids);
1177 : :
1178 : : /* Copy the Var ... */
1179 : 2408 : var = copyObject(var);
1180 : : /* ... and replace the copy's varnullingrels field */
1181 : 2408 : var->varnullingrels = newnullingrels;
1182 : 2408 : return (Node *) var;
1183 : : }
1184 : : /* Otherwise fall through to copy the Var normally */
1185 : : }
1186 [ + + ]: 7245 : else if (IsA(node, PlaceHolderVar))
1187 : : {
1188 : 3 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
1189 : :
1190 [ + - + - ]: 6 : if (phv->phlevelsup == context->sublevels_up &&
1191 : 3 : bms_overlap(phv->phrels, context->target_relids))
1192 : : {
1193 : 3 : Relids newnullingrels = bms_union(phv->phnullingrels,
1194 : : context->added_relids);
1195 : :
1196 : : /*
1197 : : * We don't modify the contents of the PHV's expression, only add
1198 : : * to phnullingrels. This corresponds to assuming that the PHV
1199 : : * will be evaluated at the same level as before, then perhaps be
1200 : : * nulled as it bubbles up. Hence, just flat-copy the node ...
1201 : : */
1202 : 3 : phv = makeNode(PlaceHolderVar);
1203 : 3 : memcpy(phv, node, sizeof(PlaceHolderVar));
1204 : : /* ... and replace the copy's phnullingrels field */
1205 : 3 : phv->phnullingrels = newnullingrels;
1206 : 3 : return (Node *) phv;
1207 : : }
1208 : : /* Otherwise fall through to copy the PlaceHolderVar normally */
1209 : : }
1210 [ - + ]: 7242 : else if (IsA(node, Query))
1211 : : {
1212 : : /* Recurse into RTE or sublink subquery */
1213 : : Query *newnode;
1214 : :
440 tgl@sss.pgh.pa.us 1215 :UBC 0 : context->sublevels_up++;
1216 : 0 : newnode = query_tree_mutator((Query *) node,
1217 : : add_nulling_relids_mutator,
1218 : : (void *) context,
1219 : : 0);
1220 : 0 : context->sublevels_up--;
1221 : 0 : return (Node *) newnode;
1222 : : }
440 tgl@sss.pgh.pa.us 1223 :CBC 9548 : return expression_tree_mutator(node, add_nulling_relids_mutator,
1224 : : (void *) context);
1225 : : }
1226 : :
1227 : : /*
1228 : : * remove_nulling_relids() removes mentions of the specified RT index(es)
1229 : : * in Var.varnullingrels and PlaceHolderVar.phnullingrels fields within
1230 : : * the given expression, except in nodes belonging to rels listed in
1231 : : * except_relids.
1232 : : */
1233 : : Node *
1234 : 4008 : remove_nulling_relids(Node *node,
1235 : : const Bitmapset *removable_relids,
1236 : : const Bitmapset *except_relids)
1237 : : {
1238 : : remove_nulling_relids_context context;
1239 : :
1240 : 4008 : context.removable_relids = removable_relids;
1241 : 4008 : context.except_relids = except_relids;
1242 : 4008 : context.sublevels_up = 0;
1243 : 4008 : return query_or_expression_tree_mutator(node,
1244 : : remove_nulling_relids_mutator,
1245 : : &context,
1246 : : 0);
1247 : : }
1248 : :
1249 : : static Node *
1250 : 72997 : remove_nulling_relids_mutator(Node *node,
1251 : : remove_nulling_relids_context *context)
1252 : : {
1253 [ + + ]: 72997 : if (node == NULL)
1254 : 19477 : return NULL;
1255 [ + + ]: 53520 : if (IsA(node, Var))
1256 : : {
1257 : 14422 : Var *var = (Var *) node;
1258 : :
1259 [ + + ]: 14422 : if (var->varlevelsup == context->sublevels_up &&
1260 [ + + + + ]: 25777 : !bms_is_member(var->varno, context->except_relids) &&
1261 : 12865 : bms_overlap(var->varnullingrels, context->removable_relids))
1262 : : {
1263 : : /* Copy the Var ... */
1264 : 4157 : var = copyObject(var);
1265 : : /* ... and replace the copy's varnullingrels field */
409 1266 : 4157 : var->varnullingrels = bms_difference(var->varnullingrels,
1267 : : context->removable_relids);
440 1268 : 4157 : return (Node *) var;
1269 : : }
1270 : : /* Otherwise fall through to copy the Var normally */
1271 : : }
1272 [ + + ]: 39098 : else if (IsA(node, PlaceHolderVar))
1273 : : {
1274 : 222 : PlaceHolderVar *phv = (PlaceHolderVar *) node;
1275 : :
1276 [ + - ]: 222 : if (phv->phlevelsup == context->sublevels_up &&
1277 [ + - ]: 222 : !bms_overlap(phv->phrels, context->except_relids))
1278 : : {
1279 : : /*
1280 : : * Note: it might seem desirable to remove the PHV altogether if
1281 : : * phnullingrels goes to empty. Currently we dare not do that
1282 : : * because we use PHVs in some cases to enforce separate identity
1283 : : * of subexpressions; see wrap_non_vars usages in prepjointree.c.
1284 : : */
1285 : : /* Copy the PlaceHolderVar and mutate what's below ... */
1286 : : phv = (PlaceHolderVar *)
1287 : 222 : expression_tree_mutator(node,
1288 : : remove_nulling_relids_mutator,
1289 : : (void *) context);
1290 : : /* ... and replace the copy's phnullingrels field */
409 1291 : 222 : phv->phnullingrels = bms_difference(phv->phnullingrels,
1292 : : context->removable_relids);
1293 : : /* We must also update phrels, if it contains a removable RTI */
440 1294 : 222 : phv->phrels = bms_difference(phv->phrels,
1295 : : context->removable_relids);
1296 [ - + ]: 222 : Assert(!bms_is_empty(phv->phrels));
1297 : 222 : return (Node *) phv;
1298 : : }
1299 : : /* Otherwise fall through to copy the PlaceHolderVar normally */
1300 : : }
1301 [ + + ]: 38876 : else if (IsA(node, Query))
1302 : : {
1303 : : /* Recurse into RTE or sublink subquery */
1304 : : Query *newnode;
1305 : :
1306 : 80 : context->sublevels_up++;
1307 : 80 : newnode = query_tree_mutator((Query *) node,
1308 : : remove_nulling_relids_mutator,
1309 : : (void *) context,
1310 : : 0);
1311 : 80 : context->sublevels_up--;
1312 : 80 : return (Node *) newnode;
1313 : : }
1314 : 49061 : return expression_tree_mutator(node, remove_nulling_relids_mutator,
1315 : : (void *) context);
1316 : : }
1317 : :
1318 : :
1319 : : /*
1320 : : * replace_rte_variables() finds all Vars in an expression tree
1321 : : * that reference a particular RTE, and replaces them with substitute
1322 : : * expressions obtained from a caller-supplied callback function.
1323 : : *
1324 : : * When invoking replace_rte_variables on a portion of a Query, pass the
1325 : : * address of the containing Query's hasSubLinks field as outer_hasSubLinks.
1326 : : * Otherwise, pass NULL, but inserting a SubLink into a non-Query expression
1327 : : * will then cause an error.
1328 : : *
1329 : : * Note: the business with inserted_sublink is needed to update hasSubLinks
1330 : : * in subqueries when the replacement adds a subquery inside a subquery.
1331 : : * Messy, isn't it? We do not need to do similar pushups for hasAggs,
1332 : : * because it isn't possible for this transformation to insert a level-zero
1333 : : * aggregate reference into a subquery --- it could only insert outer aggs.
1334 : : * Likewise for hasWindowFuncs.
1335 : : *
1336 : : * Note: usually, we'd not expose the mutator function or context struct
1337 : : * for a function like this. We do so because callbacks often find it
1338 : : * convenient to recurse directly to the mutator on sub-expressions of
1339 : : * what they will return.
1340 : : */
1341 : : Node *
5338 1342 : 87586 : replace_rte_variables(Node *node, int target_varno, int sublevels_up,
1343 : : replace_rte_variables_callback callback,
1344 : : void *callback_arg,
1345 : : bool *outer_hasSubLinks)
1346 : : {
1347 : : Node *result;
1348 : : replace_rte_variables_context context;
1349 : :
1350 : 87586 : context.callback = callback;
1351 : 87586 : context.callback_arg = callback_arg;
1352 : 87586 : context.target_varno = target_varno;
1353 : 87586 : context.sublevels_up = sublevels_up;
1354 : :
1355 : : /*
1356 : : * We try to initialize inserted_sublink to true if there is no need to
1357 : : * detect new sublinks because the query already has some.
1358 : : */
1359 [ + + + + ]: 87586 : if (node && IsA(node, Query))
1360 : 2302 : context.inserted_sublink = ((Query *) node)->hasSubLinks;
1361 [ + - ]: 85284 : else if (outer_hasSubLinks)
1362 : 85284 : context.inserted_sublink = *outer_hasSubLinks;
1363 : : else
5338 tgl@sss.pgh.pa.us 1364 :UBC 0 : context.inserted_sublink = false;
1365 : :
1366 : : /*
1367 : : * Must be prepared to start with a Query or a bare expression tree; if
1368 : : * it's a Query, we don't want to increment sublevels_up.
1369 : : */
5338 tgl@sss.pgh.pa.us 1370 :CBC 87586 : result = query_or_expression_tree_mutator(node,
1371 : : replace_rte_variables_mutator,
1372 : : (void *) &context,
1373 : : 0);
1374 : :
1375 [ + + ]: 87583 : if (context.inserted_sublink)
1376 : : {
1377 [ + + + + ]: 8631 : if (result && IsA(result, Query))
1378 : 48 : ((Query *) result)->hasSubLinks = true;
1379 [ + - ]: 8583 : else if (outer_hasSubLinks)
1380 : 8583 : *outer_hasSubLinks = true;
1381 : : else
5338 tgl@sss.pgh.pa.us 1382 [ # # ]:UBC 0 : elog(ERROR, "replace_rte_variables inserted a SubLink, but has noplace to record it");
1383 : : }
1384 : :
5338 tgl@sss.pgh.pa.us 1385 :CBC 87583 : return result;
1386 : : }
1387 : :
1388 : : Node *
1389 : 384065 : replace_rte_variables_mutator(Node *node,
1390 : : replace_rte_variables_context *context)
1391 : : {
9716 bruce@momjian.us 1392 [ + + ]: 384065 : if (node == NULL)
8962 tgl@sss.pgh.pa.us 1393 : 119122 : return NULL;
1394 [ + + ]: 264943 : if (IsA(node, Var))
1395 : : {
1396 : 96427 : Var *var = (Var *) node;
1397 : :
5338 1398 [ + + ]: 96427 : if (var->varno == context->target_varno &&
1399 [ + + ]: 57004 : var->varlevelsup == context->sublevels_up)
1400 : : {
1401 : : /* Found a matching variable, make the substitution */
1402 : : Node *newnode;
1403 : :
2411 peter_e@gmx.net 1404 : 53326 : newnode = context->callback(var, context);
1405 : : /* Detect if we are adding a sublink to query */
5338 tgl@sss.pgh.pa.us 1406 [ + + ]: 53326 : if (!context->inserted_sublink)
1407 : 49115 : context->inserted_sublink = checkExprHasSubLink(newnode);
1408 : 53326 : return newnode;
1409 : : }
1410 : : /* otherwise fall through to copy the var normally */
1411 : : }
6152 1412 [ + + ]: 168516 : else if (IsA(node, CurrentOfExpr))
1413 : : {
1414 : 3 : CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
1415 : :
5338 1416 [ + - ]: 3 : if (cexpr->cvarno == context->target_varno &&
6152 1417 [ + - ]: 3 : context->sublevels_up == 0)
1418 : : {
1419 : : /*
1420 : : * We get here if a WHERE CURRENT OF expression turns out to apply
1421 : : * to a view. Someday we might be able to translate the
1422 : : * expression to apply to an underlying table of the view, but
1423 : : * right now it's not implemented.
1424 : : */
1425 [ + - ]: 3 : ereport(ERROR,
1426 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1427 : : errmsg("WHERE CURRENT OF on a view is not implemented")));
1428 : : }
1429 : : /* otherwise fall through to copy the expr normally */
1430 : : }
1431 [ + + ]: 168513 : else if (IsA(node, Query))
1432 : : {
1433 : : /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1434 : : Query *newnode;
1435 : : bool save_inserted_sublink;
1436 : :
8592 1437 : 1238 : context->sublevels_up++;
7482 1438 : 1238 : save_inserted_sublink = context->inserted_sublink;
5338 1439 : 1238 : context->inserted_sublink = ((Query *) node)->hasSubLinks;
7758 1440 : 1238 : newnode = query_tree_mutator((Query *) node,
1441 : : replace_rte_variables_mutator,
1442 : : (void *) context,
1443 : : 0);
7482 1444 : 1238 : newnode->hasSubLinks |= context->inserted_sublink;
1445 : 1238 : context->inserted_sublink = save_inserted_sublink;
8592 1446 : 1238 : context->sublevels_up--;
8962 1447 : 1238 : return (Node *) newnode;
1448 : : }
5338 1449 : 210376 : return expression_tree_mutator(node, replace_rte_variables_mutator,
1450 : : (void *) context);
1451 : : }
1452 : :
1453 : :
1454 : : /*
1455 : : * map_variable_attnos() finds all user-column Vars in an expression tree
1456 : : * that reference a particular RTE, and adjusts their varattnos according
1457 : : * to the given mapping array (varattno n is replaced by attno_map[n-1]).
1458 : : * Vars for system columns are not modified.
1459 : : *
1460 : : * A zero in the mapping array represents a dropped column, which should not
1461 : : * appear in the expression.
1462 : : *
1463 : : * If the expression tree contains a whole-row Var for the target RTE,
1464 : : * *found_whole_row is set to true. In addition, if to_rowtype is
1465 : : * not InvalidOid, we replace the Var with a Var of that vartype, inserting
1466 : : * a ConvertRowtypeExpr to map back to the rowtype expected by the expression.
1467 : : * (Therefore, to_rowtype had better be a child rowtype of the rowtype of the
1468 : : * RTE we're changing references to.) Callers that don't provide to_rowtype
1469 : : * should report an error if *found_whole_row is true; we don't do that here
1470 : : * because we don't know exactly what wording for the error message would
1471 : : * be most appropriate. The caller will be aware of the context.
1472 : : *
1473 : : * This could be built using replace_rte_variables and a callback function,
1474 : : * but since we don't ever need to insert sublinks, replace_rte_variables is
1475 : : * overly complicated.
1476 : : */
1477 : :
1478 : : typedef struct
1479 : : {
1480 : : int target_varno; /* RTE index to search for */
1481 : : int sublevels_up; /* (current) nesting depth */
1482 : : const AttrMap *attno_map; /* map array for user attnos */
1483 : : Oid to_rowtype; /* change whole-row Vars to this type */
1484 : : bool *found_whole_row; /* output flag */
1485 : : } map_variable_attnos_context;
1486 : :
1487 : : static Node *
4306 1488 : 56655 : map_variable_attnos_mutator(Node *node,
1489 : : map_variable_attnos_context *context)
1490 : : {
1491 [ + + ]: 56655 : if (node == NULL)
1492 : 540 : return NULL;
1493 [ + + ]: 56115 : if (IsA(node, Var))
1494 : : {
1495 : 12824 : Var *var = (Var *) node;
1496 : :
1497 [ + + ]: 12824 : if (var->varno == context->target_varno &&
1498 [ + - ]: 12716 : var->varlevelsup == context->sublevels_up)
1499 : : {
1500 : : /* Found a matching variable, make the substitution */
3973 bruce@momjian.us 1501 : 12716 : Var *newvar = (Var *) palloc(sizeof(Var));
1502 : 12716 : int attno = var->varattno;
1503 : :
2375 tgl@sss.pgh.pa.us 1504 : 12716 : *newvar = *var; /* initially copy all fields of the Var */
1505 : :
4306 1506 [ + + ]: 12716 : if (attno > 0)
1507 : : {
1508 : : /* user-defined column, replace attno */
1579 michael@paquier.xyz 1509 [ + - ]: 12653 : if (attno > context->attno_map->maplen ||
1510 [ - + ]: 12653 : context->attno_map->attnums[attno - 1] == 0)
4306 tgl@sss.pgh.pa.us 1511 [ # # ]:UBC 0 : elog(ERROR, "unexpected varattno %d in expression to be mapped",
1512 : : attno);
1557 tgl@sss.pgh.pa.us 1513 :CBC 12653 : newvar->varattno = context->attno_map->attnums[attno - 1];
1514 : : /* If the syntactic referent is same RTE, fix it too */
1515 [ + + ]: 12653 : if (newvar->varnosyn == context->target_varno)
1516 : 12614 : newvar->varattnosyn = newvar->varattno;
1517 : : }
4306 1518 [ + + ]: 63 : else if (attno == 0)
1519 : : {
1520 : : /* whole-row variable, warn caller */
1521 : 27 : *(context->found_whole_row) = true;
1522 : :
1523 : : /* If the caller expects us to convert the Var, do so. */
2375 1524 [ + + ]: 27 : if (OidIsValid(context->to_rowtype) &&
1525 [ + - ]: 24 : context->to_rowtype != var->vartype)
1526 : : {
1527 : : ConvertRowtypeExpr *r;
1528 : :
1529 : : /* This certainly won't work for a RECORD variable. */
2446 rhaas@postgresql.org 1530 [ - + ]: 24 : Assert(var->vartype != RECORDOID);
1531 : :
1532 : : /* Var itself is changed to the requested type. */
2375 tgl@sss.pgh.pa.us 1533 : 24 : newvar->vartype = context->to_rowtype;
1534 : :
1535 : : /*
1536 : : * Add a conversion node on top to convert back to the
1537 : : * original type expected by the expression.
1538 : : */
1539 : 24 : r = makeNode(ConvertRowtypeExpr);
1540 : 24 : r->arg = (Expr *) newvar;
1541 : 24 : r->resulttype = var->vartype;
1542 : 24 : r->convertformat = COERCE_IMPLICIT_CAST;
1543 : 24 : r->location = -1;
1544 : :
1545 : 24 : return (Node *) r;
1546 : : }
1547 : : }
4306 1548 : 12692 : return (Node *) newvar;
1549 : : }
1550 : : /* otherwise fall through to copy the var normally */
1551 : : }
2376 rhaas@postgresql.org 1552 [ + + ]: 43291 : else if (IsA(node, ConvertRowtypeExpr))
1553 : : {
1554 : 18 : ConvertRowtypeExpr *r = (ConvertRowtypeExpr *) node;
2375 tgl@sss.pgh.pa.us 1555 : 18 : Var *var = (Var *) r->arg;
1556 : :
1557 : : /*
1558 : : * If this is coercing a whole-row Var that we need to convert, then
1559 : : * just convert the Var without adding an extra ConvertRowtypeExpr.
1560 : : * Effectively we're simplifying var::parenttype::grandparenttype into
1561 : : * just var::grandparenttype. This avoids building stacks of CREs if
1562 : : * this function is applied repeatedly.
1563 : : */
1564 [ + + ]: 18 : if (IsA(var, Var) &&
1565 [ + + ]: 12 : var->varno == context->target_varno &&
1566 [ + - ]: 9 : var->varlevelsup == context->sublevels_up &&
1567 [ + - ]: 9 : var->varattno == 0 &&
1568 [ + - ]: 9 : OidIsValid(context->to_rowtype) &&
1569 [ + - ]: 9 : context->to_rowtype != var->vartype)
1570 : : {
1571 : : ConvertRowtypeExpr *newnode;
1572 : 9 : Var *newvar = (Var *) palloc(sizeof(Var));
1573 : :
1574 : : /* whole-row variable, warn caller */
1575 : 9 : *(context->found_whole_row) = true;
1576 : :
1577 : 9 : *newvar = *var; /* initially copy all fields of the Var */
1578 : :
1579 : : /* This certainly won't work for a RECORD variable. */
1580 [ - + ]: 9 : Assert(var->vartype != RECORDOID);
1581 : :
1582 : : /* Var itself is changed to the requested type. */
1583 : 9 : newvar->vartype = context->to_rowtype;
1584 : :
2376 rhaas@postgresql.org 1585 : 9 : newnode = (ConvertRowtypeExpr *) palloc(sizeof(ConvertRowtypeExpr));
2375 tgl@sss.pgh.pa.us 1586 : 9 : *newnode = *r; /* initially copy all fields of the CRE */
1587 : 9 : newnode->arg = (Expr *) newvar;
1588 : :
2376 rhaas@postgresql.org 1589 : 9 : return (Node *) newnode;
1590 : : }
1591 : : /* otherwise fall through to process the expression normally */
1592 : : }
4306 tgl@sss.pgh.pa.us 1593 [ - + ]: 43273 : else if (IsA(node, Query))
1594 : : {
1595 : : /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1596 : : Query *newnode;
1597 : :
4306 tgl@sss.pgh.pa.us 1598 :UBC 0 : context->sublevels_up++;
1599 : 0 : newnode = query_tree_mutator((Query *) node,
1600 : : map_variable_attnos_mutator,
1601 : : (void *) context,
1602 : : 0);
1603 : 0 : context->sublevels_up--;
1604 : 0 : return (Node *) newnode;
1605 : : }
4306 tgl@sss.pgh.pa.us 1606 :CBC 43390 : return expression_tree_mutator(node, map_variable_attnos_mutator,
1607 : : (void *) context);
1608 : : }
1609 : :
1610 : : Node *
1611 : 4838 : map_variable_attnos(Node *node,
1612 : : int target_varno, int sublevels_up,
1613 : : const AttrMap *attno_map,
1614 : : Oid to_rowtype, bool *found_whole_row)
1615 : : {
1616 : : map_variable_attnos_context context;
1617 : :
1618 : 4838 : context.target_varno = target_varno;
1619 : 4838 : context.sublevels_up = sublevels_up;
1620 : 4838 : context.attno_map = attno_map;
2446 rhaas@postgresql.org 1621 : 4838 : context.to_rowtype = to_rowtype;
4306 tgl@sss.pgh.pa.us 1622 : 4838 : context.found_whole_row = found_whole_row;
1623 : :
1624 : 4838 : *found_whole_row = false;
1625 : :
1626 : : /*
1627 : : * Must be prepared to start with a Query or a bare expression tree; if
1628 : : * it's a Query, we don't want to increment sublevels_up.
1629 : : */
1630 : 4838 : return query_or_expression_tree_mutator(node,
1631 : : map_variable_attnos_mutator,
1632 : : (void *) &context,
1633 : : 0);
1634 : : }
1635 : :
1636 : :
1637 : : /*
1638 : : * ReplaceVarsFromTargetList - replace Vars with items from a targetlist
1639 : : *
1640 : : * Vars matching target_varno and sublevels_up are replaced by the
1641 : : * entry with matching resno from targetlist, if there is one.
1642 : : *
1643 : : * If there is no matching resno for such a Var, the action depends on the
1644 : : * nomatch_option:
1645 : : * REPLACEVARS_REPORT_ERROR: throw an error
1646 : : * REPLACEVARS_CHANGE_VARNO: change Var's varno to nomatch_varno
1647 : : * REPLACEVARS_SUBSTITUTE_NULL: replace Var with a NULL Const of same type
1648 : : *
1649 : : * The caller must also provide target_rte, the RTE describing the target
1650 : : * relation. This is needed to handle whole-row Vars referencing the target.
1651 : : * We expand such Vars into RowExpr constructs.
1652 : : *
1653 : : * outer_hasSubLinks works the same as for replace_rte_variables().
1654 : : */
1655 : :
1656 : : typedef struct
1657 : : {
1658 : : RangeTblEntry *target_rte;
1659 : : List *targetlist;
1660 : : ReplaceVarsNoMatchOption nomatch_option;
1661 : : int nomatch_varno;
1662 : : } ReplaceVarsFromTargetList_context;
1663 : :
1664 : : static Node *
4175 1665 : 4338 : ReplaceVarsFromTargetList_callback(Var *var,
1666 : : replace_rte_variables_context *context)
1667 : : {
1668 : 4338 : ReplaceVarsFromTargetList_context *rcon = (ReplaceVarsFromTargetList_context *) context->callback_arg;
1669 : : TargetEntry *tle;
1670 : :
5338 1671 [ + + ]: 4338 : if (var->varattno == InvalidAttrNumber)
1672 : : {
1673 : : /* Must expand whole-tuple reference into RowExpr */
1674 : : RowExpr *rowexpr;
1675 : : List *colnames;
1676 : : List *fields;
1677 : :
1678 : : /*
1679 : : * If generating an expansion for a var of a named rowtype (ie, this
1680 : : * is a plain relation RTE), then we must include dummy items for
1681 : : * dropped columns. If the var is RECORD (ie, this is a JOIN), then
1682 : : * omit dropped columns. In the latter case, attach column names to
1683 : : * the RowExpr for use of the executor and ruleutils.c.
1684 : : */
1685 : 27 : expandRTE(rcon->target_rte,
1686 : 27 : var->varno, var->varlevelsup, var->location,
1687 : 27 : (var->vartype != RECORDOID),
1688 : : &colnames, &fields);
1689 : : /* Adjust the generated per-field Vars... */
1690 : 27 : fields = (List *) replace_rte_variables_mutator((Node *) fields,
1691 : : context);
1692 : 27 : rowexpr = makeNode(RowExpr);
1693 : 27 : rowexpr->args = fields;
1694 : 27 : rowexpr->row_typeid = var->vartype;
1695 : 27 : rowexpr->row_format = COERCE_IMPLICIT_CAST;
759 1696 [ - + ]: 27 : rowexpr->colnames = (var->vartype == RECORDOID) ? colnames : NIL;
5338 1697 : 27 : rowexpr->location = var->location;
1698 : :
1699 : 27 : return (Node *) rowexpr;
1700 : : }
1701 : :
1702 : : /* Normal case referencing one targetlist element */
1703 : 4311 : tle = get_tle_by_resno(rcon->targetlist, var->varattno);
1704 : :
4935 1705 [ + + - + ]: 4311 : if (tle == NULL || tle->resjunk)
1706 : : {
1707 : : /* Failed to find column in targetlist */
4175 1708 [ - + + - ]: 195 : switch (rcon->nomatch_option)
1709 : : {
4175 tgl@sss.pgh.pa.us 1710 :UBC 0 : case REPLACEVARS_REPORT_ERROR:
1711 : : /* fall through, throw error below */
1712 : 0 : break;
1713 : :
4175 tgl@sss.pgh.pa.us 1714 :CBC 120 : case REPLACEVARS_CHANGE_VARNO:
1715 : 120 : var = (Var *) copyObject(var);
1716 : 120 : var->varno = rcon->nomatch_varno;
1717 : : /* we leave the syntactic referent alone */
1718 : 120 : return (Node *) var;
1719 : :
1720 : 75 : case REPLACEVARS_SUBSTITUTE_NULL:
1721 : :
1722 : : /*
1723 : : * If Var is of domain type, we should add a CoerceToDomain
1724 : : * node, in case there is a NOT NULL domain constraint.
1725 : : */
1726 : 75 : return coerce_to_domain((Node *) makeNullConst(var->vartype,
1727 : : var->vartypmod,
1728 : : var->varcollid),
1729 : : InvalidOid, -1,
1730 : : var->vartype,
1731 : : COERCION_IMPLICIT,
1732 : : COERCE_IMPLICIT_CAST,
1733 : : -1,
1734 : : false);
1735 : : }
4175 tgl@sss.pgh.pa.us 1736 [ # # ]:UBC 0 : elog(ERROR, "could not find replacement targetlist entry for attno %d",
1737 : : var->varattno);
1738 : : return NULL; /* keep compiler quiet */
1739 : : }
1740 : : else
1741 : : {
1742 : : /* Make a copy of the tlist item to return */
2593 peter_e@gmx.net 1743 :CBC 4116 : Expr *newnode = copyObject(tle->expr);
1744 : :
1745 : : /* Must adjust varlevelsup if tlist item is from higher query */
5338 tgl@sss.pgh.pa.us 1746 [ + + ]: 4116 : if (var->varlevelsup > 0)
2593 peter_e@gmx.net 1747 : 81 : IncrementVarSublevelsUp((Node *) newnode, var->varlevelsup, 0);
1748 : :
1749 : : /*
1750 : : * Check to see if the tlist item contains a PARAM_MULTIEXPR Param,
1751 : : * and throw error if so. This case could only happen when expanding
1752 : : * an ON UPDATE rule's NEW variable and the referenced tlist item in
1753 : : * the original UPDATE command is part of a multiple assignment. There
1754 : : * seems no practical way to handle such cases without multiple
1755 : : * evaluation of the multiple assignment's sub-select, which would
1756 : : * create semantic oddities that users of rules would probably prefer
1757 : : * not to cope with. So treat it as an unimplemented feature.
1758 : : */
1759 [ - + ]: 4116 : if (contains_multiexpr_param((Node *) newnode, NULL))
3588 tgl@sss.pgh.pa.us 1760 [ # # ]:UBC 0 : ereport(ERROR,
1761 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1762 : : errmsg("NEW variables in ON UPDATE rules cannot reference columns that are part of a multiple assignment in the subject UPDATE command")));
1763 : :
2593 peter_e@gmx.net 1764 :CBC 4116 : return (Node *) newnode;
1765 : : }
1766 : : }
1767 : :
1768 : : Node *
4175 tgl@sss.pgh.pa.us 1769 : 2915 : ReplaceVarsFromTargetList(Node *node,
1770 : : int target_varno, int sublevels_up,
1771 : : RangeTblEntry *target_rte,
1772 : : List *targetlist,
1773 : : ReplaceVarsNoMatchOption nomatch_option,
1774 : : int nomatch_varno,
1775 : : bool *outer_hasSubLinks)
1776 : : {
1777 : : ReplaceVarsFromTargetList_context context;
1778 : :
6889 1779 : 2915 : context.target_rte = target_rte;
8598 1780 : 2915 : context.targetlist = targetlist;
4175 1781 : 2915 : context.nomatch_option = nomatch_option;
1782 : 2915 : context.nomatch_varno = nomatch_varno;
1783 : :
5338 1784 : 2915 : return replace_rte_variables(node, target_varno, sublevels_up,
1785 : : ReplaceVarsFromTargetList_callback,
1786 : : (void *) &context,
1787 : : outer_hasSubLinks);
1788 : : }
|
