| blob | 7bf90a98cb48c4b2d6b52e45cdf25690955e10de |
1 /*-------------------------------------------------------------------------
2 *
3 * setrefs.c
4 * Post-processing of a completed plan tree: fix references to subplan
5 * vars, compute regproc values for operators, etc
6 *
7 * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 *
11 * IDENTIFICATION
12 * src/backend/optimizer/plan/setrefs.c
13 *
14 *-------------------------------------------------------------------------
15 */
33 {
40 {
49 {
55 {
59 Index acceptable_rel;
64 {
67 Index newvarno;
71 /*
72 * Check if a Const node is a regclass value. We accept plain OID too,
73 * since a regclass Const will get folded to that type if it's an argument
74 * to oideq or similar operators. (This might result in some extraneous
75 * values in a plan's list of relation dependencies, but the worst result
76 * would be occasional useless replans.)
77 */
78 #define ISREGCLASSCONST(con) \
79 (((con)->consttype == REGCLASSOID || (con)->consttype == OIDOID) && \
80 !(con)->constisnull)
82 #define fix_scan_list(root, lst, rtoffset) \
83 ((List *) fix_scan_expr(root, (Node *) (lst), rtoffset))
123 Index newvarno,
127 Index newvarno);
129 Index sortgroupref,
131 Index newvarno);
142 Index newvarno,
149 Index resultRelation,
153 /*****************************************************************************
154 *
155 * SUBPLAN REFERENCES
156 *
157 *****************************************************************************/
159 /*
160 * set_plan_references
161 *
162 * This is the final processing pass of the planner/optimizer. The plan
163 * tree is complete; we just have to adjust some representational details
164 * for the convenience of the executor:
165 *
166 * 1. We flatten the various subquery rangetables into a single list, and
167 * zero out RangeTblEntry fields that are not useful to the executor.
168 *
169 * 2. We adjust Vars in scan nodes to be consistent with the flat rangetable.
170 *
171 * 3. We adjust Vars in upper plan nodes to refer to the outputs of their
172 * subplans.
173 *
174 * 4. Aggrefs in Agg plan nodes need to be adjusted in some cases involving
175 * partial aggregation or minmax aggregate optimization.
176 *
177 * 5. PARAM_MULTIEXPR Params are replaced by regular PARAM_EXEC Params,
178 * now that we have finished planning all MULTIEXPR subplans.
179 *
180 * 6. We compute regproc OIDs for operators (ie, we look up the function
181 * that implements each op).
182 *
183 * 7. We create lists of specific objects that the plan depends on.
184 * This will be used by plancache.c to drive invalidation of cached plans.
185 * Relation dependencies are represented by OIDs, and everything else by
186 * PlanInvalItems (this distinction is motivated by the shared-inval APIs).
187 * Currently, relations, user-defined functions, and domains are the only
188 * types of objects that are explicitly tracked this way.
189 *
190 * 8. We assign every plan node in the tree a unique ID.
191 *
192 * We also perform one final optimization step, which is to delete
193 * SubqueryScan, Append, and MergeAppend plan nodes that aren't doing
194 * anything useful. The reason for doing this last is that
195 * it can't readily be done before set_plan_references, because it would
196 * break set_upper_references: the Vars in the child plan's top tlist
197 * wouldn't match up with the Vars in the outer plan tree. A SubqueryScan
198 * serves a necessary function as a buffer between outer query and subquery
199 * variable numbering ... but after we've flattened the rangetable this is
200 * no longer a problem, since then there's only one rtindex namespace.
201 * Likewise, Append and MergeAppend buffer between the parent and child vars
202 * of an appendrel, but we don't need to worry about that once we've done
203 * set_plan_references.
204 *
205 * set_plan_references recursively traverses the whole plan tree.
206 *
207 * The return value is normally the same Plan node passed in, but can be
208 * different when the passed-in Plan is a node we decide isn't needed.
209 *
210 * The flattened rangetable entries are appended to root->glob->finalrtable.
211 * Also, rowmarks entries are appended to root->glob->finalrowmarks, and the
212 * RT indexes of ModifyTable result relations to root->glob->resultRelations,
213 * and flattened AppendRelInfos are appended to root->glob->appendRelations.
214 * Plan dependencies are appended to root->glob->relationOids (for relations)
215 * and root->glob->invalItems (for everything else).
216 *
217 * Notice that we modify Plan nodes in-place, but use expression_tree_mutator
218 * to process targetlist and qual expressions. We can assume that the Plan
219 * nodes were just built by the planner and are not multiply referenced, but
220 * it's not so safe to assume that for expression tree nodes.
221 */
222 Plan *
224 {
229 /*
230 * Add all the query's RTEs to the flattened rangetable. The live ones
231 * will have their rangetable indexes increased by rtoffset. (Additional
232 * RTEs, not referenced by the Plan tree, might get added after those.)
233 */
236 /*
237 * Adjust RT indexes of PlanRowMarks and add to final rowmarks list
238 */
240 {
244 /* flat copy is enough since all fields are scalars */
248 /* adjust indexes ... but *not* the rowmarkId */
253 }
255 /*
256 * Adjust RT indexes of AppendRelInfos and add to final appendrels list.
257 * We assume the AppendRelInfos were built during planning and don't need
258 * to be copied.
259 */
261 {
264 /* adjust RT indexes */
268 /*
269 * Rather than adjust the translated_vars entries, just drop 'em.
270 * Neither the executor nor EXPLAIN currently need that data.
271 */
275 }
277 /* Now fix the Plan tree */
279 }
281 /*
282 * Extract RangeTblEntries from the plan's rangetable, and add to flat rtable
283 *
284 * This can recurse into subquery plans; "recursing" is true if so.
285 */
286 static void
288 {
290 Index rti;
293 /*
294 * Add the query's own RTEs to the flattened rangetable.
295 *
296 * At top level, we must add all RTEs so that their indexes in the
297 * flattened rangetable match up with their original indexes. When
298 * recursing, we only care about extracting relation RTEs.
299 */
301 {
306 }
308 /*
309 * If there are any dead subqueries, they are not referenced in the Plan
310 * tree, so we must add RTEs contained in them to the flattened rtable
311 * separately. (If we failed to do this, the executor would not perform
312 * expected permission checks for tables mentioned in such subqueries.)
313 *
314 * Note: this pass over the rangetable can't be combined with the previous
315 * one, because that would mess up the numbering of the live RTEs in the
316 * flattened rangetable.
317 */
320 {
323 /*
324 * We should ignore inheritance-parent RTEs: their contents have been
325 * pulled up into our rangetable already. Also ignore any subquery
326 * RTEs without matching RelOptInfos, as they likewise have been
327 * pulled up.
328 */
331 {
335 {
338 /*
339 * The subquery might never have been planned at all, if it
340 * was excluded on the basis of self-contradictory constraints
341 * in our query level. In this case apply
342 * flatten_unplanned_rtes.
343 *
344 * If it was planned but the result rel is dummy, we assume
345 * that it has been omitted from our plan tree (see
346 * set_subquery_pathlist), and recurse to pull up its RTEs.
347 *
348 * Otherwise, it should be represented by a SubqueryScan node
349 * somewhere in our plan tree, and we'll pull up its RTEs when
350 * we process that plan node.
351 *
352 * However, if we're recursing, then we should pull up RTEs
353 * whether the subquery is dummy or not, because we've found
354 * that some upper query level is treating this one as dummy,
355 * and so we won't scan this level's plan tree at all.
356 */
363 }
364 }
365 rti++;
366 }
367 }
369 /*
370 * Extract RangeTblEntries from a subquery that was never planned at all
371 */
372 static void
374 {
375 /* Use query_tree_walker to find all RTEs in the parse tree */
377 flatten_rtes_walker,
379 QTW_EXAMINE_RTES_BEFORE);
380 }
382 static bool
384 {
388 {
391 /* As above, we need only save relation RTEs */
395 }
397 {
398 /* Recurse into subselects */
400 flatten_rtes_walker,
402 QTW_EXAMINE_RTES_BEFORE);
403 }
406 }
408 /*
409 * Add (a copy of) the given RTE to the final rangetable
410 *
411 * In the flat rangetable, we zero out substructure pointers that are not
412 * needed by the executor; this reduces the storage space and copying cost
413 * for cached plans. We keep only the ctename, alias and eref Alias fields,
414 * which are needed by EXPLAIN, and the selectedCols, insertedCols,
415 * updatedCols, and extraUpdatedCols bitmaps, which are needed for
416 * executor-startup permissions checking and for trigger event checking.
417 */
418 static void
420 {
423 /* flat copy to duplicate all the scalar fields */
427 /* zap unneeded sub-structure */
443 /*
444 * Check for RT index overflow; it's very unlikely, but if it did happen,
445 * the executor would get confused by varnos that match the special varno
446 * values.
447 */
453 /*
454 * If it's a plain relation RTE, add the table to relationOids.
455 *
456 * We do this even though the RTE might be unreferenced in the plan tree;
457 * this would correspond to cases such as views that were expanded, child
458 * tables that were eliminated by constraint exclusion, etc. Schema
459 * invalidation on such a rel must still force rebuilding of the plan.
460 *
461 * Note we don't bother to avoid making duplicate list entries. We could,
462 * but it would probably cost more cycles than it would save.
463 */
466 }
468 /*
469 * set_plan_refs: recurse through the Plan nodes of a single subquery level
470 */
473 {
479 /* Assign this node a unique ID. */
482 /*
483 * Plan-type-specific fixes
484 */
486 {
488 {
496 }
499 {
509 }
512 {
528 }
531 {
535 }
538 {
542 /* no need to fix targetlist and qual */
549 }
552 {
562 }
565 {
575 }
578 /* Needs special treatment, see comments below */
581 rtoffset);
583 {
593 }
596 {
606 }
609 {
619 }
622 {
630 }
633 {
641 }
644 {
652 }
669 {
672 }
685 /*
686 * These plan types don't actually bother to evaluate their
687 * targetlists, because they just return their unmodified input
688 * tuples. Even though the targetlist won't be used by the
689 * executor, we fix it up for possible use by EXPLAIN (not to
690 * mention ease of debugging --- wrong varnos are very confusing).
691 */
694 /*
695 * Since these plan types don't check quals either, we should not
696 * find any qual expression attached to them.
697 */
701 {
704 /*
705 * Like the plan types above, LockRows doesn't evaluate its
706 * tlist or quals. But we have to fix up the RT indexes in
707 * its rowmarks.
708 */
713 {
718 }
719 }
722 {
725 /*
726 * Like the plan types above, Limit doesn't evaluate its tlist
727 * or quals. It does have live expressions for limit/offset,
728 * however; and those cannot contain subplan variable refs, so
729 * fix_scan_expr works for them.
730 */
738 }
741 {
744 /*
745 * If this node is combining partial-aggregation results, we
746 * must convert its Aggrefs to contain references to the
747 * partial-aggregate subexpressions that will be available
748 * from the child plan node.
749 */
751 {
754 NULL);
757 NULL);
758 }
761 }
767 {
772 /*
773 * Like Limit node limit/offset expressions, WindowAgg has
774 * frame offset expressions, which cannot contain subplan
775 * variable refs, so fix_scan_expr works for them.
776 */
781 }
784 {
787 /*
788 * Result may or may not have a subplan; if not, it's more
789 * like a scan node than an upper node.
790 */
793 else
794 {
799 }
800 /* resconstantqual can't contain any subplan variable refs */
803 }
809 {
819 {
825 /*
826 * Pass each per-subplan returningList through
827 * set_returning_clause_references().
828 */
834 {
840 rlist,
841 subplan,
842 resultrel,
843 rtoffset);
845 }
848 /*
849 * Set up the visible plan targetlist as being the same as
850 * the first RETURNING list. This is for the use of
851 * EXPLAIN; the executor won't pay any attention to the
852 * targetlist. We postpone this step until here so that
853 * we don't have to do set_returning_clause_references()
854 * twice on identical targetlists.
855 */
857 }
859 /*
860 * We treat ModifyTable with ON CONFLICT as a form of 'pseudo
861 * join', where the inner side is the EXCLUDED tuple.
862 * Therefore use fix_join_expr to setup the relevant variables
863 * to INNER_VAR. We explicitly don't create any OUTER_VARs as
864 * those are already used by RETURNING and it seems better to
865 * be non-conflicting.
866 */
868 {
877 rtoffset);
883 rtoffset);
889 }
897 {
899 }
901 {
906 }
908 {
911 rtoffset);
912 }
914 /*
915 * Append this ModifyTable node's final result relation RT
916 * index(es) to the global list for the plan, and set its
917 * resultRelIndex to reflect their starting position in the
918 * global list.
919 */
925 /*
926 * If the main target relation is a partitioned table, also
927 * add the partition root's RT index to rootResultRelations,
928 * and remember its index in that list in rootResultRelIndex.
929 */
931 {
937 }
938 }
941 /* Needs special treatment, see comments below */
944 rtoffset);
946 /* Needs special treatment, see comments below */
949 rtoffset);
951 /* This doesn't evaluate targetlist or check quals either */
956 {
959 /* BitmapAnd works like Append, but has no tlist */
963 {
966 rtoffset);
967 }
968 }
971 {
974 /* BitmapOr works like Append, but has no tlist */
978 {
981 rtoffset);
982 }
983 }
989 }
991 /*
992 * Now recurse into child plans, if any
993 *
994 * NOTE: it is essential that we recurse into child plans AFTER we set
995 * subplan references in this plan's tlist and quals. If we did the
996 * reference-adjustments bottom-up, then we would fail to match this
997 * plan's var nodes against the already-modified nodes of the children.
998 */
1003 }
1005 /*
1006 * set_indexonlyscan_references
1007 * Do set_plan_references processing on an IndexOnlyScan
1008 *
1009 * This is unlike the handling of a plain IndexScan because we have to
1010 * convert Vars referencing the heap into Vars referencing the index.
1011 * We can use the fix_upper_expr machinery for that, by working from a
1012 * targetlist describing the index columns.
1013 */
1018 {
1023 /*
1024 * Vars in the plan node's targetlist, qual, and recheckqual must only
1025 * reference columns that the index AM can actually return. To ensure
1026 * this, remove non-returnable columns (which are marked as resjunk) from
1027 * the indexed tlist. We can just drop them because the indexed_tlist
1028 * machinery pays attention to TLE resnos, not physical list position.
1029 */
1032 {
1037 }
1045 index_itlist,
1046 INDEX_VAR,
1047 rtoffset);
1051 index_itlist,
1052 INDEX_VAR,
1053 rtoffset);
1057 index_itlist,
1058 INDEX_VAR,
1059 rtoffset);
1060 /* indexqual is already transformed to reference index columns */
1062 /* indexorderby is already transformed to reference index columns */
1064 /* indextlist must NOT be transformed to reference index columns */
1070 }
1072 /*
1073 * set_subqueryscan_references
1074 * Do set_plan_references processing on a SubqueryScan
1075 *
1076 * We try to strip out the SubqueryScan entirely; if we can't, we have
1077 * to do the normal processing on it.
1078 */
1083 {
1087 /* Need to look up the subquery's RelOptInfo, since we need its subroot */
1090 /* Recursively process the subplan */
1094 {
1095 /*
1096 * We can omit the SubqueryScan node and just pull up the subplan.
1097 */
1099 }
1100 else
1101 {
1102 /*
1103 * Keep the SubqueryScan node. We have to do the processing that
1104 * set_plan_references would otherwise have done on it. Notice we do
1105 * not do set_upper_references() here, because a SubqueryScan will
1106 * always have been created with correct references to its subplan's
1107 * outputs to begin with.
1108 */
1116 }
1119 }
1121 /*
1122 * trivial_subqueryscan
1123 * Detect whether a SubqueryScan can be deleted from the plan tree.
1124 *
1125 * We can delete it if it has no qual to check and the targetlist just
1126 * regurgitates the output of the child plan.
1127 */
1128 static bool
1130 {
1144 {
1151 /*
1152 * We accept either a Var referencing the corresponding element of the
1153 * subplan tlist, or a Const equaling the subplan element. See
1154 * generate_setop_tlist() for motivation.
1155 */
1157 {
1164 }
1166 {
1169 }
1170 else
1173 attrno++;
1174 }
1177 }
1179 /*
1180 * clean_up_removed_plan_level
1181 * Do necessary cleanup when we strip out a SubqueryScan, Append, etc
1182 *
1183 * We are dropping the "parent" plan in favor of returning just its "child".
1184 * A few small tweaks are needed.
1185 */
1188 {
1189 /*
1190 * We have to be sure we don't lose any initplans, so move any that were
1191 * attached to the parent plan to the child. If we do move any, the child
1192 * is no longer parallel-safe.
1193 */
1197 /*
1198 * Attach plans this way so that parent's initplans are processed before
1199 * any pre-existing initplans of the child. Probably doesn't matter, but
1200 * let's preserve the ordering just in case.
1201 */
1205 /*
1206 * We also have to transfer the parent's column labeling info into the
1207 * child, else columns sent to client will be improperly labeled if this
1208 * is the topmost plan level. resjunk and so on may be important too.
1209 */
1213 }
1215 /*
1216 * set_foreignscan_references
1217 * Do set_plan_references processing on a ForeignScan
1218 */
1219 static void
1223 {
1224 /* Adjust scanrelid if it's valid */
1229 {
1230 /*
1231 * Adjust tlist, qual, fdw_exprs, fdw_recheck_quals to reference
1232 * foreign scan tuple
1233 */
1239 itlist,
1240 INDEX_VAR,
1241 rtoffset);
1245 itlist,
1246 INDEX_VAR,
1247 rtoffset);
1251 itlist,
1252 INDEX_VAR,
1253 rtoffset);
1257 itlist,
1258 INDEX_VAR,
1259 rtoffset);
1261 /* fdw_scan_tlist itself just needs fix_scan_list() adjustments */
1264 }
1265 else
1266 {
1267 /*
1268 * Adjust tlist, qual, fdw_exprs, fdw_recheck_quals in the standard
1269 * way
1270 */
1279 }
1282 }
1284 /*
1285 * set_customscan_references
1286 * Do set_plan_references processing on a CustomScan
1287 */
1288 static void
1292 {
1295 /* Adjust scanrelid if it's valid */
1300 {
1301 /* Adjust tlist, qual, custom_exprs to reference custom scan tuple */
1307 itlist,
1308 INDEX_VAR,
1309 rtoffset);
1313 itlist,
1314 INDEX_VAR,
1315 rtoffset);
1319 itlist,
1320 INDEX_VAR,
1321 rtoffset);
1323 /* custom_scan_tlist itself just needs fix_scan_list() adjustments */
1326 }
1327 else
1328 {
1329 /* Adjust tlist, qual, custom_exprs in the standard way */
1336 }
1338 /* Adjust child plan-nodes recursively, if needed */
1340 {
1342 }
1345 }
1347 /*
1348 * set_append_references
1349 * Do set_plan_references processing on an Append
1350 *
1351 * We try to strip out the Append entirely; if we can't, we have
1352 * to do the normal processing on it.
1353 */
1358 {
1361 /*
1362 * Append, like Sort et al, doesn't actually evaluate its targetlist or
1363 * check quals. If it's got exactly one child plan, then it's not doing
1364 * anything useful at all, and we can strip it out.
1365 */
1368 /* First, we gotta recurse on the children */
1370 {
1372 }
1374 /*
1375 * See if it's safe to get rid of the Append entirely. For this to be
1376 * safe, there must be only one child plan and that child plan's parallel
1377 * awareness must match that of the Append's. The reason for the latter
1378 * is that the if the Append is parallel aware and the child is not then
1379 * the calling plan may execute the non-parallel aware child multiple
1380 * times.
1381 */
1387 /*
1388 * Otherwise, clean up the Append as needed. It's okay to do this after
1389 * recursing to the children, because set_dummy_tlist_references doesn't
1390 * look at those.
1391 */
1397 {
1399 {
1404 {
1408 }
1409 }
1410 }
1412 /* We don't need to recurse to lefttree or righttree ... */
1417 }
1419 /*
1420 * set_mergeappend_references
1421 * Do set_plan_references processing on a MergeAppend
1422 *
1423 * We try to strip out the MergeAppend entirely; if we can't, we have
1424 * to do the normal processing on it.
1425 */
1430 {
1433 /*
1434 * MergeAppend, like Sort et al, doesn't actually evaluate its targetlist
1435 * or check quals. If it's got exactly one child plan, then it's not
1436 * doing anything useful at all, and we can strip it out.
1437 */
1440 /* First, we gotta recurse on the children */
1442 {
1444 }
1446 /*
1447 * See if it's safe to get rid of the MergeAppend entirely. For this to
1448 * be safe, there must be only one child plan and that child plan's
1449 * parallel awareness must match that of the MergeAppend's. The reason
1450 * for the latter is that the if the MergeAppend is parallel aware and the
1451 * child is not then the calling plan may execute the non-parallel aware
1452 * child multiple times.
1453 */
1459 /*
1460 * Otherwise, clean up the MergeAppend as needed. It's okay to do this
1461 * after recursing to the children, because set_dummy_tlist_references
1462 * doesn't look at those.
1463 */
1469 {
1471 {
1476 {
1480 }
1481 }
1482 }
1484 /* We don't need to recurse to lefttree or righttree ... */
1489 }
1491 /*
1492 * set_hash_references
1493 * Do set_plan_references processing on a Hash node
1494 */
1495 static void
1497 {
1502 /*
1503 * Hash's hashkeys are used when feeding tuples into the hashtable,
1504 * therefore have them reference Hash's outer plan (which itself is the
1505 * inner plan of the HashJoin).
1506 */
1511 outer_itlist,
1512 OUTER_VAR,
1513 rtoffset);
1515 /* Hash doesn't project */
1518 /* Hash nodes don't have their own quals */
1520 }
1522 /*
1523 * offset_relid_set
1524 * Apply rtoffset to the members of a Relids set.
1525 */
1526 static Relids
1528 {
1532 /* If there's no offset to apply, we needn't recompute the value */
1539 }
1541 /*
1542 * copyVar
1543 * Copy a Var node.
1544 *
1545 * fix_scan_expr and friends do this enough times that it's worth having
1546 * a bespoke routine instead of using the generic copyObject() function.
1547 */
1550 {
1555 }
1557 /*
1558 * fix_expr_common
1559 * Do generic set_plan_references processing on an expression node
1560 *
1561 * This is code that is common to all variants of expression-fixing.
1562 * We must look up operator opcode info for OpExpr and related nodes,
1563 * add OIDs from regclass Const nodes into root->glob->relationOids, and
1564 * add PlanInvalItems for user-defined functions into root->glob->invalItems.
1565 * We also fill in column index lists for GROUPING() expressions.
1566 *
1567 * We assume it's okay to update opcode info in-place. So this could possibly
1568 * scribble on the planner's input data structures, but it's OK.
1569 */
1570 static void
1572 {
1573 /* We assume callers won't call us on a NULL pointer */
1575 {
1578 }
1580 {
1583 }
1585 {
1588 }
1590 {
1594 }
1596 {
1600 }
1602 {
1606 }
1608 {
1612 }
1614 {
1617 /* Check for regclass reference */
1622 }
1624 {
1628 /* If there are no grouping sets, we don't need this. */
1633 {
1638 {
1640 }
1646 }
1647 }
1648 }
1650 /*
1651 * fix_param_node
1652 * Do set_plan_references processing on a Param
1653 *
1654 * If it's a PARAM_MULTIEXPR, replace it with the appropriate Param from
1655 * root->multiexpr_params; otherwise no change is needed.
1656 * Just for paranoia's sake, we make a copy of the node in either case.
1657 */
1660 {
1662 {
1674 }
1676 }
1678 /*
1679 * fix_scan_expr
1680 * Do set_plan_references processing on a scan-level expression
1681 *
1682 * This consists of incrementing all Vars' varnos by rtoffset,
1683 * replacing PARAM_MULTIEXPR Params, expanding PlaceHolderVars,
1684 * replacing Aggref nodes that should be replaced by initplan output Params,
1685 * looking up operator opcode info for OpExpr and related nodes,
1686 * and adding OIDs from regclass Const nodes into root->glob->relationOids.
1687 */
1690 {
1691 fix_scan_expr_context context;
1700 {
1702 }
1703 else
1704 {
1705 /*
1706 * If rtoffset == 0, we don't need to change any Vars, and if there
1707 * are no MULTIEXPR subqueries then we don't need to replace
1708 * PARAM_MULTIEXPR Params, and if there are no placeholders anywhere
1709 * we won't need to remove them, and if there are no minmax Aggrefs we
1710 * won't need to replace them. Then it's OK to just scribble on the
1711 * input node tree instead of copying (since the only change, filling
1712 * in any unset opfuncid fields, is harmless). This saves just enough
1713 * cycles to be noticeable on trivial queries.
1714 */
1717 }
1718 }
1722 {
1726 {
1731 /*
1732 * We should not see any Vars marked INNER_VAR or OUTER_VAR. But an
1733 * indexqual expression could contain INDEX_VAR Vars.
1734 */
1742 }
1746 {
1749 /* See if the Aggref should be replaced by a Param */
1752 {
1757 {
1763 }
1764 }
1765 /* If no match, just fall through to process it normally */
1766 }
1768 {
1776 }
1778 {
1779 /* At scan level, we should always just evaluate the contained expr */
1783 }
1787 }
1789 static bool
1791 {
1798 }
1800 /*
1801 * set_join_references
1802 * Modify the target list and quals of a join node to reference its
1803 * subplans, by setting the varnos to OUTER_VAR or INNER_VAR and setting
1804 * attno values to the result domain number of either the corresponding
1805 * outer or inner join tuple item. Also perform opcode lookup for these
1806 * expressions, and add regclass OIDs to root->glob->relationOids.
1807 */
1808 static void
1810 {
1819 /*
1820 * First process the joinquals (including merge or hash clauses). These
1821 * are logically below the join so they can always use all values
1822 * available from the input tlists. It's okay to also handle
1823 * NestLoopParams now, because those couldn't refer to nullable
1824 * subexpressions.
1825 */
1828 outer_itlist,
1829 inner_itlist,
1831 rtoffset);
1833 /* Now do join-type-specific stuff */
1835 {
1840 {
1845 outer_itlist,
1846 OUTER_VAR,
1847 rtoffset);
1848 /* Check we replaced any PlaceHolderVar with simple Var */
1852 }
1853 }
1855 {
1860 outer_itlist,
1861 inner_itlist,
1863 rtoffset);
1864 }
1866 {
1871 outer_itlist,
1872 inner_itlist,
1874 rtoffset);
1876 /*
1877 * HashJoin's hashkeys are used to look for matching tuples from its
1878 * outer plan (not the Hash node!) in the hashtable.
1879 */
1882 outer_itlist,
1883 OUTER_VAR,
1884 rtoffset);
1885 }
1887 /*
1888 * Now we need to fix up the targetlist and qpqual, which are logically
1889 * above the join. This means they should not re-use any input expression
1890 * that was computed in the nullable side of an outer join. Vars and
1891 * PlaceHolderVars are fine, so we can implement this restriction just by
1892 * clearing has_non_vars in the indexed_tlist structs.
1893 *
1894 * XXX This is a grotty workaround for the fact that we don't clearly
1895 * distinguish between a Var appearing below an outer join and the "same"
1896 * Var appearing above it. If we did, we'd not need to hack the matching
1897 * rules this way.
1898 */
1900 {
1915 }
1919 outer_itlist,
1920 inner_itlist,
1922 rtoffset);
1925 outer_itlist,
1926 inner_itlist,
1928 rtoffset);
1932 }
1934 /*
1935 * set_upper_references
1936 * Update the targetlist and quals of an upper-level plan node
1937 * to refer to the tuples returned by its lefttree subplan.
1938 * Also perform opcode lookup for these expressions, and
1939 * add regclass OIDs to root->glob->relationOids.
1940 *
1941 * This is used for single-input plan types like Agg, Group, Result.
1942 *
1943 * In most cases, we have to match up individual Vars in the tlist and
1944 * qual expressions with elements of the subplan's tlist (which was
1945 * generated by flattening these selfsame expressions, so it should have all
1946 * the required variables). There is an important exception, however:
1947 * depending on where we are in the plan tree, sort/group columns may have
1948 * been pushed into the subplan tlist unflattened. If these values are also
1949 * needed in the output then we want to reference the subplan tlist element
1950 * rather than recomputing the expression.
1951 */
1952 static void
1954 {
1964 {
1968 /* If it's a sort/group item, first try to match by sortref */
1970 {
1974 subplan_itlist,
1975 OUTER_VAR);
1979 subplan_itlist,
1980 OUTER_VAR,
1981 rtoffset);
1982 }
1983 else
1986 subplan_itlist,
1987 OUTER_VAR,
1988 rtoffset);
1992 }
1998 subplan_itlist,
1999 OUTER_VAR,
2000 rtoffset);
2003 }
2005 /*
2006 * set_param_references
2007 * Initialize the initParam list in Gather or Gather merge node such that
2008 * it contains reference of all the params that needs to be evaluated
2009 * before execution of the node. It contains the initplan params that are
2010 * being passed to the plan nodes below it.
2011 */
2012 static void
2014 {
2018 {
2024 {
2026 {
2031 {
2033 }
2034 }
2035 }
2037 /*
2038 * Remember the list of all external initplan params that are used by
2039 * the children of Gather or Gather merge node.
2040 */
2044 else
2047 }
2048 }
2050 /*
2051 * Recursively scan an expression tree and convert Aggrefs to the proper
2052 * intermediate form for combining aggregates. This means (1) replacing each
2053 * one's argument list with a single argument that is the original Aggref
2054 * modified to show partial aggregation and (2) changing the upper Aggref to
2055 * show combining aggregation.
2056 *
2057 * After this step, set_upper_references will replace the partial Aggrefs
2058 * with Vars referencing the lower Agg plan node's outputs, so that the final
2059 * form seen by the executor is a combining Aggref with a Var as input.
2060 *
2061 * It's rather messy to postpone this step until setrefs.c; ideally it'd be
2062 * done in createplan.c. The difficulty is that once we modify the Aggref
2063 * expressions, they will no longer be equal() to their original form and
2064 * so cross-plan-node-level matches will fail. So this has to happen after
2065 * the plan node above the Agg has resolved its subplan references.
2066 */
2069 {
2073 {
2078 /* Assert we've not chosen to partial-ize any unsupported cases */
2082 /*
2083 * Since aggregate calls can't be nested, we needn't recurse into the
2084 * arguments. But for safety, flat-copy the Aggref node itself rather
2085 * than modifying it in-place.
2086 */
2090 /*
2091 * For the parent Aggref, we want to copy all the fields of the
2092 * original aggregate *except* the args list, which we'll replace
2093 * below, and the aggfilter expression, which should be applied only
2094 * by the child not the parent. Rather than explicitly knowing about
2095 * all the other fields here, we can momentarily modify child_agg to
2096 * provide a suitable source for copyObject.
2097 */
2104 /*
2105 * Now, set up child_agg to represent the first phase of partial
2106 * aggregation. For now, assume serialization is required.
2107 */
2110 /*
2111 * And set up parent_agg to represent the second phase.
2112 */
2118 }
2121 }
2123 /*
2124 * set_dummy_tlist_references
2125 * Replace the targetlist of an upper-level plan node with a simple
2126 * list of OUTER_VAR references to its child.
2127 *
2128 * This is used for plan types like Sort and Append that don't evaluate
2129 * their targetlists. Although the executor doesn't care at all what's in
2130 * the tlist, EXPLAIN needs it to be realistic.
2131 *
2132 * Note: we could almost use set_upper_references() here, but it fails for
2133 * Append for lack of a lefttree subplan. Single-purpose code is faster
2134 * anyway.
2135 */
2136 static void
2138 {
2144 {
2149 /*
2150 * As in search_indexed_tlist_for_non_var(), we prefer to keep Consts
2151 * as Consts, not Vars referencing Consts. Here, there's no speed
2152 * advantage to be had, but it makes EXPLAIN output look cleaner, and
2153 * again it avoids confusing the executor.
2154 */
2156 {
2157 /* just reuse the existing TLE node */
2160 }
2170 {
2173 }
2174 else
2175 {
2178 }
2183 }
2186 /* We don't touch plan->qual here */
2187 }
2190 /*
2191 * build_tlist_index --- build an index data structure for a child tlist
2192 *
2193 * In most cases, subplan tlists will be "flat" tlists with only Vars,
2194 * so we try to optimize that case by extracting information about Vars
2195 * in advance. Matching a parent tlist to a child is still an O(N^2)
2196 * operation, but at least with a much smaller constant factor than plain
2197 * tlist_member() searches.
2198 *
2199 * The result of this function is an indexed_tlist struct to pass to
2200 * search_indexed_tlist_for_var() or search_indexed_tlist_for_non_var().
2201 * When done, the indexed_tlist may be freed with a single pfree().
2202 */
2205 {
2210 /* Create data structure with enough slots for all tlist entries */
2219 /* Find the Vars and fill in the index array */
2222 {
2226 {
2232 vinfo++;
2233 }
2236 else
2238 }
2243 }
2245 /*
2246 * build_tlist_index_other_vars --- build a restricted tlist index
2247 *
2248 * This is like build_tlist_index, but we only index tlist entries that
2249 * are Vars belonging to some rel other than the one specified. We will set
2250 * has_ph_vars (allowing PlaceHolderVars to be matched), but not has_non_vars
2251 * (so nothing other than Vars and PlaceHolderVars can be matched).
2252 */
2255 {
2260 /* Create data structure with enough slots for all tlist entries */
2269 /* Find the desired Vars and fill in the index array */
2272 {
2276 {
2280 {
2284 vinfo++;
2285 }
2286 }
2289 }
2294 }
2296 /*
2297 * search_indexed_tlist_for_var --- find a Var in an indexed tlist
2298 *
2299 * If a match is found, return a copy of the given Var with suitably
2300 * modified varno/varattno (to wit, newvarno and the resno of the TLE entry).
2301 * Also ensure that varnosyn is incremented by rtoffset.
2302 * If no match, return NULL.
2303 */
2307 {
2316 {
2318 {
2319 /* Found a match */
2327 }
2328 vinfo++;
2329 }
2331 }
2333 /*
2334 * search_indexed_tlist_for_non_var --- find a non-Var in an indexed tlist
2335 *
2336 * If a match is found, return a Var constructed to reference the tlist item.
2337 * If no match, return NULL.
2338 *
2339 * NOTE: it is a waste of time to call this unless itlist->has_ph_vars or
2340 * itlist->has_non_vars. Furthermore, set_join_references() relies on being
2341 * able to prevent matching of non-Vars by clearing itlist->has_non_vars,
2342 * so there's a correctness reason not to call it unless that's set.
2343 */
2347 {
2350 /*
2351 * If it's a simple Const, replacing it with a Var is silly, even if there
2352 * happens to be an identical Const below; a Var is more expensive to
2353 * execute than a Const. What's more, replacing it could confuse some
2354 * places in the executor that expect to see simple Consts for, eg,
2355 * dropped columns.
2356 */
2362 {
2363 /* Found a matching subplan output expression */
2370 }
2372 }
2374 /*
2375 * search_indexed_tlist_for_sortgroupref --- find a sort/group expression
2376 *
2377 * If a match is found, return a Var constructed to reference the tlist item.
2378 * If no match, return NULL.
2379 *
2380 * This is needed to ensure that we select the right subplan TLE in cases
2381 * where there are multiple textually-equal()-but-volatile sort expressions.
2382 * And it's also faster than search_indexed_tlist_for_non_var.
2383 */
2386 Index sortgroupref,
2388 Index newvarno)
2389 {
2393 {
2396 /* The equal() check should be redundant, but let's be paranoid */
2399 {
2400 /* Found a matching subplan output expression */
2407 }
2408 }
2410 }
2412 /*
2413 * fix_join_expr
2414 * Create a new set of targetlist entries or join qual clauses by
2415 * changing the varno/varattno values of variables in the clauses
2416 * to reference target list values from the outer and inner join
2417 * relation target lists. Also perform opcode lookup and add
2418 * regclass OIDs to root->glob->relationOids.
2419 *
2420 * This is used in three different scenarios:
2421 * 1) a normal join clause, where all the Vars in the clause *must* be
2422 * replaced by OUTER_VAR or INNER_VAR references. In this case
2423 * acceptable_rel should be zero so that any failure to match a Var will be
2424 * reported as an error.
2425 * 2) RETURNING clauses, which may contain both Vars of the target relation
2426 * and Vars of other relations. In this case we want to replace the
2427 * other-relation Vars by OUTER_VAR references, while leaving target Vars
2428 * alone. Thus inner_itlist = NULL and acceptable_rel = the ID of the
2429 * target relation should be passed.
2430 * 3) ON CONFLICT UPDATE SET/WHERE clauses. Here references to EXCLUDED are
2431 * to be replaced with INNER_VAR references, while leaving target Vars (the
2432 * to-be-updated relation) alone. Correspondingly inner_itlist is to be
2433 * EXCLUDED elements, outer_itlist = NULL and acceptable_rel the target
2434 * relation.
2435 *
2436 * 'clauses' is the targetlist or list of join clauses
2437 * 'outer_itlist' is the indexed target list of the outer join relation,
2438 * or NULL
2439 * 'inner_itlist' is the indexed target list of the inner join relation,
2440 * or NULL
2441 * 'acceptable_rel' is either zero or the rangetable index of a relation
2442 * whose Vars may appear in the clause without provoking an error
2443 * 'rtoffset': how much to increment varnos by
2444 *
2445 * Returns the new expression tree. The original clause structure is
2446 * not modified.
2447 */
2453 Index acceptable_rel,
2455 {
2456 fix_join_expr_context context;
2464 }
2468 {
2474 {
2477 /* Look for the var in the input tlists, first in the outer */
2479 {
2482 OUTER_VAR,
2486 }
2488 /* then in the inner. */
2490 {
2493 INNER_VAR,
2497 }
2499 /* If it's for acceptable_rel, adjust and return it */
2501 {
2507 }
2509 /* No referent found for Var */
2511 }
2513 {
2516 /* See if the PlaceHolderVar has bubbled up from a lower plan node */
2518 {
2521 OUTER_VAR);
2524 }
2526 {
2529 INNER_VAR);
2532 }
2534 /* If not supplied by input plans, evaluate the contained expr */
2536 }
2537 /* Try matching more complex expressions too, if tlists have any */
2539 {
2542 OUTER_VAR);
2545 }
2547 {
2550 INNER_VAR);
2553 }
2554 /* Special cases (apply only AFTER failing to match to lower tlist) */
2559 fix_join_expr_mutator,
2561 }
2563 /*
2564 * fix_upper_expr
2565 * Modifies an expression tree so that all Var nodes reference outputs
2566 * of a subplan. Also looks for Aggref nodes that should be replaced
2567 * by initplan output Params. Also performs opcode lookup, and adds
2568 * regclass OIDs to root->glob->relationOids.
2569 *
2570 * This is used to fix up target and qual expressions of non-join upper-level
2571 * plan nodes, as well as index-only scan nodes.
2572 *
2573 * An error is raised if no matching var can be found in the subplan tlist
2574 * --- so this routine should only be applied to nodes whose subplans'
2575 * targetlists were generated by flattening the expressions used in the
2576 * parent node.
2577 *
2578 * If itlist->has_non_vars is true, then we try to match whole subexpressions
2579 * against elements of the subplan tlist, so that we can avoid recomputing
2580 * expressions that were already computed by the subplan. (This is relatively
2581 * expensive, so we don't want to try it in the common case where the
2582 * subplan tlist is just a flattened list of Vars.)
2583 *
2584 * 'node': the tree to be fixed (a target item or qual)
2585 * 'subplan_itlist': indexed target list for subplan (or index)
2586 * 'newvarno': varno to use for Vars referencing tlist elements
2587 * 'rtoffset': how much to increment varnos by
2588 *
2589 * The resulting tree is a copy of the original in which all Var nodes have
2590 * varno = newvarno, varattno = resno of corresponding targetlist element.
2591 * The original tree is not modified.
2592 */
2597 Index newvarno,
2599 {
2600 fix_upper_expr_context context;
2607 }
2611 {
2617 {
2627 }
2629 {
2632 /* See if the PlaceHolderVar has bubbled up from a lower plan node */
2634 {
2640 }
2641 /* If not supplied by input plan, evaluate the contained expr */
2643 }
2644 /* Try matching more complex expressions too, if tlist has any */
2646 {
2652 }
2653 /* Special cases (apply only AFTER failing to match to lower tlist) */
2657 {
2660 /* See if the Aggref should be replaced by a Param */
2663 {
2668 {
2674 }
2675 }
2676 /* If no match, just fall through to process it normally */
2677 }
2680 fix_upper_expr_mutator,
2682 }
2684 /*
2685 * set_returning_clause_references
2686 * Perform setrefs.c's work on a RETURNING targetlist
2687 *
2688 * If the query involves more than just the result table, we have to
2689 * adjust any Vars that refer to other tables to reference junk tlist
2690 * entries in the top subplan's targetlist. Vars referencing the result
2691 * table should be left alone, however (the executor will evaluate them
2692 * using the actual heap tuple, after firing triggers if any). In the
2693 * adjusted RETURNING list, result-table Vars will have their original
2694 * varno (plus rtoffset), but Vars for other rels will have varno OUTER_VAR.
2695 *
2696 * We also must perform opcode lookup and add regclass OIDs to
2697 * root->glob->relationOids.
2698 *
2699 * 'rlist': the RETURNING targetlist to be fixed
2700 * 'topplan': the top subplan node that will be just below the ModifyTable
2701 * node (note it's not yet passed through set_plan_refs)
2702 * 'resultRelation': RT index of the associated result relation
2703 * 'rtoffset': how much to increment varnos by
2704 *
2705 * Note: the given 'root' is for the parent query level, not the 'topplan'.
2706 * This does not matter currently since we only access the dependency-item
2707 * lists in root->glob, but it would need some hacking if we wanted a root
2708 * that actually matches the subplan.
2709 *
2710 * Note: resultRelation is not yet adjusted by rtoffset.
2711 */
2716 Index resultRelation,
2718 {
2721 /*
2722 * We can perform the desired Var fixup by abusing the fix_join_expr
2723 * machinery that formerly handled inner indexscan fixup. We search the
2724 * top plan's targetlist for Vars of non-result relations, and use
2725 * fix_join_expr to convert RETURNING Vars into references to those tlist
2726 * entries, while leaving result-rel Vars as-is.
2727 *
2728 * PlaceHolderVars will also be sought in the targetlist, but no
2729 * more-complex expressions will be. Note that it is not possible for a
2730 * PlaceHolderVar to refer to the result relation, since the result is
2731 * never below an outer join. If that case could happen, we'd have to be
2732 * prepared to pick apart the PlaceHolderVar and evaluate its contained
2733 * expression instead.
2734 */
2738 rlist,
2739 itlist,
2740 NULL,
2741 resultRelation,
2742 rtoffset);
2747 }
2750 /*****************************************************************************
2751 * QUERY DEPENDENCY MANAGEMENT
2752 *****************************************************************************/
2754 /*
2755 * record_plan_function_dependency
2756 * Mark the current plan as depending on a particular function.
2757 *
2758 * This is exported so that the function-inlining code can record a
2759 * dependency on a function that it's removed from the plan tree.
2760 */
2761 void
2763 {
2764 /*
2765 * For performance reasons, we don't bother to track built-in functions;
2766 * we just assume they'll never change (or at least not in ways that'd
2767 * invalidate plans using them). For this purpose we can consider a
2768 * built-in function to be one with OID less than FirstBootstrapObjectId.
2769 * Note that the OID generator guarantees never to generate such an OID
2770 * after startup, even at OID wraparound.
2771 */
2773 {
2776 /*
2777 * It would work to use any syscache on pg_proc, but the easiest is
2778 * PROCOID since we already have the function's OID at hand. Note
2779 * that plancache.c knows we use PROCOID.
2780 */
2786 }
2787 }
2789 /*
2790 * record_plan_type_dependency
2791 * Mark the current plan as depending on a particular type.
2792 *
2793 * This is exported so that eval_const_expressions can record a
2794 * dependency on a domain that it's removed a CoerceToDomain node for.
2795 *
2796 * We don't currently need to record dependencies on domains that the
2797 * plan contains CoerceToDomain nodes for, though that might change in
2798 * future. Hence, this isn't actually called in this module, though
2799 * someday fix_expr_common might call it.
2800 */
2801 void
2803 {
2804 /*
2805 * As in record_plan_function_dependency, ignore the possibility that
2806 * someone would change a built-in domain.
2807 */
2809 {
2812 /*
2813 * It would work to use any syscache on pg_type, but the easiest is
2814 * TYPEOID since we already have the type's OID at hand. Note that
2815 * plancache.c knows we use TYPEOID.
2816 */
2822 }
2823 }
2825 /*
2826 * extract_query_dependencies
2827 * Given a rewritten, but not yet planned, query or queries
2828 * (i.e. a Query node or list of Query nodes), extract dependencies
2829 * just as set_plan_references would do. Also detect whether any
2830 * rewrite steps were affected by RLS.
2831 *
2832 * This is needed by plancache.c to handle invalidation of cached unplanned
2833 * queries.
2834 *
2835 * Note: this does not go through eval_const_expressions, and hence doesn't
2836 * reflect its additions of inlined functions and elided CoerceToDomain nodes
2837 * to the invalItems list. This is obviously OK for functions, since we'll
2838 * see them in the original query tree anyway. For domains, it's OK because
2839 * we don't care about domains unless they get elided. That is, a plan might
2840 * have domain dependencies that the query tree doesn't.
2841 */
2842 void
2847 {
2848 PlannerGlobal glob;
2849 PlannerInfo root;
2851 /* Make up dummy planner state so we can use this module's machinery */
2856 /* Hack: we use glob.dependsOnRole to collect hasRowSecurity flags */
2868 }
2870 /*
2871 * Tree walker for extract_query_dependencies.
2872 *
2873 * This is exported so that expression_planner_with_deps can call it on
2874 * simple expressions (post-planning, not before planning, in that case).
2875 * In that usage, glob.dependsOnRole isn't meaningful, but the relationOids
2876 * and invalItems lists are added to as needed.
2877 */
2878 bool
2880 {
2885 {
2890 {
2891 /*
2892 * This logic must handle any utility command for which parse
2893 * analysis was nontrivial (cf. stmt_requires_parse_analysis).
2894 *
2895 * Notably, CALL requires its own processing.
2896 */
2898 {
2901 /* We need not examine funccall, just the transformed exprs */
2903 context);
2905 }
2907 /*
2908 * Ignore other utility statements, except those (such as EXPLAIN)
2909 * that contain a parsed-but-not-planned query. For those, we
2910 * just need to transfer our attention to the contained query.
2911 */
2915 }
2917 /* Remember if any Query has RLS quals applied by rewriter */
2921 /* Collect relation OIDs in this Query's rtable */
2923 {
2934 }
2936 /* And recurse into the query's subexpressions */
2939 }
2940 /* Extract function dependencies and check for regclass Consts */
2944 }