?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix oversight in previous error-reporting patch; mustn't pfree path string
[PostgreSQL.git] / src / backend / rewrite / rewriteManip.c
blob1f72330631b9300d075bbae10af265656a32078f
1 /*-------------------------------------------------------------------------
2 *
3 * rewriteManip.c
4 *
5 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
6 * Portions Copyright (c) 1994, Regents of the University of California
7 *
8 *
9 * IDENTIFICATION
10 * $PostgreSQL$
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 "optimizer/clauses.h"
20 #include "parser/parse_coerce.h"
21 #include "parser/parse_relation.h"
22 #include "parser/parsetree.h"
23 #include "rewrite/rewriteManip.h"
24
25
26 typedef struct
27 {
28 int sublevels_up;
29 } contain_aggs_of_level_context;
30
31 typedef struct
32 {
33 int agg_location;
34 int sublevels_up;
35 } locate_agg_of_level_context;
36
37 static bool contain_aggs_of_level_walker(Node *node,
38 contain_aggs_of_level_context *context);
39 static bool locate_agg_of_level_walker(Node *node,
40 locate_agg_of_level_context *context);
41 static bool checkExprHasSubLink_walker(Node *node, void *context);
42 static Relids offset_relid_set(Relids relids, int offset);
43 static Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid);
44
45
46 /*
47 * checkExprHasAggs -
48 * Check if an expression contains an aggregate function call of the
49 * current query level.
50 */
51 bool
52 checkExprHasAggs(Node *node)
53 {
54 return contain_aggs_of_level(node, 0);
55 }
56
57 /*
58 * contain_aggs_of_level -
59 * Check if an expression contains an aggregate function call of a
60 * specified query level.
61 *
62 * The objective of this routine is to detect whether there are aggregates
63 * belonging to the given query level. Aggregates belonging to subqueries
64 * or outer queries do NOT cause a true result. We must recurse into
65 * subqueries to detect outer-reference aggregates that logically belong to
66 * the specified query level.
67 */
68 bool
69 contain_aggs_of_level(Node *node, int levelsup)
70 {
71 contain_aggs_of_level_context context;
72
73 context.sublevels_up = levelsup;
74
75 /*
76 * Must be prepared to start with a Query or a bare expression tree; if
77 * it's a Query, we don't want to increment sublevels_up.
78 */
79 return query_or_expression_tree_walker(node,
80 contain_aggs_of_level_walker,
81 (void *) &context,
82 0);
83 }
84
85 static bool
86 contain_aggs_of_level_walker(Node *node,
87 contain_aggs_of_level_context *context)
88 {
89 if (node == NULL)
90 return false;
91 if (IsA(node, Aggref))
92 {
93 if (((Aggref *) node)->agglevelsup == context->sublevels_up)
94 return true; /* abort the tree traversal and return true */
95 /* else fall through to examine argument */
96 }
97 if (IsA(node, Query))
98 {
99 /* Recurse into subselects */
100 bool result;
101
102 context->sublevels_up++;
103 result = query_tree_walker((Query *) node,
104 contain_aggs_of_level_walker,
105 (void *) context, 0);
106 context->sublevels_up--;
107 return result;
108 }
109 return expression_tree_walker(node, contain_aggs_of_level_walker,
110 (void *) context);
111 }
112
113 /*
114 * locate_agg_of_level -
115 * Find the parse location of any aggregate of the specified query level.
116 *
117 * Returns -1 if no such agg is in the querytree, or if they all have
118 * unknown parse location. (The former case is probably caller error,
119 * but we don't bother to distinguish it from the latter case.)
120 *
121 * Note: it might seem appropriate to merge this functionality into
122 * contain_aggs_of_level, but that would complicate that function's API.
123 * Currently, the only uses of this function are for error reporting,
124 * and so shaving cycles probably isn't very important.
125 */
126 int
127 locate_agg_of_level(Node *node, int levelsup)
128 {
129 locate_agg_of_level_context context;
130
131 context.agg_location = -1; /* in case we find nothing */
132 context.sublevels_up = levelsup;
133
134 /*
135 * Must be prepared to start with a Query or a bare expression tree; if
136 * it's a Query, we don't want to increment sublevels_up.
137 */
138 (void) query_or_expression_tree_walker(node,
139 locate_agg_of_level_walker,
140 (void *) &context,
141 0);
142
143 return context.agg_location;
144 }
145
146 static bool
147 locate_agg_of_level_walker(Node *node,
148 locate_agg_of_level_context *context)
149 {
150 if (node == NULL)
151 return false;
152 if (IsA(node, Aggref))
153 {
154 if (((Aggref *) node)->agglevelsup == context->sublevels_up &&
155 ((Aggref *) node)->location >= 0)
156 {
157 context->agg_location = ((Aggref *) node)->location;
158 return true; /* abort the tree traversal and return true */
159 }
160 /* else fall through to examine argument */
161 }
162 if (IsA(node, Query))
163 {
164 /* Recurse into subselects */
165 bool result;
166
167 context->sublevels_up++;
168 result = query_tree_walker((Query *) node,
169 locate_agg_of_level_walker,
170 (void *) context, 0);
171 context->sublevels_up--;
172 return result;
173 }
174 return expression_tree_walker(node, locate_agg_of_level_walker,
175 (void *) context);
176 }
177
178 /*
179 * checkExprHasSubLink -
180 * Check if an expression contains a SubLink.
181 */
182 bool
183 checkExprHasSubLink(Node *node)
184 {
185 /*
186 * If a Query is passed, examine it --- but we should not recurse into
187 * sub-Queries that are in its rangetable or CTE list.
188 */
189 return query_or_expression_tree_walker(node,
190 checkExprHasSubLink_walker,
191 NULL,
192 QTW_IGNORE_RC_SUBQUERIES);
193 }
194
195 static bool
196 checkExprHasSubLink_walker(Node *node, void *context)
197 {
198 if (node == NULL)
199 return false;
200 if (IsA(node, SubLink))
201 return true; /* abort the tree traversal and return true */
202 return expression_tree_walker(node, checkExprHasSubLink_walker, context);
203 }
204
205
206 /*
207 * OffsetVarNodes - adjust Vars when appending one query's RT to another
208 *
209 * Find all Var nodes in the given tree with varlevelsup == sublevels_up,
210 * and increment their varno fields (rangetable indexes) by 'offset'.
211 * The varnoold fields are adjusted similarly. Also, adjust other nodes
212 * that contain rangetable indexes, such as RangeTblRef and JoinExpr.
213 *
214 * NOTE: although this has the form of a walker, we cheat and modify the
215 * nodes in-place. The given expression tree should have been copied
216 * earlier to ensure that no unwanted side-effects occur!
217 */
218
219 typedef struct
220 {
221 int offset;
222 int sublevels_up;
223 } OffsetVarNodes_context;
224
225 static bool
226 OffsetVarNodes_walker(Node *node, OffsetVarNodes_context *context)
227 {
228 if (node == NULL)
229 return false;
230 if (IsA(node, Var))
231 {
232 Var *var = (Var *) node;
233
234 if (var->varlevelsup == context->sublevels_up)
235 {
236 var->varno += context->offset;
237 var->varnoold += context->offset;
238 }
239 return false;
240 }
241 if (IsA(node, CurrentOfExpr))
242 {
243 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
244
245 if (context->sublevels_up == 0)
246 cexpr->cvarno += context->offset;
247 return false;
248 }
249 if (IsA(node, RangeTblRef))
250 {
251 RangeTblRef *rtr = (RangeTblRef *) node;
252
253 if (context->sublevels_up == 0)
254 rtr->rtindex += context->offset;
255 /* the subquery itself is visited separately */
256 return false;
257 }
258 if (IsA(node, JoinExpr))
259 {
260 JoinExpr *j = (JoinExpr *) node;
261
262 if (context->sublevels_up == 0)
263 j->rtindex += context->offset;
264 /* fall through to examine children */
265 }
266 if (IsA(node, FlattenedSubLink))
267 {
268 FlattenedSubLink *fslink = (FlattenedSubLink *) node;
269
270 if (context->sublevels_up == 0)
271 {
272 fslink->lefthand = offset_relid_set(fslink->lefthand,
273 context->offset);
274 fslink->righthand = offset_relid_set(fslink->righthand,
275 context->offset);
276 }
277 /* fall through to examine children */
278 }
279 if (IsA(node, PlaceHolderVar))
280 {
281 PlaceHolderVar *phv = (PlaceHolderVar *) node;
282
283 if (phv->phlevelsup == context->sublevels_up)
284 {
285 phv->phrels = offset_relid_set(phv->phrels,
286 context->offset);
287 }
288 /* fall through to examine children */
289 }
290 if (IsA(node, AppendRelInfo))
291 {
292 AppendRelInfo *appinfo = (AppendRelInfo *) node;
293
294 if (context->sublevels_up == 0)
295 {
296 appinfo->parent_relid += context->offset;
297 appinfo->child_relid += context->offset;
298 }
299 /* fall through to examine children */
300 }
301 /* Shouldn't need to handle other planner auxiliary nodes here */
302 Assert(!IsA(node, SpecialJoinInfo));
303 Assert(!IsA(node, PlaceHolderInfo));
304
305 if (IsA(node, Query))
306 {
307 /* Recurse into subselects */
308 bool result;
309
310 context->sublevels_up++;
311 result = query_tree_walker((Query *) node, OffsetVarNodes_walker,
312 (void *) context, 0);
313 context->sublevels_up--;
314 return result;
315 }
316 return expression_tree_walker(node, OffsetVarNodes_walker,
317 (void *) context);
318 }
319
320 void
321 OffsetVarNodes(Node *node, int offset, int sublevels_up)
322 {
323 OffsetVarNodes_context context;
324
325 context.offset = offset;
326 context.sublevels_up = sublevels_up;
327
328 /*
329 * Must be prepared to start with a Query or a bare expression tree; if
330 * it's a Query, go straight to query_tree_walker to make sure that
331 * sublevels_up doesn't get incremented prematurely.
332 */
333 if (node && IsA(node, Query))
334 {
335 Query *qry = (Query *) node;
336
337 /*
338 * If we are starting at a Query, and sublevels_up is zero, then we
339 * must also fix rangetable indexes in the Query itself --- namely
340 * resultRelation and rowMarks entries. sublevels_up cannot be zero
341 * when recursing into a subquery, so there's no need to have the same
342 * logic inside OffsetVarNodes_walker.
343 */
344 if (sublevels_up == 0)
345 {
346 ListCell *l;
347
348 if (qry->resultRelation)
349 qry->resultRelation += offset;
350 foreach(l, qry->rowMarks)
351 {
352 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
353
354 rc->rti += offset;
355 }
356 }
357 query_tree_walker(qry, OffsetVarNodes_walker,
358 (void *) &context, 0);
359 }
360 else
361 OffsetVarNodes_walker(node, &context);
362 }
363
364 static Relids
365 offset_relid_set(Relids relids, int offset)
366 {
367 Relids result = NULL;
368 Relids tmprelids;
369 int rtindex;
370
371 tmprelids = bms_copy(relids);
372 while ((rtindex = bms_first_member(tmprelids)) >= 0)
373 result = bms_add_member(result, rtindex + offset);
374 bms_free(tmprelids);
375 return result;
376 }
377
378 /*
379 * ChangeVarNodes - adjust Var nodes for a specific change of RT index
380 *
381 * Find all Var nodes in the given tree belonging to a specific relation
382 * (identified by sublevels_up and rt_index), and change their varno fields
383 * to 'new_index'. The varnoold fields are changed too. Also, adjust other
384 * nodes that contain rangetable indexes, such as RangeTblRef and JoinExpr.
385 *
386 * NOTE: although this has the form of a walker, we cheat and modify the
387 * nodes in-place. The given expression tree should have been copied
388 * earlier to ensure that no unwanted side-effects occur!
389 */
390
391 typedef struct
392 {
393 int rt_index;
394 int new_index;
395 int sublevels_up;
396 } ChangeVarNodes_context;
397
398 static bool
399 ChangeVarNodes_walker(Node *node, ChangeVarNodes_context *context)
400 {
401 if (node == NULL)
402 return false;
403 if (IsA(node, Var))
404 {
405 Var *var = (Var *) node;
406
407 if (var->varlevelsup == context->sublevels_up &&
408 var->varno == context->rt_index)
409 {
410 var->varno = context->new_index;
411 var->varnoold = context->new_index;
412 }
413 return false;
414 }
415 if (IsA(node, CurrentOfExpr))
416 {
417 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
418
419 if (context->sublevels_up == 0 &&
420 cexpr->cvarno == context->rt_index)
421 cexpr->cvarno = context->new_index;
422 return false;
423 }
424 if (IsA(node, RangeTblRef))
425 {
426 RangeTblRef *rtr = (RangeTblRef *) node;
427
428 if (context->sublevels_up == 0 &&
429 rtr->rtindex == context->rt_index)
430 rtr->rtindex = context->new_index;
431 /* the subquery itself is visited separately */
432 return false;
433 }
434 if (IsA(node, JoinExpr))
435 {
436 JoinExpr *j = (JoinExpr *) node;
437
438 if (context->sublevels_up == 0 &&
439 j->rtindex == context->rt_index)
440 j->rtindex = context->new_index;
441 /* fall through to examine children */
442 }
443 if (IsA(node, FlattenedSubLink))
444 {
445 FlattenedSubLink *fslink = (FlattenedSubLink *) node;
446
447 if (context->sublevels_up == 0)
448 {
449 fslink->lefthand = adjust_relid_set(fslink->lefthand,
450 context->rt_index,
451 context->new_index);
452 fslink->righthand = adjust_relid_set(fslink->righthand,
453 context->rt_index,
454 context->new_index);
455 }
456 /* fall through to examine children */
457 }
458 if (IsA(node, PlaceHolderVar))
459 {
460 PlaceHolderVar *phv = (PlaceHolderVar *) node;
461
462 if (phv->phlevelsup == context->sublevels_up)
463 {
464 phv->phrels = adjust_relid_set(phv->phrels,
465 context->rt_index,
466 context->new_index);
467 }
468 /* fall through to examine children */
469 }
470 if (IsA(node, AppendRelInfo))
471 {
472 AppendRelInfo *appinfo = (AppendRelInfo *) node;
473
474 if (context->sublevels_up == 0)
475 {
476 if (appinfo->parent_relid == context->rt_index)
477 appinfo->parent_relid = context->new_index;
478 if (appinfo->child_relid == context->rt_index)
479 appinfo->child_relid = context->new_index;
480 }
481 /* fall through to examine children */
482 }
483 /* Shouldn't need to handle other planner auxiliary nodes here */
484 Assert(!IsA(node, SpecialJoinInfo));
485 Assert(!IsA(node, PlaceHolderInfo));
486
487 if (IsA(node, Query))
488 {
489 /* Recurse into subselects */
490 bool result;
491
492 context->sublevels_up++;
493 result = query_tree_walker((Query *) node, ChangeVarNodes_walker,
494 (void *) context, 0);
495 context->sublevels_up--;
496 return result;
497 }
498 return expression_tree_walker(node, ChangeVarNodes_walker,
499 (void *) context);
500 }
501
502 void
503 ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
504 {
505 ChangeVarNodes_context context;
506
507 context.rt_index = rt_index;
508 context.new_index = new_index;
509 context.sublevels_up = sublevels_up;
510
511 /*
512 * Must be prepared to start with a Query or a bare expression tree; if
513 * it's a Query, go straight to query_tree_walker to make sure that
514 * sublevels_up doesn't get incremented prematurely.
515 */
516 if (node && IsA(node, Query))
517 {
518 Query *qry = (Query *) node;
519
520 /*
521 * If we are starting at a Query, and sublevels_up is zero, then we
522 * must also fix rangetable indexes in the Query itself --- namely
523 * resultRelation and rowMarks entries. sublevels_up cannot be zero
524 * when recursing into a subquery, so there's no need to have the same
525 * logic inside ChangeVarNodes_walker.
526 */
527 if (sublevels_up == 0)
528 {
529 ListCell *l;
530
531 if (qry->resultRelation == rt_index)
532 qry->resultRelation = new_index;
533 foreach(l, qry->rowMarks)
534 {
535 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
536
537 if (rc->rti == rt_index)
538 rc->rti = new_index;
539 }
540 }
541 query_tree_walker(qry, ChangeVarNodes_walker,
542 (void *) &context, 0);
543 }
544 else
545 ChangeVarNodes_walker(node, &context);
546 }
547
548 /*
549 * Substitute newrelid for oldrelid in a Relid set
550 */
551 static Relids
552 adjust_relid_set(Relids relids, int oldrelid, int newrelid)
553 {
554 if (bms_is_member(oldrelid, relids))
555 {
556 /* Ensure we have a modifiable copy */
557 relids = bms_copy(relids);
558 /* Remove old, add new */
559 relids = bms_del_member(relids, oldrelid);
560 relids = bms_add_member(relids, newrelid);
561 }
562 return relids;
563 }
564
565 /*
566 * IncrementVarSublevelsUp - adjust Var nodes when pushing them down in tree
567 *
568 * Find all Var nodes in the given tree having varlevelsup >= min_sublevels_up,
569 * and add delta_sublevels_up to their varlevelsup value. This is needed when
570 * an expression that's correct for some nesting level is inserted into a
571 * subquery. Ordinarily the initial call has min_sublevels_up == 0 so that
572 * all Vars are affected. The point of min_sublevels_up is that we can
573 * increment it when we recurse into a sublink, so that local variables in
574 * that sublink are not affected, only outer references to vars that belong
575 * to the expression's original query level or parents thereof.
576 *
577 * Likewise for other nodes containing levelsup fields, such as Aggref.
578 *
579 * NOTE: although this has the form of a walker, we cheat and modify the
580 * Var nodes in-place. The given expression tree should have been copied
581 * earlier to ensure that no unwanted side-effects occur!
582 */
583
584 typedef struct
585 {
586 int delta_sublevels_up;
587 int min_sublevels_up;
588 } IncrementVarSublevelsUp_context;
589
590 static bool
591 IncrementVarSublevelsUp_walker(Node *node,
592 IncrementVarSublevelsUp_context *context)
593 {
594 if (node == NULL)
595 return false;
596 if (IsA(node, Var))
597 {
598 Var *var = (Var *) node;
599
600 if (var->varlevelsup >= context->min_sublevels_up)
601 var->varlevelsup += context->delta_sublevels_up;
602 return false; /* done here */
603 }
604 if (IsA(node, CurrentOfExpr))
605 {
606 /* this should not happen */
607 if (context->min_sublevels_up == 0)
608 elog(ERROR, "cannot push down CurrentOfExpr");
609 return false;
610 }
611 if (IsA(node, Aggref))
612 {
613 Aggref *agg = (Aggref *) node;
614
615 if (agg->agglevelsup >= context->min_sublevels_up)
616 agg->agglevelsup += context->delta_sublevels_up;
617 /* fall through to recurse into argument */
618 }
619 if (IsA(node, PlaceHolderVar))
620 {
621 PlaceHolderVar *phv = (PlaceHolderVar *) node;
622
623 if (phv->phlevelsup >= context->min_sublevels_up)
624 phv->phlevelsup += context->delta_sublevels_up;
625 /* fall through to recurse into argument */
626 }
627 if (IsA(node, RangeTblEntry))
628 {
629 RangeTblEntry *rte = (RangeTblEntry *) node;
630
631 if (rte->rtekind == RTE_CTE)
632 {
633 if (rte->ctelevelsup >= context->min_sublevels_up)
634 rte->ctelevelsup += context->delta_sublevels_up;
635 }
636 return false; /* allow range_table_walker to continue */
637 }
638 if (IsA(node, Query))
639 {
640 /* Recurse into subselects */
641 bool result;
642
643 context->min_sublevels_up++;
644 result = query_tree_walker((Query *) node,
645 IncrementVarSublevelsUp_walker,
646 (void *) context,
647 QTW_EXAMINE_RTES);
648 context->min_sublevels_up--;
649 return result;
650 }
651 return expression_tree_walker(node, IncrementVarSublevelsUp_walker,
652 (void *) context);
653 }
654
655 void
656 IncrementVarSublevelsUp(Node *node, int delta_sublevels_up,
657 int min_sublevels_up)
658 {
659 IncrementVarSublevelsUp_context context;
660
661 context.delta_sublevels_up = delta_sublevels_up;
662 context.min_sublevels_up = min_sublevels_up;
663
664 /*
665 * Must be prepared to start with a Query or a bare expression tree; if
666 * it's a Query, we don't want to increment sublevels_up.
667 */
668 query_or_expression_tree_walker(node,
669 IncrementVarSublevelsUp_walker,
670 (void *) &context,
671 QTW_EXAMINE_RTES);
672 }
673
674 /*
675 * IncrementVarSublevelsUp_rtable -
676 * Same as IncrementVarSublevelsUp, but to be invoked on a range table.
677 */
678 void
679 IncrementVarSublevelsUp_rtable(List *rtable, int delta_sublevels_up,
680 int min_sublevels_up)
681 {
682 IncrementVarSublevelsUp_context context;
683
684 context.delta_sublevels_up = delta_sublevels_up;
685 context.min_sublevels_up = min_sublevels_up;
686
687 range_table_walker(rtable,
688 IncrementVarSublevelsUp_walker,
689 (void *) &context,
690 QTW_EXAMINE_RTES);
691 }
692
693
694 /*
695 * rangeTableEntry_used - detect whether an RTE is referenced somewhere
696 * in var nodes or join or setOp trees of a query or expression.
697 */
698
699 typedef struct
700 {
701 int rt_index;
702 int sublevels_up;
703 } rangeTableEntry_used_context;
704
705 static bool
706 rangeTableEntry_used_walker(Node *node,
707 rangeTableEntry_used_context *context)
708 {
709 if (node == NULL)
710 return false;
711 if (IsA(node, Var))
712 {
713 Var *var = (Var *) node;
714
715 if (var->varlevelsup == context->sublevels_up &&
716 var->varno == context->rt_index)
717 return true;
718 return false;
719 }
720 if (IsA(node, CurrentOfExpr))
721 {
722 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
723
724 if (context->sublevels_up == 0 &&
725 cexpr->cvarno == context->rt_index)
726 return true;
727 return false;
728 }
729 if (IsA(node, RangeTblRef))
730 {
731 RangeTblRef *rtr = (RangeTblRef *) node;
732
733 if (rtr->rtindex == context->rt_index &&
734 context->sublevels_up == 0)
735 return true;
736 /* the subquery itself is visited separately */
737 return false;
738 }
739 if (IsA(node, JoinExpr))
740 {
741 JoinExpr *j = (JoinExpr *) node;
742
743 if (j->rtindex == context->rt_index &&
744 context->sublevels_up == 0)
745 return true;
746 /* fall through to examine children */
747 }
748 /* Shouldn't need to handle planner auxiliary nodes here */
749 Assert(!IsA(node, FlattenedSubLink));
750 Assert(!IsA(node, PlaceHolderVar));
751 Assert(!IsA(node, SpecialJoinInfo));
752 Assert(!IsA(node, AppendRelInfo));
753 Assert(!IsA(node, PlaceHolderInfo));
754
755 if (IsA(node, Query))
756 {
757 /* Recurse into subselects */
758 bool result;
759
760 context->sublevels_up++;
761 result = query_tree_walker((Query *) node, rangeTableEntry_used_walker,
762 (void *) context, 0);
763 context->sublevels_up--;
764 return result;
765 }
766 return expression_tree_walker(node, rangeTableEntry_used_walker,
767 (void *) context);
768 }
769
770 bool
771 rangeTableEntry_used(Node *node, int rt_index, int sublevels_up)
772 {
773 rangeTableEntry_used_context context;
774
775 context.rt_index = rt_index;
776 context.sublevels_up = sublevels_up;
777
778 /*
779 * Must be prepared to start with a Query or a bare expression tree; if
780 * it's a Query, we don't want to increment sublevels_up.
781 */
782 return query_or_expression_tree_walker(node,
783 rangeTableEntry_used_walker,
784 (void *) &context,
785 0);
786 }
787
788
789 /*
790 * attribute_used -
791 * Check if a specific attribute number of a RTE is used
792 * somewhere in the query or expression.
793 */
794
795 typedef struct
796 {
797 int rt_index;
798 int attno;
799 int sublevels_up;
800 } attribute_used_context;
801
802 static bool
803 attribute_used_walker(Node *node,
804 attribute_used_context *context)
805 {
806 if (node == NULL)
807 return false;
808 if (IsA(node, Var))
809 {
810 Var *var = (Var *) node;
811
812 if (var->varlevelsup == context->sublevels_up &&
813 var->varno == context->rt_index &&
814 var->varattno == context->attno)
815 return true;
816 return false;
817 }
818 if (IsA(node, Query))
819 {
820 /* Recurse into subselects */
821 bool result;
822
823 context->sublevels_up++;
824 result = query_tree_walker((Query *) node, attribute_used_walker,
825 (void *) context, 0);
826 context->sublevels_up--;
827 return result;
828 }
829 return expression_tree_walker(node, attribute_used_walker,
830 (void *) context);
831 }
832
833 bool
834 attribute_used(Node *node, int rt_index, int attno, int sublevels_up)
835 {
836 attribute_used_context context;
837
838 context.rt_index = rt_index;
839 context.attno = attno;
840 context.sublevels_up = sublevels_up;
841
842 /*
843 * Must be prepared to start with a Query or a bare expression tree; if
844 * it's a Query, we don't want to increment sublevels_up.
845 */
846 return query_or_expression_tree_walker(node,
847 attribute_used_walker,
848 (void *) &context,
849 0);
850 }
851
852
853 /*
854 * If the given Query is an INSERT ... SELECT construct, extract and
855 * return the sub-Query node that represents the SELECT part. Otherwise
856 * return the given Query.
857 *
858 * If subquery_ptr is not NULL, then *subquery_ptr is set to the location
859 * of the link to the SELECT subquery inside parsetree, or NULL if not an
860 * INSERT ... SELECT.
861 *
862 * This is a hack needed because transformations on INSERT ... SELECTs that
863 * appear in rule actions should be applied to the source SELECT, not to the
864 * INSERT part. Perhaps this can be cleaned up with redesigned querytrees.
865 */
866 Query *
867 getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
868 {
869 Query *selectquery;
870 RangeTblEntry *selectrte;
871 RangeTblRef *rtr;
872
873 if (subquery_ptr)
874 *subquery_ptr = NULL;
875
876 if (parsetree == NULL)
877 return parsetree;
878 if (parsetree->commandType != CMD_INSERT)
879 return parsetree;
880
881 /*
882 * Currently, this is ONLY applied to rule-action queries, and so we
883 * expect to find the *OLD* and *NEW* placeholder entries in the given
884 * query. If they're not there, it must be an INSERT/SELECT in which
885 * they've been pushed down to the SELECT.
886 */
887 if (list_length(parsetree->rtable) >= 2 &&
888 strcmp(rt_fetch(PRS2_OLD_VARNO, parsetree->rtable)->eref->aliasname,
889 "*OLD*") == 0 &&
890 strcmp(rt_fetch(PRS2_NEW_VARNO, parsetree->rtable)->eref->aliasname,
891 "*NEW*") == 0)
892 return parsetree;
893 Assert(parsetree->jointree && IsA(parsetree->jointree, FromExpr));
894 if (list_length(parsetree->jointree->fromlist) != 1)
895 elog(ERROR, "expected to find SELECT subquery");
896 rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
897 Assert(IsA(rtr, RangeTblRef));
898 selectrte = rt_fetch(rtr->rtindex, parsetree->rtable);
899 selectquery = selectrte->subquery;
900 if (!(selectquery && IsA(selectquery, Query) &&
901 selectquery->commandType == CMD_SELECT))
902 elog(ERROR, "expected to find SELECT subquery");
903 if (list_length(selectquery->rtable) >= 2 &&
904 strcmp(rt_fetch(PRS2_OLD_VARNO, selectquery->rtable)->eref->aliasname,
905 "*OLD*") == 0 &&
906 strcmp(rt_fetch(PRS2_NEW_VARNO, selectquery->rtable)->eref->aliasname,
907 "*NEW*") == 0)
908 {
909 if (subquery_ptr)
910 *subquery_ptr = &(selectrte->subquery);
911 return selectquery;
912 }
913 elog(ERROR, "could not find rule placeholders");
914 return NULL; /* not reached */
915 }
916
917
918 /*
919 * Add the given qualifier condition to the query's WHERE clause
920 */
921 void
922 AddQual(Query *parsetree, Node *qual)
923 {
924 Node *copy;
925
926 if (qual == NULL)
927 return;
928
929 if (parsetree->commandType == CMD_UTILITY)
930 {
931 /*
932 * There's noplace to put the qual on a utility statement.
933 *
934 * If it's a NOTIFY, silently ignore the qual; this means that the
935 * NOTIFY will execute, whether or not there are any qualifying rows.
936 * While clearly wrong, this is much more useful than refusing to
937 * execute the rule at all, and extra NOTIFY events are harmless for
938 * typical uses of NOTIFY.
939 *
940 * If it isn't a NOTIFY, error out, since unconditional execution of
941 * other utility stmts is unlikely to be wanted. (This case is not
942 * currently allowed anyway, but keep the test for safety.)
943 */
944 if (parsetree->utilityStmt && IsA(parsetree->utilityStmt, NotifyStmt))
945 return;
946 else
947 ereport(ERROR,
948 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
949 errmsg("conditional utility statements are not implemented")));
950 }
951
952 if (parsetree->setOperations != NULL)
953 {
954 /*
955 * There's noplace to put the qual on a setop statement, either. (This
956 * could be fixed, but right now the planner simply ignores any qual
957 * condition on a setop query.)
958 */
959 ereport(ERROR,
960 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
961 errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
962 }
963
964 /* INTERSECT want's the original, but we need to copy - Jan */
965 copy = copyObject(qual);
966
967 parsetree->jointree->quals = make_and_qual(parsetree->jointree->quals,
968 copy);
969
970 /*
971 * We had better not have stuck an aggregate into the WHERE clause.
972 */
973 Assert(!checkExprHasAggs(copy));
974
975 /*
976 * Make sure query is marked correctly if added qual has sublinks. Need
977 * not search qual when query is already marked.
978 */
979 if (!parsetree->hasSubLinks)
980 parsetree->hasSubLinks = checkExprHasSubLink(copy);
981 }
982
983
984 /*
985 * Invert the given clause and add it to the WHERE qualifications of the
986 * given querytree. Inversion means "x IS NOT TRUE", not just "NOT x",
987 * else we will do the wrong thing when x evaluates to NULL.
988 */
989 void
990 AddInvertedQual(Query *parsetree, Node *qual)
991 {
992 BooleanTest *invqual;
993
994 if (qual == NULL)
995 return;
996
997 /* Need not copy input qual, because AddQual will... */
998 invqual = makeNode(BooleanTest);
999 invqual->arg = (Expr *) qual;
1000 invqual->booltesttype = IS_NOT_TRUE;
1001
1002 AddQual(parsetree, (Node *) invqual);
1003 }
1004
1005
1006 /*
1007 * ResolveNew - replace Vars with corresponding items from a targetlist
1008 *
1009 * Vars matching target_varno and sublevels_up are replaced by the
1010 * entry with matching resno from targetlist, if there is one.
1011 * If not, we either change the unmatched Var's varno to update_varno
1012 * (when event == CMD_UPDATE) or replace it with a constant NULL.
1013 *
1014 * The caller must also provide target_rte, the RTE describing the target
1015 * relation. This is needed to handle whole-row Vars referencing the target.
1016 * We expand such Vars into RowExpr constructs.
1017 *
1018 * Note: the business with inserted_sublink is needed to update hasSubLinks
1019 * in subqueries when the replacement adds a subquery inside a subquery.
1020 * Messy, isn't it? We do not need to do similar pushups for hasAggs,
1021 * because it isn't possible for this transformation to insert a level-zero
1022 * aggregate reference into a subquery --- it could only insert outer aggs.
1023 */
1024
1025 typedef struct
1026 {
1027 int target_varno;
1028 int sublevels_up;
1029 RangeTblEntry *target_rte;
1030 List *targetlist;
1031 int event;
1032 int update_varno;
1033 bool inserted_sublink;
1034 } ResolveNew_context;
1035
1036 static Node *
1037 resolve_one_var(Var *var, ResolveNew_context *context)
1038 {
1039 TargetEntry *tle;
1040
1041 tle = get_tle_by_resno(context->targetlist, var->varattno);
1042
1043 if (tle == NULL)
1044 {
1045 /* Failed to find column in insert/update tlist */
1046 if (context->event == CMD_UPDATE)
1047 {
1048 /* For update, just change unmatched var's varno */
1049 var = (Var *) copyObject(var);
1050 var->varno = context->update_varno;
1051 var->varnoold = context->update_varno;
1052 return (Node *) var;
1053 }
1054 else
1055 {
1056 /* Otherwise replace unmatched var with a null */
1057 /* need coerce_to_domain in case of NOT NULL domain constraint */
1058 return coerce_to_domain((Node *) makeNullConst(var->vartype,
1059 var->vartypmod),
1060 InvalidOid, -1,
1061 var->vartype,
1062 COERCE_IMPLICIT_CAST,
1063 -1,
1064 false,
1065 false);
1066 }
1067 }
1068 else
1069 {
1070 /* Make a copy of the tlist item to return */
1071 Node *n = copyObject(tle->expr);
1072
1073 /* Adjust varlevelsup if tlist item is from higher query */
1074 if (var->varlevelsup > 0)
1075 IncrementVarSublevelsUp(n, var->varlevelsup, 0);
1076 /* Report it if we are adding a sublink to query */
1077 if (!context->inserted_sublink)
1078 context->inserted_sublink = checkExprHasSubLink(n);
1079 return n;
1080 }
1081 }
1082
1083 static Node *
1084 ResolveNew_mutator(Node *node, ResolveNew_context *context)
1085 {
1086 if (node == NULL)
1087 return NULL;
1088 if (IsA(node, Var))
1089 {
1090 Var *var = (Var *) node;
1091 int this_varno = (int) var->varno;
1092 int this_varlevelsup = (int) var->varlevelsup;
1093
1094 if (this_varno == context->target_varno &&
1095 this_varlevelsup == context->sublevels_up)
1096 {
1097 if (var->varattno == InvalidAttrNumber)
1098 {
1099 /* Must expand whole-tuple reference into RowExpr */
1100 RowExpr *rowexpr;
1101 List *colnames;
1102 List *fields;
1103
1104 /*
1105 * If generating an expansion for a var of a named rowtype
1106 * (ie, this is a plain relation RTE), then we must include
1107 * dummy items for dropped columns. If the var is RECORD (ie,
1108 * this is a JOIN), then omit dropped columns. Either way,
1109 * attach column names to the RowExpr for use of ruleutils.c.
1110 */
1111 expandRTE(context->target_rte,
1112 this_varno, this_varlevelsup, var->location,
1113 (var->vartype != RECORDOID),
1114 &colnames, &fields);
1115 /* Adjust the generated per-field Vars... */
1116 fields = (List *) ResolveNew_mutator((Node *) fields,
1117 context);
1118 rowexpr = makeNode(RowExpr);
1119 rowexpr->args = fields;
1120 rowexpr->row_typeid = var->vartype;
1121 rowexpr->row_format = COERCE_IMPLICIT_CAST;
1122 rowexpr->colnames = colnames;
1123 rowexpr->location = -1;
1124
1125 return (Node *) rowexpr;
1126 }
1127
1128 /* Normal case for scalar variable */
1129 return resolve_one_var(var, context);
1130 }
1131 /* otherwise fall through to copy the var normally */
1132 }
1133 else if (IsA(node, CurrentOfExpr))
1134 {
1135 CurrentOfExpr *cexpr = (CurrentOfExpr *) node;
1136 int this_varno = (int) cexpr->cvarno;
1137
1138 if (this_varno == context->target_varno &&
1139 context->sublevels_up == 0)
1140 {
1141 /*
1142 * We get here if a WHERE CURRENT OF expression turns out to apply
1143 * to a view. Someday we might be able to translate the
1144 * expression to apply to an underlying table of the view, but
1145 * right now it's not implemented.
1146 */
1147 ereport(ERROR,
1148 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1149 errmsg("WHERE CURRENT OF on a view is not implemented")));
1150 }
1151 /* otherwise fall through to copy the expr normally */
1152 }
1153 else if (IsA(node, Query))
1154 {
1155 /* Recurse into RTE subquery or not-yet-planned sublink subquery */
1156 Query *newnode;
1157 bool save_inserted_sublink;
1158
1159 context->sublevels_up++;
1160 save_inserted_sublink = context->inserted_sublink;
1161 context->inserted_sublink = false;
1162 newnode = query_tree_mutator((Query *) node,
1163 ResolveNew_mutator,
1164 (void *) context,
1165 0);
1166 newnode->hasSubLinks |= context->inserted_sublink;
1167 context->inserted_sublink = save_inserted_sublink;
1168 context->sublevels_up--;
1169 return (Node *) newnode;
1170 }
1171 return expression_tree_mutator(node, ResolveNew_mutator,
1172 (void *) context);
1173 }
1174
1175 Node *
1176 ResolveNew(Node *node, int target_varno, int sublevels_up,
1177 RangeTblEntry *target_rte,
1178 List *targetlist, int event, int update_varno)
1179 {
1180 Node *result;
1181 ResolveNew_context context;
1182
1183 context.target_varno = target_varno;
1184 context.sublevels_up = sublevels_up;
1185 context.target_rte = target_rte;
1186 context.targetlist = targetlist;
1187 context.event = event;
1188 context.update_varno = update_varno;
1189 context.inserted_sublink = false;
1190
1191 /*
1192 * Must be prepared to start with a Query or a bare expression tree; if
1193 * it's a Query, we don't want to increment sublevels_up.
1194 */
1195 result = query_or_expression_tree_mutator(node,
1196 ResolveNew_mutator,
1197 (void *) &context,
1198 0);
1199
1200 if (context.inserted_sublink)
1201 {
1202 if (IsA(result, Query))
1203 ((Query *) result)->hasSubLinks = true;
1204
1205 /*
1206 * Note: if we're called on a non-Query node then it's the caller's
1207 * responsibility to update hasSubLinks in the ancestor Query. This is
1208 * pretty fragile and perhaps should be rethought ...
1209 */
1210 }
1211
1212 return result;
1213 }
PostgreSQL from CVS