Loading...
Searching...
No Matches
setrefs.c File Reference
#include "postgres.h"#include "access/transam.h"#include "catalog/pg_type.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "optimizer/optimizer.h"#include "optimizer/pathnode.h"#include "optimizer/planmain.h"#include "optimizer/planner.h"#include "optimizer/subselect.h"#include "optimizer/tlist.h"#include "parser/parse_relation.h"#include "rewrite/rewriteManip.h"#include "tcop/utility.h"#include "utils/syscache.h"
Include dependency graph for setrefs.c:
Go to the source code of this file.
Data Structures | |
| struct | tlist_vinfo |
| struct | indexed_tlist |
| struct | fix_scan_expr_context |
| struct | fix_join_expr_context |
| struct | fix_upper_expr_context |
| struct | fix_windowagg_cond_context |
| struct | flatten_rtes_walker_context |
Macros | |
| #define | NUM_EXEC_TLIST(parentplan) ((parentplan)->plan_rows) |
| #define | NUM_EXEC_QUAL(parentplan) ((parentplan)->plan_rows * 2.0) |
| #define | ISREGCLASSCONST(con) |
| #define | fix_scan_list(root, lst, rtoffset, num_exec) ((List *) fix_scan_expr(root, (Node *) (lst), rtoffset, num_exec)) |
Enumerations | |
| enum | NullingRelsMatch { NRM_EQUAL , NRM_SUBSET , NRM_SUPERSET } |
Macro Definition Documentation
◆ fix_scan_list
| #define fix_scan_list | ( | root, | |
| lst, | |||
| rtoffset, | |||
| num_exec | |||
| ) | ((List *) fix_scan_expr(root, (Node *) (lst), rtoffset, num_exec)) |
Definition at line 130 of file setrefs.c.
291{
292 Plan *result;
296
297 /*
298 * Add all the query's RTEs to the flattened rangetable. The live ones
299 * will have their rangetable indexes increased by rtoffset. (Additional
300 * RTEs, not referenced by the Plan tree, might get added after those.)
301 */
303
304 /*
305 * Adjust RT indexes of PlanRowMarks and add to final rowmarks list
306 */
308 {
311
312 /* sanity check on existing row marks */
315
316 /* flat copy is enough since all fields are scalars */
319
320 /* adjust indexes ... but *not* the rowmarkId */
321 newrc->rti += rtoffset;
322 newrc->prti += rtoffset;
323
325 }
326
327 /*
328 * Adjust RT indexes of AppendRelInfos and add to final appendrels list.
329 * We assume the AppendRelInfos were built during planning and don't need
330 * to be copied.
331 */
333 {
335
336 /* adjust RT indexes */
337 appinfo->parent_relid += rtoffset;
338 appinfo->child_relid += rtoffset;
339
340 /*
341 * Rather than adjust the translated_vars entries, just drop 'em.
342 * Neither the executor nor EXPLAIN currently need that data.
343 */
345
347 }
348
349 /* If needed, create workspace for processing AlternativeSubPlans */
351 {
356 }
357
358 /* Now fix the Plan tree */
360
361 /*
362 * If we have AlternativeSubPlans, it is likely that we now have some
363 * unreferenced subplans in glob->subplans. To avoid expending cycles on
364 * those subplans later, get rid of them by setting those list entries to
365 * NULL. (Note: we can't do this immediately upon processing an
366 * AlternativeSubPlan, because there may be multiple copies of the
367 * AlternativeSubPlan, and they can get resolved differently.)
368 */
370 {
372 {
374
375 /*
376 * If it was used by some AlternativeSubPlan in this query level,
377 * but wasn't selected as best by any AlternativeSubPlan, then we
378 * don't need it. Do not touch subplans that aren't parts of
379 * AlternativeSubPlans.
380 */
383 }
384 }
385
386 return result;
387}
388
389/*
390 * Extract RangeTblEntries from the plan's rangetable, and add to flat rtable
391 *
392 * This can recurse into subquery plans; "recursing" is true if so.
393 *
394 * This also seems like a good place to add the query's RTEPermissionInfos to
395 * the flat rteperminfos.
396 */
397static void
399{
401 Index rti;
403
404 /*
405 * Record enough information to make it possible for code that looks at
406 * the final range table to understand how it was constructed. (If
407 * finalrtable is still NIL, then this is the very topmost PlannerInfo,
408 * which will always have plan_name == NULL and rtoffset == 0; we omit the
409 * degenerate list entry.)
410 */
412 {
414
417
418 /* When recursing = true, it's an unplanned or dummy subquery. */
419 rtinfo->dummy = recursing;
420
422 }
423
424 /*
425 * Add the query's own RTEs to the flattened rangetable.
426 *
427 * At top level, we must add all RTEs so that their indexes in the
428 * flattened rangetable match up with their original indexes. When
429 * recursing, we only care about extracting relation RTEs (and subquery
430 * RTEs that were once relation RTEs).
431 */
433 {
435
439 }
440
441 /*
442 * If there are any dead subqueries, they are not referenced in the Plan
443 * tree, so we must add RTEs contained in them to the flattened rtable
444 * separately. (If we failed to do this, the executor would not perform
445 * expected permission checks for tables mentioned in such subqueries.)
446 *
447 * Note: this pass over the rangetable can't be combined with the previous
448 * one, because that would mess up the numbering of the live RTEs in the
449 * flattened rangetable.
450 */
451 rti = 1;
453 {
455
456 /*
457 * We should ignore inheritance-parent RTEs: their contents have been
458 * pulled up into our rangetable already. Also ignore any subquery
459 * RTEs without matching RelOptInfos, as they likewise have been
460 * pulled up.
461 */
463 rti < root->simple_rel_array_size)
464 {
466
468 {
470
471 /*
472 * The subquery might never have been planned at all, if it
473 * was excluded on the basis of self-contradictory constraints
474 * in our query level. In this case apply
475 * flatten_unplanned_rtes.
476 *
477 * If it was planned but the result rel is dummy, we assume
478 * that it has been omitted from our plan tree (see
479 * set_subquery_pathlist), and recurse to pull up its RTEs.
480 *
481 * Otherwise, it should be represented by a SubqueryScan node
482 * somewhere in our plan tree, and we'll pull up its RTEs when
483 * we process that plan node.
484 *
485 * However, if we're recursing, then we should pull up RTEs
486 * whether the subquery is dummy or not, because we've found
487 * that some upper query level is treating this one as dummy,
488 * and so we won't scan this level's plan tree at all.
489 */
492 else if (recursing ||
496 }
497 }
498 rti++;
499 }
500}
501
502/*
503 * Extract RangeTblEntries from a subquery that was never planned at all
504 */
505
506static void
508{
510
511 /* Use query_tree_walker to find all RTEs in the parse tree */
513 flatten_rtes_walker,
514 &cxt,
515 QTW_EXAMINE_RTES_BEFORE);
516}
517
518static bool
520{
522 return false;
524 {
526
527 /* As above, we need only save relation RTEs and former relations */
531 return false;
532 }
534 {
535 /*
536 * Recurse into subselects. Must update cxt->query to this query so
537 * that the rtable and rteperminfos correspond with each other.
538 */
540 bool result;
541
544 flatten_rtes_walker,
545 cxt,
546 QTW_EXAMINE_RTES_BEFORE);
548 return result;
549 }
551}
552
553/*
554 * Add (a copy of) the given RTE to the final rangetable and also the
555 * corresponding RTEPermissionInfo, if any, to final rteperminfos.
556 *
557 * In the flat rangetable, we zero out substructure pointers that are not
558 * needed by the executor; this reduces the storage space and copying cost
559 * for cached plans. We keep only the ctename, alias, eref Alias fields,
560 * which are needed by EXPLAIN, and perminfoindex which is needed by the
561 * executor to fetch the RTE's RTEPermissionInfo.
562 */
563static void
566{
568
569 /* flat copy to duplicate all the scalar fields */
572
573 /* zap unneeded sub-structure */
588
590
591 /*
592 * If it's a plain relation RTE (or a subquery that was once a view
593 * reference), add the relation OID to relationOids. Also add its new RT
594 * index to the set of relations to be potentially accessed during
595 * execution.
596 *
597 * We do this even though the RTE might be unreferenced in the plan tree;
598 * this would correspond to cases such as views that were expanded, child
599 * tables that were eliminated by constraint exclusion, etc. Schema
600 * invalidation on such a rel must still force rebuilding of the plan.
601 *
602 * Note we don't bother to avoid making duplicate list entries. We could,
603 * but it would probably cost more cycles than it would save.
604 */
607 {
611 }
612
613 /*
614 * Add a copy of the RTEPermissionInfo, if any, corresponding to this RTE
615 * to the flattened global list.
616 */
618 {
621
622 /* Get the existing one from this query's rteperminfos. */
624
625 /*
626 * Add a new one to finalrteperminfos and copy the contents of the
627 * existing one into it. Note that addRTEPermissionInfo() also
628 * updates newrte->perminfoindex to point to newperminfo in
629 * finalrteperminfos.
630 */
634 }
635}
636
637/*
638 * set_plan_refs: recurse through the Plan nodes of a single subquery level
639 */
642{
643 ListCell *l;
644
647
648 /* Assign this node a unique ID. */
650
651 /*
652 * Plan-type-specific fixes
653 */
655 {
657 {
659
661 splan->scan.plan.targetlist =
664 splan->scan.plan.qual =
667 }
668 break;
670 {
672
674 splan->scan.plan.targetlist =
677 splan->scan.plan.qual =
682 rtoffset, 1);
683 }
684 break;
686 {
688
690 splan->scan.plan.targetlist =
693 splan->scan.plan.qual =
696 splan->indexqual =
698 rtoffset, 1);
699 splan->indexqualorig =
702 splan->indexorderby =
704 rtoffset, 1);
705 splan->indexorderbyorig =
708 }
709 break;
711 {
713
715 }
716 break;
718 {
720
722 /* no need to fix targetlist and qual */
725 splan->indexqual =
727 splan->indexqualorig =
730 }
731 break;
733 {
735
737 splan->scan.plan.targetlist =
740 splan->scan.plan.qual =
743 splan->bitmapqualorig =
746 }
747 break;
749 {
751
753 splan->scan.plan.targetlist =
756 splan->scan.plan.qual =
759 splan->tidquals =
761 rtoffset, 1);
762 }
763 break;
765 {
767
769 splan->scan.plan.targetlist =
772 splan->scan.plan.qual =
775 splan->tidrangequals =
777 rtoffset, 1);
778 }
779 break;
781 /* Needs special treatment, see comments below */
784 rtoffset);
786 {
788
790 splan->scan.plan.targetlist =
793 splan->scan.plan.qual =
796 splan->functions =
798 }
799 break;
801 {
803
805 splan->scan.plan.targetlist =
808 splan->scan.plan.qual =
813 rtoffset, 1);
814 }
815 break;
817 {
819
821 splan->scan.plan.targetlist =
824 splan->scan.plan.qual =
827 splan->values_lists =
829 rtoffset, 1);
830 }
831 break;
833 {
835
837 splan->scan.plan.targetlist =
840 splan->scan.plan.qual =
843 }
844 break;
846 {
848
850 splan->scan.plan.targetlist =
853 splan->scan.plan.qual =
856 }
857 break;
859 {
861
863 splan->scan.plan.targetlist =
866 splan->scan.plan.qual =
869 }
870 break;
873 break;
876 break;
877
882 break;
883
886 {
889 }
890 break;
891
894 break;
895
897 {
899
900 /*
901 * Memoize does not evaluate its targetlist. It just uses the
902 * same targetlist from its outer subnode.
903 */
905
907 rtoffset,
909 break;
910 }
911
917
918 /*
919 * These plan types don't actually bother to evaluate their
920 * targetlists, because they just return their unmodified input
921 * tuples. Even though the targetlist won't be used by the
922 * executor, we fix it up for possible use by EXPLAIN (not to
923 * mention ease of debugging --- wrong varnos are very confusing).
924 */
926
927 /*
928 * Since these plan types don't check quals either, we should not
929 * find any qual expression attached to them.
930 */
932 break;
934 {
936
937 /*
938 * Like the plan types above, LockRows doesn't evaluate its
939 * tlist or quals. But we have to fix up the RT indexes in
940 * its rowmarks.
941 */
944
946 {
948
949 rc->rti += rtoffset;
950 rc->prti += rtoffset;
951 }
952 }
953 break;
955 {
957
958 /*
959 * Like the plan types above, Limit doesn't evaluate its tlist
960 * or quals. It does have live expressions for limit/offset,
961 * however; and those cannot contain subplan variable refs, so
962 * fix_scan_expr works for them.
963 */
966
967 splan->limitOffset =
969 splan->limitCount =
971 }
972 break;
974 {
976
977 /*
978 * If this node is combining partial-aggregation results, we
979 * must convert its Aggrefs to contain references to the
980 * partial-aggregate subexpressions that will be available
981 * from the child plan node.
982 */
984 {
987 NULL);
990 NULL);
991 }
992
994 }
995 break;
998 break;
1000 {
1002
1003 /*
1004 * Adjust the WindowAgg's run conditions by swapping the
1005 * WindowFuncs references out to instead reference the Var in
1006 * the scan slot so that when the executor evaluates the
1007 * runCondition, it receives the WindowFunc's value from the
1008 * slot that the result has just been stored into rather than
1009 * evaluating the WindowFunc all over again.
1010 */
1012 wplan->runCondition,
1014
1016
1017 /*
1018 * Like Limit node limit/offset expressions, WindowAgg has
1019 * frame offset expressions, which cannot contain subplan
1020 * variable refs, so fix_scan_expr works for them.
1021 */
1022 wplan->startOffset =
1024 wplan->endOffset =
1027 wplan->runCondition,
1028 rtoffset,
1031 wplan->runConditionOrig,
1032 rtoffset,
1034 }
1035 break;
1037 {
1039
1040 /*
1041 * Result may or may not have a subplan; if not, it's more
1042 * like a scan node than an upper node.
1043 */
1046 else
1047 {
1048 /*
1049 * The tlist of a childless Result could contain
1050 * unresolved ROWID_VAR Vars, in case it's representing a
1051 * target relation which is completely empty because of
1052 * constraint exclusion. Replace any such Vars by null
1053 * constants, as though they'd been resolved for a leaf
1054 * scan node that doesn't support them. We could have
1055 * fix_scan_expr do this, but since the case is only
1056 * expected to occur here, it seems safer to special-case
1057 * it here and keep the assertions that ROWID_VARs
1058 * shouldn't be seen by fix_scan_expr.
1059 *
1060 * We also must handle the case where set operations have
1061 * been short-circuited resulting in a dummy Result node.
1062 * prepunion.c uses varno==0 for the set op targetlist.
1063 * See generate_setop_tlist() and generate_setop_tlist().
1064 * Here we rewrite these to use varno==1, which is the
1065 * varno of the first set-op child. Without this, EXPLAIN
1066 * will have trouble displaying targetlists of dummy set
1067 * operations.
1068 */
1070 {
1073
1075 {
1078 var->vartypmod,
1079 var->varcollid);
1080 else if (var->varno == 0)
1082 var->varattno,
1083 var->vartype,
1084 var->vartypmod,
1085 var->varcollid,
1086 var->varlevelsup);
1087 }
1088 }
1089
1096 }
1097 /* resconstantqual can't contain any subplan variable refs */
1098 splan->resconstantqual =
1100 /* adjust the relids set */
1102 }
1103 break;
1106 break;
1108 {
1111
1114
1115 splan->withCheckOptionLists =
1117 rtoffset, 1);
1118
1120 {
1123 *lcrr;
1124
1125 /*
1126 * Pass each per-resultrel returningList through
1127 * set_returning_clause_references().
1128 */
1132 {
1135
1137 rlist,
1138 subplan,
1139 resultrel,
1140 rtoffset);
1142 }
1144
1145 /*
1146 * Set up the visible plan targetlist as being the same as
1147 * the first RETURNING list. This is mostly for the use
1148 * of EXPLAIN; the executor won't execute that targetlist,
1149 * although it does use it to prepare the node's result
1150 * tuple slot. We postpone this step until here so that
1151 * we don't have to do set_returning_clause_references()
1152 * twice on identical targetlists.
1153 */
1155 }
1156
1157 /*
1158 * We treat ModifyTable with ON CONFLICT as a form of 'pseudo
1159 * join', where the inner side is the EXCLUDED tuple.
1160 * Therefore use fix_join_expr to setup the relevant variables
1161 * to INNER_VAR. We explicitly don't create any OUTER_VARs as
1162 * those are already used by RETURNING and it seems better to
1163 * be non-conflicting.
1164 */
1167 {
1169
1171
1172 splan->onConflictSet =
1177
1183
1185
1186 splan->exclRelTlist =
1188 }
1189
1190 /*
1191 * The MERGE statement produces the target rows by performing
1192 * a right join between the target relation and the source
1193 * relation (which could be a plain relation or a subquery).
1194 * The INSERT and UPDATE actions of the MERGE statement
1195 * require access to the columns from the source relation. We
1196 * arrange things so that the source relation attributes are
1197 * available as INNER_VAR and the target relation attributes
1198 * are available from the scan tuple.
1199 */
1201 {
1204 *lcj,
1205 *lcr;
1206
1207 /*
1208 * Fix the targetList of individual action nodes so that
1209 * the so-called "source relation" Vars are referenced as
1210 * INNER_VAR. Note that for this to work correctly during
1211 * execution, the ecxt_innertuple must be set to the tuple
1212 * obtained by executing the subplan, which is what
1213 * constitutes the "source relation".
1214 *
1215 * We leave the Vars from the result relation (i.e. the
1216 * target relation) unchanged i.e. those Vars would be
1217 * picked from the scan slot. So during execution, we must
1218 * ensure that ecxt_scantuple is setup correctly to refer
1219 * to the tuple from the target relation.
1220 */
1222
1224
1228 {
1232
1233 foreach(l, mergeActionList)
1234 {
1236
1237 /* Fix targetList of each action. */
1239 action->targetList,
1241 resultrel,
1242 rtoffset,
1243 NRM_EQUAL,
1245
1246 /* Fix quals too. */
1250 resultrel,
1251 rtoffset,
1252 NRM_EQUAL,
1254 }
1255
1256 /* Fix join condition too. */
1257 mergeJoinCondition = (Node *)
1259 (List *) mergeJoinCondition,
1261 resultrel,
1262 rtoffset,
1263 NRM_EQUAL,
1266 }
1268 }
1269
1270 splan->nominalRelation += rtoffset;
1272 splan->rootRelation += rtoffset;
1273 splan->exclRelRTI += rtoffset;
1274
1276 {
1277 lfirst_int(l) += rtoffset;
1278 }
1280 {
1282
1283 rc->rti += rtoffset;
1284 rc->prti += rtoffset;
1285 }
1286
1287 /*
1288 * Append this ModifyTable node's final result relation RT
1289 * index(es) to the global list for the plan.
1290 */
1291 root->glob->resultRelations =
1293 splan->resultRelations);
1295 {
1296 root->glob->resultRelations =
1298 splan->rootRelation);
1299 }
1300 }
1301 break;
1303 /* Needs special treatment, see comments below */
1306 rtoffset);
1308 /* Needs special treatment, see comments below */
1311 rtoffset);
1313 /* This doesn't evaluate targetlist or check quals either */
1316 break;
1318 {
1320
1321 /* BitmapAnd works like Append, but has no tlist */
1325 {
1328 rtoffset);
1329 }
1330 }
1331 break;
1333 {
1335
1336 /* BitmapOr works like Append, but has no tlist */
1340 {
1343 rtoffset);
1344 }
1345 }
1346 break;
1347 default:
1350 break;
1351 }
1352
1353 /*
1354 * Now recurse into child plans, if any
1355 *
1356 * NOTE: it is essential that we recurse into child plans AFTER we set
1357 * subplan references in this plan's tlist and quals. If we did the
1358 * reference-adjustments bottom-up, then we would fail to match this
1359 * plan's var nodes against the already-modified nodes of the children.
1360 */
1363
1365}
1366
1367/*
1368 * set_indexonlyscan_references
1369 * Do set_plan_references processing on an IndexOnlyScan
1370 *
1371 * This is unlike the handling of a plain IndexScan because we have to
1372 * convert Vars referencing the heap into Vars referencing the index.
1373 * We can use the fix_upper_expr machinery for that, by working from a
1374 * targetlist describing the index columns.
1375 */
1379 int rtoffset)
1380{
1384
1385 /*
1386 * Vars in the plan node's targetlist, qual, and recheckqual must only
1387 * reference columns that the index AM can actually return. To ensure
1388 * this, remove non-returnable columns (which are marked as resjunk) from
1389 * the indexed tlist. We can just drop them because the indexed_tlist
1390 * machinery pays attention to TLE resnos, not physical list position.
1391 */
1394 {
1396
1399 }
1400
1402
1403 plan->scan.scanrelid += rtoffset;
1407 index_itlist,
1408 INDEX_VAR,
1409 rtoffset,
1410 NRM_EQUAL,
1415 index_itlist,
1416 INDEX_VAR,
1417 rtoffset,
1418 NRM_EQUAL,
1423 index_itlist,
1424 INDEX_VAR,
1425 rtoffset,
1426 NRM_EQUAL,
1428 /* indexqual is already transformed to reference index columns */
1430 rtoffset, 1);
1431 /* indexorderby is already transformed to reference index columns */
1433 rtoffset, 1);
1434 /* indextlist must NOT be transformed to reference index columns */
1437
1439
1441}
1442
1443/*
1444 * set_subqueryscan_references
1445 * Do set_plan_references processing on a SubqueryScan
1446 *
1447 * We try to strip out the SubqueryScan entirely; if we can't, we have
1448 * to do the normal processing on it.
1449 */
1453 int rtoffset)
1454{
1455 RelOptInfo *rel;
1456 Plan *result;
1457
1458 /* Need to look up the subquery's RelOptInfo, since we need its subroot */
1460
1461 /* Recursively process the subplan */
1463
1465 {
1466 Index scanrelid;
1467
1468 /*
1469 * We can omit the SubqueryScan node and just pull up the subplan.
1470 */
1472
1473 /* Remember that we removed a SubqueryScan */
1474 scanrelid = plan->scan.scanrelid + rtoffset;
1477 }
1478 else
1479 {
1480 /*
1481 * Keep the SubqueryScan node. We have to do the processing that
1482 * set_plan_references would otherwise have done on it. Notice we do
1483 * not do set_upper_references() here, because a SubqueryScan will
1484 * always have been created with correct references to its subplan's
1485 * outputs to begin with.
1486 */
1487 plan->scan.scanrelid += rtoffset;
1488 plan->scan.plan.targetlist =
1491 plan->scan.plan.qual =
1494
1496 }
1497
1498 return result;
1499}
1500
1501/*
1502 * trivial_subqueryscan
1503 * Detect whether a SubqueryScan can be deleted from the plan tree.
1504 *
1505 * We can delete it if it has no qual to check and the targetlist just
1506 * regurgitates the output of the child plan.
1507 *
1508 * This can be called from mark_async_capable_plan(), a helper function for
1509 * create_append_plan(), before set_subqueryscan_references(), to determine
1510 * triviality of a SubqueryScan that is a child of an Append node. So we
1511 * cache the result in the SubqueryScan node to avoid repeated computation.
1512 *
1513 * Note: when called from mark_async_capable_plan(), we determine the result
1514 * before running finalize_plan() on the SubqueryScan node (if needed) and
1515 * set_plan_references() on the subplan tree, but this would be safe, because
1516 * 1) finalize_plan() doesn't modify the tlist or quals for the SubqueryScan
1517 * node (or that for any plan node in the subplan tree), and
1518 * 2) set_plan_references() modifies the tlist for every plan node in the
1519 * subplan tree, but keeps const/resjunk columns as const/resjunk ones and
1520 * preserves the length and order of the tlist, and
1521 * 3) set_plan_references() might delete the topmost plan node like an Append
1522 * or MergeAppend from the subplan tree and pull up the child plan node,
1523 * but in that case, the tlist for the child plan node exactly matches the
1524 * parent.
1525 */
1526bool
1528{
1531 *lc;
1532
1533 /* We might have detected this already; in which case reuse the result */
1535 return true;
1537 return false;
1539 /* Initially, mark the SubqueryScan as non-deletable from the plan tree */
1541
1543 return false;
1544
1547 return false; /* tlists not same length */
1548
1549 attrno = 1;
1551 {
1554
1556 return false; /* tlist doesn't match junk status */
1557
1558 /*
1559 * We accept either a Var referencing the corresponding element of the
1560 * subplan tlist, or a Const equaling the subplan element. See
1561 * generate_setop_tlist() for motivation.
1562 */
1564 {
1566
1568 Assert(var->varlevelsup == 0);
1570 return false; /* out of order */
1571 }
1573 {
1575 return false;
1576 }
1577 else
1578 return false;
1579
1580 attrno++;
1581 }
1582
1583 /* Re-mark the SubqueryScan as deletable from the plan tree */
1585
1586 return true;
1587}
1588
1589/*
1590 * clean_up_removed_plan_level
1591 * Do necessary cleanup when we strip out a SubqueryScan, Append, etc
1592 *
1593 * We are dropping the "parent" plan in favor of returning just its "child".
1594 * A few small tweaks are needed.
1595 */
1598{
1599 /*
1600 * We have to be sure we don't lose any initplans, so move any that were
1601 * attached to the parent plan to the child. If any are parallel-unsafe,
1602 * the child is no longer parallel-safe. As a cosmetic matter, also add
1603 * the initplans' run costs to the child's costs.
1604 */
1606 {
1609
1616
1617 /*
1618 * Attach plans this way so that parent's initplans are processed
1619 * before any pre-existing initplans of the child. Probably doesn't
1620 * matter, but let's preserve the ordering just in case.
1621 */
1623 child->initPlan);
1624 }
1625
1626 /*
1627 * We also have to transfer the parent's column labeling info into the
1628 * child, else columns sent to client will be improperly labeled if this
1629 * is the topmost plan level. resjunk and so on may be important too.
1630 */
1632
1633 return child;
1634}
1635
1636/*
1637 * set_foreignscan_references
1638 * Do set_plan_references processing on a ForeignScan
1639 */
1640static void
1643 int rtoffset)
1644{
1645 /* Adjust scanrelid if it's valid */
1647 fscan->scan.scanrelid += rtoffset;
1648
1650 {
1651 /*
1652 * Adjust tlist, qual, fdw_exprs, fdw_recheck_quals to reference
1653 * foreign scan tuple
1654 */
1656
1660 itlist,
1661 INDEX_VAR,
1662 rtoffset,
1663 NRM_EQUAL,
1668 itlist,
1669 INDEX_VAR,
1670 rtoffset,
1671 NRM_EQUAL,
1676 itlist,
1677 INDEX_VAR,
1678 rtoffset,
1679 NRM_EQUAL,
1684 itlist,
1685 INDEX_VAR,
1686 rtoffset,
1687 NRM_EQUAL,
1690 /* fdw_scan_tlist itself just needs fix_scan_list() adjustments */
1691 fscan->fdw_scan_tlist =
1694 }
1695 else
1696 {
1697 /*
1698 * Adjust tlist, qual, fdw_exprs, fdw_recheck_quals in the standard
1699 * way
1700 */
1701 fscan->scan.plan.targetlist =
1704 fscan->scan.plan.qual =
1707 fscan->fdw_exprs =
1710 fscan->fdw_recheck_quals =
1713 }
1714
1717
1718 /* Adjust resultRelation if it's valid */
1720 fscan->resultRelation += rtoffset;
1721}
1722
1723/*
1724 * set_customscan_references
1725 * Do set_plan_references processing on a CustomScan
1726 */
1727static void
1730 int rtoffset)
1731{
1733
1734 /* Adjust scanrelid if it's valid */
1736 cscan->scan.scanrelid += rtoffset;
1737
1739 {
1740 /* Adjust tlist, qual, custom_exprs to reference custom scan tuple */
1742
1746 itlist,
1747 INDEX_VAR,
1748 rtoffset,
1749 NRM_EQUAL,
1754 itlist,
1755 INDEX_VAR,
1756 rtoffset,
1757 NRM_EQUAL,
1762 itlist,
1763 INDEX_VAR,
1764 rtoffset,
1765 NRM_EQUAL,
1768 /* custom_scan_tlist itself just needs fix_scan_list() adjustments */
1769 cscan->custom_scan_tlist =
1772 }
1773 else
1774 {
1775 /* Adjust tlist, qual, custom_exprs in the standard way */
1776 cscan->scan.plan.targetlist =
1779 cscan->scan.plan.qual =
1782 cscan->custom_exprs =
1785 }
1786
1787 /* Adjust child plan-nodes recursively, if needed */
1789 {
1791 }
1792
1794}
1795
1796/*
1797 * register_partpruneinfo
1798 * Subroutine for set_append_references and set_mergeappend_references
1799 *
1800 * Add the PartitionPruneInfo from root->partPruneInfos at the given index
1801 * into PlannerGlobal->partPruneInfos and return its index there.
1802 *
1803 * Also update the RT indexes present in PartitionedRelPruneInfos to add the
1804 * offset.
1805 *
1806 * Finally, if there are initial pruning steps, add the RT indexes of the
1807 * leaf partitions to the set of relations that are prunable at execution
1808 * startup time.
1809 */
1810static int
1812{
1814 PartitionPruneInfo *pinfo;
1815 ListCell *l;
1816
1817 Assert(part_prune_index >= 0 &&
1820 part_prune_index);
1821
1824 {
1826 ListCell *l2;
1827
1828 foreach(l2, prune_infos)
1829 {
1832
1833 prelinfo->rtindex += rtoffset;
1834 prelinfo->initial_pruning_steps =
1836 rtoffset, 1);
1837 prelinfo->exec_pruning_steps =
1839 rtoffset, 1);
1840
1842 {
1843 /*
1844 * Non-leaf partitions and partitions that do not have a
1845 * subplan are not included in this map as mentioned in
1846 * make_partitionedrel_pruneinfo().
1847 */
1849 {
1854 }
1855 }
1856 }
1857 }
1858
1860
1862}
1863
1864/*
1865 * set_append_references
1866 * Do set_plan_references processing on an Append
1867 *
1868 * We try to strip out the Append entirely; if we can't, we have
1869 * to do the normal processing on it.
1870 */
1874 int rtoffset)
1875{
1876 ListCell *l;
1877
1878 /*
1879 * Append, like Sort et al, doesn't actually evaluate its targetlist or
1880 * check quals. If it's got exactly one child plan, then it's not doing
1881 * anything useful at all, and we can strip it out.
1882 */
1884
1885 /* First, we gotta recurse on the children */
1887 {
1889 }
1890
1891 /*
1892 * See if it's safe to get rid of the Append entirely. For this to be
1893 * safe, there must be only one child plan and that child plan's parallel
1894 * awareness must match the Append's. The reason for the latter is that
1895 * if the Append is parallel aware and the child is not, then the calling
1896 * plan may execute the non-parallel aware child multiple times. (If you
1897 * change these rules, update create_append_path to match.)
1898 */
1900 {
1902
1904 {
1905 Plan *result;
1906
1908
1909 /* Remember that we removed an Append */
1912
1913 return result;
1914 }
1915 }
1916
1917 /*
1918 * Otherwise, clean up the Append as needed. It's okay to do this after
1919 * recursing to the children, because set_dummy_tlist_references doesn't
1920 * look at those.
1921 */
1923
1925
1926 /*
1927 * Add PartitionPruneInfo, if any, to PlannerGlobal and update the index.
1928 * Also update the RT indexes present in it to add the offset.
1929 */
1931 aplan->part_prune_index =
1933
1934 /* We don't need to recurse to lefttree or righttree ... */
1937
1939}
1940
1941/*
1942 * set_mergeappend_references
1943 * Do set_plan_references processing on a MergeAppend
1944 *
1945 * We try to strip out the MergeAppend entirely; if we can't, we have
1946 * to do the normal processing on it.
1947 */
1951 int rtoffset)
1952{
1953 ListCell *l;
1954
1955 /*
1956 * MergeAppend, like Sort et al, doesn't actually evaluate its targetlist
1957 * or check quals. If it's got exactly one child plan, then it's not
1958 * doing anything useful at all, and we can strip it out.
1959 */
1961
1962 /* First, we gotta recurse on the children */
1964 {
1966 }
1967
1968 /*
1969 * See if it's safe to get rid of the MergeAppend entirely. For this to
1970 * be safe, there must be only one child plan and that child plan's
1971 * parallel awareness must match the MergeAppend's. The reason for the
1972 * latter is that if the MergeAppend is parallel aware and the child is
1973 * not, then the calling plan may execute the non-parallel aware child
1974 * multiple times. (If you change these rules, update
1975 * create_merge_append_path to match.)
1976 */
1978 {
1980
1982 {
1983 Plan *result;
1984
1986
1987 /* Remember that we removed a MergeAppend */
1990
1991 return result;
1992 }
1993 }
1994
1995 /*
1996 * Otherwise, clean up the MergeAppend as needed. It's okay to do this
1997 * after recursing to the children, because set_dummy_tlist_references
1998 * doesn't look at those.
1999 */
2001
2003
2004 /*
2005 * Add PartitionPruneInfo, if any, to PlannerGlobal and update the index.
2006 * Also update the RT indexes present in it to add the offset.
2007 */
2009 mplan->part_prune_index =
2011
2012 /* We don't need to recurse to lefttree or righttree ... */
2015
2017}
2018
2019/*
2020 * set_hash_references
2021 * Do set_plan_references processing on a Hash node
2022 */
2023static void
2025{
2028 indexed_tlist *outer_itlist;
2029
2030 /*
2031 * Hash's hashkeys are used when feeding tuples into the hashtable,
2032 * therefore have them reference Hash's outer plan (which itself is the
2033 * inner plan of the HashJoin).
2034 */
2039 outer_itlist,
2040 OUTER_VAR,
2041 rtoffset,
2042 NRM_EQUAL,
2044
2045 /* Hash doesn't project */
2047
2048 /* Hash nodes don't have their own quals */
2050}
2051
2052/*
2053 * offset_relid_set
2054 * Apply rtoffset to the members of a Relids set.
2055 */
2058{
2060 int rtindex;
2061
2062 /* If there's no offset to apply, we needn't recompute the value */
2063 if (rtoffset == 0)
2064 return relids;
2065 rtindex = -1;
2067 result = bms_add_member(result, rtindex + rtoffset);
2068 return result;
2069}
2070
2071/*
2072 * copyVar
2073 * Copy a Var node.
2074 *
2075 * fix_scan_expr and friends do this enough times that it's worth having
2076 * a bespoke routine instead of using the generic copyObject() function.
2077 */
2080{
2082
2083 *newvar = *var;
2085}
2086
2087/*
2088 * fix_expr_common
2089 * Do generic set_plan_references processing on an expression node
2090 *
2091 * This is code that is common to all variants of expression-fixing.
2092 * We must look up operator opcode info for OpExpr and related nodes,
2093 * add OIDs from regclass Const nodes into root->glob->relationOids, and
2094 * add PlanInvalItems for user-defined functions into root->glob->invalItems.
2095 * We also fill in column index lists for GROUPING() expressions.
2096 *
2097 * We assume it's okay to update opcode info in-place. So this could possibly
2098 * scribble on the planner's input data structures, but it's OK.
2099 */
2100static void
2102{
2103 /* We assume callers won't call us on a NULL pointer */
2105 {
2107 ((Aggref *) node)->aggfnoid);
2108 }
2110 {
2112 ((WindowFunc *) node)->winfnoid);
2113 }
2115 {
2117 ((FuncExpr *) node)->funcid);
2118 }
2120 {
2124 }
2126 {
2130 }
2132 {
2136 }
2138 {
2140
2141 set_sa_opfuncid(saop);
2143
2146
2149 }
2151 {
2153
2154 /* Check for regclass reference */
2156 root->glob->relationOids =
2158 DatumGetObjectId(con->constvalue));
2159 }
2161 {
2164
2165 /* If there are no grouping sets, we don't need this. */
2166
2168
2170 {
2173
2175 {
2177 }
2178
2180
2181 if (!g->cols)
2182 g->cols = cols;
2183 }
2184 }
2185}
2186
2187/*
2188 * fix_param_node
2189 * Do set_plan_references processing on a Param
2190 *
2191 * If it's a PARAM_MULTIEXPR, replace it with the appropriate Param from
2192 * root->multiexpr_params; otherwise no change is needed.
2193 * Just for paranoia's sake, we make a copy of the node in either case.
2194 */
2197{
2199 {
2202 List *params;
2203
2211 }
2213}
2214
2215/*
2216 * fix_alternative_subplan
2217 * Do set_plan_references processing on an AlternativeSubPlan
2218 *
2219 * Choose one of the alternative implementations and return just that one,
2220 * discarding the rest of the AlternativeSubPlan structure.
2221 * Note: caller must still recurse into the result!
2222 *
2223 * We don't make any attempt to fix up cost estimates in the parent plan
2224 * node or higher-level nodes.
2225 */
2228 double num_exec)
2229{
2233
2234 /*
2235 * Compute the estimated cost of each subplan assuming num_exec
2236 * executions, and keep the cheapest one. In event of exact equality of
2237 * estimates, we prefer the later plan; this is a bit arbitrary, but in
2238 * current usage it biases us to break ties against fast-start subplans.
2239 */
2241
2243 {
2246
2249 {
2252 }
2253
2254 /* Also mark all subplans that are in AlternativeSubPlans */
2256 }
2257
2258 /* Mark the subplan we selected */
2260
2262}
2263
2264/*
2265 * fix_scan_expr
2266 * Do set_plan_references processing on a scan-level expression
2267 *
2268 * This consists of incrementing all Vars' varnos by rtoffset,
2269 * replacing PARAM_MULTIEXPR Params, expanding PlaceHolderVars,
2270 * replacing Aggref nodes that should be replaced by initplan output Params,
2271 * choosing the best implementation for AlternativeSubPlans,
2272 * looking up operator opcode info for OpExpr and related nodes,
2273 * and adding OIDs from regclass Const nodes into root->glob->relationOids.
2274 *
2275 * 'node': the expression to be modified
2276 * 'rtoffset': how much to increment varnos by
2277 * 'num_exec': estimated number of executions of expression
2278 *
2279 * The expression tree is either copied-and-modified, or modified in-place
2280 * if that seems safe.
2281 */
2284{
2285 fix_scan_expr_context context;
2286
2288 context.rtoffset = rtoffset;
2289 context.num_exec = num_exec;
2290
2291 if (rtoffset != 0 ||
2293 root->glob->lastPHId != 0 ||
2295 root->hasAlternativeSubPlans)
2296 {
2298 }
2299 else
2300 {
2301 /*
2302 * If rtoffset == 0, we don't need to change any Vars, and if there
2303 * are no MULTIEXPR subqueries then we don't need to replace
2304 * PARAM_MULTIEXPR Params, and if there are no placeholders anywhere
2305 * we won't need to remove them, and if there are no minmax Aggrefs we
2306 * won't need to replace them, and if there are no AlternativeSubPlans
2307 * we won't need to remove them. Then it's OK to just scribble on the
2308 * input node tree instead of copying (since the only change, filling
2309 * in any unset opfuncid fields, is harmless). This saves just enough
2310 * cycles to be noticeable on trivial queries.
2311 */
2313 return node;
2314 }
2315}
2316
2319{
2323 {
2325
2327
2328 /*
2329 * We should not see Vars marked INNER_VAR, OUTER_VAR, or ROWID_VAR.
2330 * But an indexqual expression could contain INDEX_VAR Vars.
2331 */
2337 if (var->varnosyn > 0)
2338 var->varnosyn += context->rtoffset;
2340 }
2344 {
2347
2348 /* See if the Aggref should be replaced by a Param */
2351 {
2352 /* Make a copy of the Param for paranoia's sake */
2354 }
2355 /* If no match, just fall through to process it normally */
2356 }
2358 {
2360
2364 }
2366 {
2367 /* At scan level, we should always just evaluate the contained expr */
2369
2370 /* XXX can we assert something about phnullingrels? */
2372 }
2375 (AlternativeSubPlan *) node,
2376 context->num_exec),
2377 context);
2380}
2381
2382static bool
2384{
2386 return false;
2392}
2393
2394/*
2395 * set_join_references
2396 * Modify the target list and quals of a join node to reference its
2397 * subplans, by setting the varnos to OUTER_VAR or INNER_VAR and setting
2398 * attno values to the result domain number of either the corresponding
2399 * outer or inner join tuple item. Also perform opcode lookup for these
2400 * expressions, and add regclass OIDs to root->glob->relationOids.
2401 */
2402static void
2404{
2405 Plan *outer_plan = join->plan.lefttree;
2406 Plan *inner_plan = join->plan.righttree;
2407 indexed_tlist *outer_itlist;
2408 indexed_tlist *inner_itlist;
2409
2412
2413 /*
2414 * First process the joinquals (including merge or hash clauses). These
2415 * are logically below the join so they can always use all values
2416 * available from the input tlists. It's okay to also handle
2417 * NestLoopParams now, because those couldn't refer to nullable
2418 * subexpressions.
2419 */
2421 join->joinqual,
2422 outer_itlist,
2423 inner_itlist,
2424 (Index) 0,
2425 rtoffset,
2426 NRM_EQUAL,
2428
2429 /* Now do join-type-specific stuff */
2431 {
2434
2436 {
2438
2439 /*
2440 * Because we don't reparameterize parameterized paths to match
2441 * the outer-join level at which they are used, Vars seen in the
2442 * NestLoopParam expression may have nullingrels that are just a
2443 * subset of those in the Vars actually available from the outer
2444 * side. (Lateral references can also cause this, as explained in
2445 * the comments for identify_current_nestloop_params.) Not
2446 * checking this exactly is a bit grotty, but the work needed to
2447 * make things match up perfectly seems well out of proportion to
2448 * the value.
2449 */
2452 outer_itlist,
2453 OUTER_VAR,
2454 rtoffset,
2455 NRM_SUBSET,
2456 NUM_EXEC_TLIST(outer_plan));
2457 /* Check we replaced any PlaceHolderVar with simple Var */
2461 }
2462 }
2464 {
2466
2468 mj->mergeclauses,
2469 outer_itlist,
2470 inner_itlist,
2471 (Index) 0,
2472 rtoffset,
2473 NRM_EQUAL,
2475 }
2477 {
2479
2481 hj->hashclauses,
2482 outer_itlist,
2483 inner_itlist,
2484 (Index) 0,
2485 rtoffset,
2486 NRM_EQUAL,
2488
2489 /*
2490 * HashJoin's hashkeys are used to look for matching tuples from its
2491 * outer plan (not the Hash node!) in the hashtable.
2492 */
2495 outer_itlist,
2496 OUTER_VAR,
2497 rtoffset,
2498 NRM_EQUAL,
2500 }
2501
2502 /*
2503 * Now we need to fix up the targetlist and qpqual, which are logically
2504 * above the join. This means that, if it's not an inner join, any Vars
2505 * and PHVs appearing here should have nullingrels that include the
2506 * effects of the outer join, ie they will have nullingrels equal to the
2507 * input Vars' nullingrels plus the bit added by the outer join. We don't
2508 * currently have enough info available here to identify what that should
2509 * be, so we just tell fix_join_expr to accept superset nullingrels
2510 * matches instead of exact ones.
2511 */
2513 join->plan.targetlist,
2514 outer_itlist,
2515 inner_itlist,
2516 (Index) 0,
2517 rtoffset,
2521 join->plan.qual,
2522 outer_itlist,
2523 inner_itlist,
2524 (Index) 0,
2525 rtoffset,
2528
2529 pfree(outer_itlist);
2530 pfree(inner_itlist);
2531}
2532
2533/*
2534 * set_upper_references
2535 * Update the targetlist and quals of an upper-level plan node
2536 * to refer to the tuples returned by its lefttree subplan.
2537 * Also perform opcode lookup for these expressions, and
2538 * add regclass OIDs to root->glob->relationOids.
2539 *
2540 * This is used for single-input plan types like Agg, Group, Result.
2541 *
2542 * In most cases, we have to match up individual Vars in the tlist and
2543 * qual expressions with elements of the subplan's tlist (which was
2544 * generated by flattening these selfsame expressions, so it should have all
2545 * the required variables). There is an important exception, however:
2546 * depending on where we are in the plan tree, sort/group columns may have
2547 * been pushed into the subplan tlist unflattened. If these values are also
2548 * needed in the output then we want to reference the subplan tlist element
2549 * rather than recomputing the expression.
2550 */
2551static void
2553{
2555 indexed_tlist *subplan_itlist;
2557 ListCell *l;
2558
2560
2561 /*
2562 * If it's a grouping node with grouping sets, any Vars and PHVs appearing
2563 * in the targetlist and quals should have nullingrels that include the
2564 * effects of the grouping step, ie they will have nullingrels equal to
2565 * the input Vars/PHVs' nullingrels plus the RT index of the grouping
2566 * step. In order to perform exact nullingrels matches, we remove the RT
2567 * index of the grouping step first.
2568 */
2570 root->group_rtindex > 0 &&
2572 {
2576 NULL);
2580 NULL);
2581 }
2582
2585 {
2588
2589 /* If it's a sort/group item, first try to match by sortref */
2591 {
2594 tle->ressortgroupref,
2595 subplan_itlist,
2596 OUTER_VAR);
2600 subplan_itlist,
2601 OUTER_VAR,
2602 rtoffset,
2603 NRM_EQUAL,
2605 }
2606 else
2609 subplan_itlist,
2610 OUTER_VAR,
2611 rtoffset,
2612 NRM_EQUAL,
2617 }
2619
2623 subplan_itlist,
2624 OUTER_VAR,
2625 rtoffset,
2626 NRM_EQUAL,
2628
2629 pfree(subplan_itlist);
2630}
2631
2632/*
2633 * set_param_references
2634 * Initialize the initParam list in Gather or Gather merge node such that
2635 * it contains reference of all the params that needs to be evaluated
2636 * before execution of the node. It contains the initplan params that are
2637 * being passed to the plan nodes below it.
2638 */
2639static void
2641{
2643
2645 {
2648 ListCell *l;
2649
2651 {
2653 {
2655 ListCell *l2;
2656
2658 {
2660 }
2661 }
2662 }
2663
2664 /*
2665 * Remember the list of all external initplan params that are used by
2666 * the children of Gather or Gather merge node.
2667 */
2671 else
2674 }
2675}
2676
2677/*
2678 * Recursively scan an expression tree and convert Aggrefs to the proper
2679 * intermediate form for combining aggregates. This means (1) replacing each
2680 * one's argument list with a single argument that is the original Aggref
2681 * modified to show partial aggregation and (2) changing the upper Aggref to
2682 * show combining aggregation.
2683 *
2684 * After this step, set_upper_references will replace the partial Aggrefs
2685 * with Vars referencing the lower Agg plan node's outputs, so that the final
2686 * form seen by the executor is a combining Aggref with a Var as input.
2687 *
2688 * It's rather messy to postpone this step until setrefs.c; ideally it'd be
2689 * done in createplan.c. The difficulty is that once we modify the Aggref
2690 * expressions, they will no longer be equal() to their original form and
2691 * so cross-plan-node-level matches will fail. So this has to happen after
2692 * the plan node above the Agg has resolved its subplan references.
2693 */
2696{
2700 {
2704
2705 /* Assert we've not chosen to partial-ize any unsupported cases */
2708
2709 /*
2710 * Since aggregate calls can't be nested, we needn't recurse into the
2711 * arguments. But for safety, flat-copy the Aggref node itself rather
2712 * than modifying it in-place.
2713 */
2716
2717 /*
2718 * For the parent Aggref, we want to copy all the fields of the
2719 * original aggregate *except* the args list, which we'll replace
2720 * below, and the aggfilter expression, which should be applied only
2721 * by the child not the parent. Rather than explicitly knowing about
2722 * all the other fields here, we can momentarily modify child_agg to
2723 * provide a suitable source for copyObject.
2724 */
2730
2731 /*
2732 * Now, set up child_agg to represent the first phase of partial
2733 * aggregation. For now, assume serialization is required.
2734 */
2736
2737 /*
2738 * And set up parent_agg to represent the second phase.
2739 */
2743
2745 }
2747}
2748
2749/*
2750 * set_dummy_tlist_references
2751 * Replace the targetlist of an upper-level plan node with a simple
2752 * list of OUTER_VAR references to its child.
2753 *
2754 * This is used for plan types like Sort and Append that don't evaluate
2755 * their targetlists. Although the executor doesn't care at all what's in
2756 * the tlist, EXPLAIN needs it to be realistic.
2757 *
2758 * Note: we could almost use set_upper_references() here, but it fails for
2759 * Append for lack of a lefttree subplan. Single-purpose code is faster
2760 * anyway.
2761 */
2762static void
2764{
2766 ListCell *l;
2767
2770 {
2774
2775 /*
2776 * As in search_indexed_tlist_for_non_var(), we prefer to keep Consts
2777 * as Consts, not Vars referencing Consts. Here, there's no speed
2778 * advantage to be had, but it makes EXPLAIN output look cleaner, and
2779 * again it avoids confusing the executor.
2780 */
2782 {
2783 /* just reuse the existing TLE node */
2785 continue;
2786 }
2787
2789 tle->resno,
2793 0);
2795 oldvar->varnosyn > 0)
2796 {
2799 }
2800 else
2801 {
2803 newvar->varattnosyn = 0;
2804 }
2805
2809 }
2811
2812 /* We don't touch plan->qual here */
2813}
2814
2815
2816/*
2817 * build_tlist_index --- build an index data structure for a child tlist
2818 *
2819 * In most cases, subplan tlists will be "flat" tlists with only Vars,
2820 * so we try to optimize that case by extracting information about Vars
2821 * in advance. Matching a parent tlist to a child is still an O(N^2)
2822 * operation, but at least with a much smaller constant factor than plain
2823 * tlist_member() searches.
2824 *
2825 * The result of this function is an indexed_tlist struct to pass to
2826 * search_indexed_tlist_for_var() and siblings.
2827 * When done, the indexed_tlist may be freed with a single pfree().
2828 */
2831{
2834 ListCell *l;
2835
2836 /* Create data structure with enough slots for all tlist entries */
2840
2841 itlist->tlist = tlist;
2844
2845 /* Find the Vars and fill in the index array */
2847 foreach(l, tlist)
2848 {
2850
2852 {
2854
2858 vinfo->varnullingrels = var->varnullingrels;
2859 vinfo++;
2860 }
2863 else
2865 }
2866
2868
2870}
2871
2872/*
2873 * build_tlist_index_other_vars --- build a restricted tlist index
2874 *
2875 * This is like build_tlist_index, but we only index tlist entries that
2876 * are Vars belonging to some rel other than the one specified. We will set
2877 * has_ph_vars (allowing PlaceHolderVars to be matched), but not has_non_vars
2878 * (so nothing other than Vars and PlaceHolderVars can be matched).
2879 */
2882{
2885 ListCell *l;
2886
2887 /* Create data structure with enough slots for all tlist entries */
2891
2892 itlist->tlist = tlist;
2895
2896 /* Find the desired Vars and fill in the index array */
2898 foreach(l, tlist)
2899 {
2901
2903 {
2905
2907 {
2911 vinfo->varnullingrels = var->varnullingrels;
2912 vinfo++;
2913 }
2914 }
2917 }
2918
2920
2922}
2923
2924/*
2925 * search_indexed_tlist_for_var --- find a Var in an indexed tlist
2926 *
2927 * If a match is found, return a copy of the given Var with suitably
2928 * modified varno/varattno (to wit, newvarno and the resno of the TLE entry).
2929 * Also ensure that varnosyn is incremented by rtoffset.
2930 * If no match, return NULL.
2931 *
2932 * We cross-check the varnullingrels of the subplan output Var based on
2933 * nrm_match. Most call sites should pass NRM_EQUAL indicating we expect
2934 * an exact match. However, there are places where we haven't cleaned
2935 * things up completely, and we have to settle for allowing subset or
2936 * superset matches.
2937 */
2940 int newvarno, int rtoffset,
2941 NullingRelsMatch nrm_match)
2942{
2947
2951 {
2953 {
2954 /* Found a match */
2956
2957 /*
2958 * Verify that we kept all the nullingrels machinations straight.
2959 *
2960 * XXX we skip the check for system columns and whole-row Vars.
2961 * That's because such Vars might be row identity Vars, which are
2962 * generated without any varnullingrels. It'd be hard to do
2963 * otherwise, since they're normally made very early in planning,
2964 * when we haven't looked at the jointree yet and don't know which
2965 * joins might null such Vars. Doesn't seem worth the expense to
2966 * make them fully valid. (While it's slightly annoying that we
2967 * thereby lose checking for user-written references to such
2968 * columns, it seems unlikely that a bug in nullingrels logic
2969 * would affect only system columns.)
2970 */
2971 if (!(varattno <= 0 ||
2972 (nrm_match == NRM_SUBSET ?
2974 nrm_match == NRM_SUPERSET ?
2978 bmsToString(var->varnullingrels),
2980 varno, varattno);
2981
2982 newvar->varno = newvarno;
2985 newvar->varnosyn += rtoffset;
2987 }
2988 vinfo++;
2989 }
2991}
2992
2993/*
2994 * search_indexed_tlist_for_phv --- find a PlaceHolderVar in an indexed tlist
2995 *
2996 * If a match is found, return a Var constructed to reference the tlist item.
2997 * If no match, return NULL.
2998 *
2999 * Cross-check phnullingrels as in search_indexed_tlist_for_var.
3000 *
3001 * NOTE: it is a waste of time to call this unless itlist->has_ph_vars.
3002 */
3006 NullingRelsMatch nrm_match)
3007{
3009
3011 {
3013
3015 {
3018
3019 /*
3020 * Analogously to search_indexed_tlist_for_var, we match on phid
3021 * only. We don't use equal(), partially for speed but mostly
3022 * because phnullingrels might not be exactly equal.
3023 */
3025 continue;
3026
3027 /* Verify that we kept all the nullingrels machinations straight */
3030 nrm_match == NRM_SUPERSET ?
3036 phv->phid);
3037
3038 /* Found a matching subplan output expression */
3041 newvar->varattnosyn = 0;
3043 }
3044 }
3046}
3047
3048/*
3049 * search_indexed_tlist_for_non_var --- find a non-Var/PHV in an indexed tlist
3050 *
3051 * If a match is found, return a Var constructed to reference the tlist item.
3052 * If no match, return NULL.
3053 *
3054 * NOTE: it is a waste of time to call this unless itlist->has_non_vars.
3055 */
3059{
3061
3062 /*
3063 * If it's a simple Const, replacing it with a Var is silly, even if there
3064 * happens to be an identical Const below; a Var is more expensive to
3065 * execute than a Const. What's more, replacing it could confuse some
3066 * places in the executor that expect to see simple Consts for, eg,
3067 * dropped columns.
3068 */
3071
3074 {
3075 /* Found a matching subplan output expression */
3077
3080 newvar->varattnosyn = 0;
3082 }
3084}
3085
3086/*
3087 * search_indexed_tlist_for_sortgroupref --- find a sort/group expression
3088 *
3089 * If a match is found, return a Var constructed to reference the tlist item.
3090 * If no match, return NULL.
3091 *
3092 * This is needed to ensure that we select the right subplan TLE in cases
3093 * where there are multiple textually-equal()-but-volatile sort expressions.
3094 * And it's also faster than search_indexed_tlist_for_non_var.
3095 */
3098 Index sortgroupref,
3100 int newvarno)
3101{
3103
3105 {
3107
3108 /*
3109 * Usually the equal() check is redundant, but in setop plans it may
3110 * not be, since prepunion.c assigns ressortgroupref equal to the
3111 * column resno without regard to whether that matches the topmost
3112 * level's sortgrouprefs and without regard to whether any implicit
3113 * coercions are added in the setop tree. We might have to clean that
3114 * up someday; but for now, just ignore any false matches.
3115 */
3118 {
3119 /* Found a matching subplan output expression */
3121
3124 newvar->varattnosyn = 0;
3126 }
3127 }
3129}
3130
3131/*
3132 * fix_join_expr
3133 * Create a new set of targetlist entries or join qual clauses by
3134 * changing the varno/varattno values of variables in the clauses
3135 * to reference target list values from the outer and inner join
3136 * relation target lists. Also perform opcode lookup and add
3137 * regclass OIDs to root->glob->relationOids.
3138 *
3139 * This is used in four different scenarios:
3140 * 1) a normal join clause, where all the Vars in the clause *must* be
3141 * replaced by OUTER_VAR or INNER_VAR references. In this case
3142 * acceptable_rel should be zero so that any failure to match a Var will be
3143 * reported as an error.
3144 * 2) RETURNING clauses, which may contain both Vars of the target relation
3145 * and Vars of other relations. In this case we want to replace the
3146 * other-relation Vars by OUTER_VAR references, while leaving target Vars
3147 * alone. Thus inner_itlist = NULL and acceptable_rel = the ID of the
3148 * target relation should be passed.
3149 * 3) ON CONFLICT SET and WHERE clauses. Here references to EXCLUDED are
3150 * to be replaced with INNER_VAR references, while leaving target Vars (the
3151 * to-be-updated relation) alone. Correspondingly inner_itlist is to be
3152 * EXCLUDED elements, outer_itlist = NULL and acceptable_rel the target
3153 * relation.
3154 * 4) MERGE. In this case, references to the source relation are to be
3155 * replaced with INNER_VAR references, leaving Vars of the target
3156 * relation (the to-be-modified relation) alone. So inner_itlist is to be
3157 * the source relation elements, outer_itlist = NULL and acceptable_rel
3158 * the target relation.
3159 *
3160 * 'clauses' is the targetlist or list of join clauses
3161 * 'outer_itlist' is the indexed target list of the outer join relation,
3162 * or NULL
3163 * 'inner_itlist' is the indexed target list of the inner join relation,
3164 * or NULL
3165 * 'acceptable_rel' is either zero or the rangetable index of a relation
3166 * whose Vars may appear in the clause without provoking an error
3167 * 'rtoffset': how much to increment varnos by
3168 * 'nrm_match': as for search_indexed_tlist_for_var()
3169 * 'num_exec': estimated number of executions of expression
3170 *
3171 * Returns the new expression tree. The original clause structure is
3172 * not modified.
3173 */
3176 List *clauses,
3177 indexed_tlist *outer_itlist,
3178 indexed_tlist *inner_itlist,
3179 Index acceptable_rel,
3180 int rtoffset,
3181 NullingRelsMatch nrm_match,
3182 double num_exec)
3183{
3184 fix_join_expr_context context;
3185
3187 context.outer_itlist = outer_itlist;
3188 context.inner_itlist = inner_itlist;
3189 context.acceptable_rel = acceptable_rel;
3190 context.rtoffset = rtoffset;
3191 context.nrm_match = nrm_match;
3192 context.num_exec = num_exec;
3194}
3195
3198{
3200
3204 {
3206
3207 /*
3208 * Verify that Vars with non-default varreturningtype only appear in
3209 * the RETURNING list, and refer to the target relation.
3210 */
3212 {
3215 context->acceptable_rel == 0)
3220 }
3221
3222 /* Look for the var in the input tlists, first in the outer */
3224 {
3226 context->outer_itlist,
3227 OUTER_VAR,
3228 context->rtoffset,
3229 context->nrm_match);
3232 }
3233
3234 /* then in the inner. */
3236 {
3238 context->inner_itlist,
3239 INNER_VAR,
3240 context->rtoffset,
3241 context->nrm_match);
3244 }
3245
3246 /* If it's for acceptable_rel, adjust and return it */
3248 {
3249 var = copyVar(var);
3251 if (var->varnosyn > 0)
3252 var->varnosyn += context->rtoffset;
3254 }
3255
3256 /* No referent found for Var */
3258 }
3260 {
3262
3263 /* See if the PlaceHolderVar has bubbled up from a lower plan node */
3265 {
3267 context->outer_itlist,
3268 OUTER_VAR,
3269 context->nrm_match);
3272 }
3274 {
3276 context->inner_itlist,
3277 INNER_VAR,
3278 context->nrm_match);
3281 }
3282
3283 /* If not supplied by input plans, evaluate the contained expr */
3284 /* XXX can we assert something about phnullingrels? */
3286 }
3287 /* Try matching more complex expressions too, if tlists have any */
3289 {
3291 context->outer_itlist,
3292 OUTER_VAR);
3295 }
3297 {
3299 context->inner_itlist,
3300 INNER_VAR);
3303 }
3304 /* Special cases (apply only AFTER failing to match to lower tlist) */
3309 (AlternativeSubPlan *) node,
3310 context->num_exec),
3311 context);
3314}
3315
3316/*
3317 * fix_upper_expr
3318 * Modifies an expression tree so that all Var nodes reference outputs
3319 * of a subplan. Also looks for Aggref nodes that should be replaced
3320 * by initplan output Params. Also performs opcode lookup, and adds
3321 * regclass OIDs to root->glob->relationOids.
3322 *
3323 * This is used to fix up target and qual expressions of non-join upper-level
3324 * plan nodes, as well as index-only scan nodes.
3325 *
3326 * An error is raised if no matching var can be found in the subplan tlist
3327 * --- so this routine should only be applied to nodes whose subplans'
3328 * targetlists were generated by flattening the expressions used in the
3329 * parent node.
3330 *
3331 * If itlist->has_non_vars is true, then we try to match whole subexpressions
3332 * against elements of the subplan tlist, so that we can avoid recomputing
3333 * expressions that were already computed by the subplan. (This is relatively
3334 * expensive, so we don't want to try it in the common case where the
3335 * subplan tlist is just a flattened list of Vars.)
3336 *
3337 * 'node': the tree to be fixed (a target item or qual)
3338 * 'subplan_itlist': indexed target list for subplan (or index)
3339 * 'newvarno': varno to use for Vars referencing tlist elements
3340 * 'rtoffset': how much to increment varnos by
3341 * 'nrm_match': as for search_indexed_tlist_for_var()
3342 * 'num_exec': estimated number of executions of expression
3343 *
3344 * The resulting tree is a copy of the original in which all Var nodes have
3345 * varno = newvarno, varattno = resno of corresponding targetlist element.
3346 * The original tree is not modified.
3347 */
3350 Node *node,
3351 indexed_tlist *subplan_itlist,
3352 int newvarno,
3353 int rtoffset,
3354 NullingRelsMatch nrm_match,
3355 double num_exec)
3356{
3357 fix_upper_expr_context context;
3358
3360 context.subplan_itlist = subplan_itlist;
3361 context.newvarno = newvarno;
3362 context.rtoffset = rtoffset;
3363 context.nrm_match = nrm_match;
3364 context.num_exec = num_exec;
3366}
3367
3370{
3372
3376 {
3378
3380 context->subplan_itlist,
3381 context->newvarno,
3382 context->rtoffset,
3383 context->nrm_match);
3387 }
3389 {
3391
3392 /* See if the PlaceHolderVar has bubbled up from a lower plan node */
3394 {
3396 context->subplan_itlist,
3397 context->newvarno,
3398 context->nrm_match);
3401 }
3402 /* If not supplied by input plan, evaluate the contained expr */
3403 /* XXX can we assert something about phnullingrels? */
3405 }
3406 /* Try matching more complex expressions too, if tlist has any */
3408 {
3410 context->subplan_itlist,
3411 context->newvarno);
3414 }
3415 /* Special cases (apply only AFTER failing to match to lower tlist) */
3419 {
3422
3423 /* See if the Aggref should be replaced by a Param */
3426 {
3427 /* Make a copy of the Param for paranoia's sake */
3429 }
3430 /* If no match, just fall through to process it normally */
3431 }
3434 (AlternativeSubPlan *) node,
3435 context->num_exec),
3436 context);
3439}
3440
3441/*
3442 * set_returning_clause_references
3443 * Perform setrefs.c's work on a RETURNING targetlist
3444 *
3445 * If the query involves more than just the result table, we have to
3446 * adjust any Vars that refer to other tables to reference junk tlist
3447 * entries in the top subplan's targetlist. Vars referencing the result
3448 * table should be left alone, however (the executor will evaluate them
3449 * using the actual heap tuple, after firing triggers if any). In the
3450 * adjusted RETURNING list, result-table Vars will have their original
3451 * varno (plus rtoffset), but Vars for other rels will have varno OUTER_VAR.
3452 *
3453 * We also must perform opcode lookup and add regclass OIDs to
3454 * root->glob->relationOids.
3455 *
3456 * 'rlist': the RETURNING targetlist to be fixed
3457 * 'topplan': the top subplan node that will be just below the ModifyTable
3458 * node (note it's not yet passed through set_plan_refs)
3459 * 'resultRelation': RT index of the associated result relation
3460 * 'rtoffset': how much to increment varnos by
3461 *
3462 * Note: the given 'root' is for the parent query level, not the 'topplan'.
3463 * This does not matter currently since we only access the dependency-item
3464 * lists in root->glob, but it would need some hacking if we wanted a root
3465 * that actually matches the subplan.
3466 *
3467 * Note: resultRelation is not yet adjusted by rtoffset.
3468 */
3473 Index resultRelation,
3474 int rtoffset)
3475{
3477
3478 /*
3479 * We can perform the desired Var fixup by abusing the fix_join_expr
3480 * machinery that formerly handled inner indexscan fixup. We search the
3481 * top plan's targetlist for Vars of non-result relations, and use
3482 * fix_join_expr to convert RETURNING Vars into references to those tlist
3483 * entries, while leaving result-rel Vars as-is.
3484 *
3485 * PlaceHolderVars will also be sought in the targetlist, but no
3486 * more-complex expressions will be. Note that it is not possible for a
3487 * PlaceHolderVar to refer to the result relation, since the result is
3488 * never below an outer join. If that case could happen, we'd have to be
3489 * prepared to pick apart the PlaceHolderVar and evaluate its contained
3490 * expression instead.
3491 */
3493
3495 rlist,
3496 itlist,
3497 NULL,
3498 resultRelation,
3499 rtoffset,
3500 NRM_EQUAL,
3502
3504
3506}
3507
3508/*
3509 * fix_windowagg_condition_expr_mutator
3510 * Mutator function for replacing WindowFuncs with the corresponding Var
3511 * in the targetlist which references that WindowFunc.
3512 */
3515 fix_windowagg_cond_context *context)
3516{
3519
3521 {
3523
3525 context->subplan_itlist,
3526 context->newvarno);
3530 }
3531
3534 context);
3535}
3536
3537/*
3538 * fix_windowagg_condition_expr
3539 * Converts references in 'runcondition' so that any WindowFunc
3540 * references are swapped out for a Var which references the matching
3541 * WindowFunc in 'subplan_itlist'.
3542 */
3545 List *runcondition,
3546 indexed_tlist *subplan_itlist)
3547{
3548 fix_windowagg_cond_context context;
3549
3551 context.subplan_itlist = subplan_itlist;
3552 context.newvarno = 0;
3553
3555 &context);
3556}
3557
3558/*
3559 * set_windowagg_runcondition_references
3560 * Converts references in 'runcondition' so that any WindowFunc
3561 * references are swapped out for a Var which references the matching
3562 * WindowFunc in 'plan' targetlist.
3563 */
3566 List *runcondition,
3568{
3571
3573
3575
3577
3579}
3580
3581/*
3582 * find_minmax_agg_replacement_param
3583 * If the given Aggref is one that we are optimizing into a subquery
3584 * (cf. planagg.c), then return the Param that should replace it.
3585 * Else return NULL.
3586 *
3587 * This is exported so that SS_finalize_plan can use it before setrefs.c runs.
3588 * Note that it will not find anything until we have built a Plan from a
3589 * MinMaxAggPath, as root->minmax_aggs will never be filled otherwise.
3590 */
3591Param *
3593{
3596 {
3599
3601 {
3603
3607 }
3608 }
3610}
3611
3612
3613/*****************************************************************************
3614 * QUERY DEPENDENCY MANAGEMENT
3615 *****************************************************************************/
3616
3617/*
3618 * record_plan_function_dependency
3619 * Mark the current plan as depending on a particular function.
3620 *
3621 * This is exported so that the function-inlining code can record a
3622 * dependency on a function that it's removed from the plan tree.
3623 */
3624void
3626{
3627 /*
3628 * For performance reasons, we don't bother to track built-in functions;
3629 * we just assume they'll never change (or at least not in ways that'd
3630 * invalidate plans using them). For this purpose we can consider a
3631 * built-in function to be one with OID less than FirstUnpinnedObjectId.
3632 * Note that the OID generator guarantees never to generate such an OID
3633 * after startup, even at OID wraparound.
3634 */
3636 {
3638
3639 /*
3640 * It would work to use any syscache on pg_proc, but the easiest is
3641 * PROCOID since we already have the function's OID at hand. Note
3642 * that plancache.c knows we use PROCOID.
3643 */
3646 ObjectIdGetDatum(funcid));
3647
3649 }
3650}
3651
3652/*
3653 * record_plan_type_dependency
3654 * Mark the current plan as depending on a particular type.
3655 *
3656 * This is exported so that eval_const_expressions can record a
3657 * dependency on a domain that it's removed a CoerceToDomain node for.
3658 *
3659 * We don't currently need to record dependencies on domains that the
3660 * plan contains CoerceToDomain nodes for, though that might change in
3661 * future. Hence, this isn't actually called in this module, though
3662 * someday fix_expr_common might call it.
3663 */
3664void
3666{
3667 /*
3668 * As in record_plan_function_dependency, ignore the possibility that
3669 * someone would change a built-in domain.
3670 */
3672 {
3674
3675 /*
3676 * It would work to use any syscache on pg_type, but the easiest is
3677 * TYPEOID since we already have the type's OID at hand. Note that
3678 * plancache.c knows we use TYPEOID.
3679 */
3682 ObjectIdGetDatum(typid));
3683
3685 }
3686}
3687
3688/*
3689 * extract_query_dependencies
3690 * Given a rewritten, but not yet planned, query or queries
3691 * (i.e. a Query node or list of Query nodes), extract dependencies
3692 * just as set_plan_references would do. Also detect whether any
3693 * rewrite steps were affected by RLS.
3694 *
3695 * This is needed by plancache.c to handle invalidation of cached unplanned
3696 * queries.
3697 *
3698 * Note: this does not go through eval_const_expressions, and hence doesn't
3699 * reflect its additions of inlined functions and elided CoerceToDomain nodes
3700 * to the invalItems list. This is obviously OK for functions, since we'll
3701 * see them in the original query tree anyway. For domains, it's OK because
3702 * we don't care about domains unless they get elided. That is, a plan might
3703 * have domain dependencies that the query tree doesn't.
3704 */
3705void
3707 List **relationOids,
3708 List **invalItems,
3709 bool *hasRowSecurity)
3710{
3711 PlannerGlobal glob;
3713
3714 /* Make up dummy planner state so we can use this module's machinery */
3716 glob.type = T_PlannerGlobal;
3719 /* Hack: we use glob.dependsOnRole to collect hasRowSecurity flags */
3721
3724 root.glob = &glob;
3725
3727
3728 *relationOids = glob.relationOids;
3729 *invalItems = glob.invalItems;
3730 *hasRowSecurity = glob.dependsOnRole;
3731}
3732
3733/*
3734 * Tree walker for extract_query_dependencies.
3735 *
3736 * This is exported so that expression_planner_with_deps can call it on
3737 * simple expressions (post-planning, not before planning, in that case).
3738 * In that usage, glob.dependsOnRole isn't meaningful, but the relationOids
3739 * and invalItems lists are added to as needed.
3740 */
3741bool
3743{
3745 return false;
3748 {
3751
3753 {
3754 /*
3755 * This logic must handle any utility command for which parse
3756 * analysis was nontrivial (cf. stmt_requires_parse_analysis).
3757 *
3758 * Notably, CALL requires its own processing.
3759 */
3761 {
3763
3764 /* We need not examine funccall, just the transformed exprs */
3766 context);
3768 context);
3769 return false;
3770 }
3771
3772 /*
3773 * Ignore other utility statements, except those (such as EXPLAIN)
3774 * that contain a parsed-but-not-planned query. For those, we
3775 * just need to transfer our attention to the contained query.
3776 */
3779 return false;
3780 }
3781
3782 /* Remember if any Query has RLS quals applied by rewriter */
3783 if (query->hasRowSecurity)
3785
3786 /* Collect relation OIDs in this Query's rtable */
3788 {
3790
3796 }
3797
3798 /* And recurse into the query's subexpressions */
3800 context, 0);
3801 }
3802 /* Extract function dependencies and check for regclass Consts */
3803 fix_expr_common(context, node);
3805 context);
3806}
3807
3808/*
3809 * Record some details about a node removed from the plan during setrefs
3810 * processing, for the benefit of code trying to reconstruct planner decisions
3811 * from examination of the final plan tree.
3812 */
3813static void
3816{
3818
3819 n->plan_node_id = plan_node_id;
3820 n->elided_type = elided_type;
3821 n->relids = relids;
3822
3824}
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:292
Var * makeVarFromTargetEntry(int varno, TargetEntry *tle)
Definition makefuncs.c:107
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition makefuncs.c:66
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition makefuncs.c:388
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition makefuncs.c:289
TargetEntry * flatCopyTargetEntry(TargetEntry *src_tle)
Definition makefuncs.c:322
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
Definition parse_relation.c:3950
RTEPermissionInfo * addRTEPermissionInfo(List **rteperminfos, RangeTblEntry *rte)
Definition parse_relation.c:3921
void mark_partial_aggref(Aggref *agg, AggSplit aggsplit)
Definition planner.c:5818
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
Definition relnode.c:1606
Node * remove_nulling_relids(Node *node, const Bitmapset *removable_relids, const Bitmapset *except_relids)
Definition rewriteManip.c:1328
void record_plan_type_dependency(PlannerInfo *root, Oid typid)
Definition setrefs.c:3666
static void set_hash_references(PlannerInfo *root, Plan *plan, int rtoffset)
Definition setrefs.c:2025
static void record_elided_node(PlannerGlobal *glob, int plan_node_id, NodeTag elided_type, Bitmapset *relids)
Definition setrefs.c:3815
static void add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
Definition setrefs.c:399
static Node * fix_join_expr_mutator(Node *node, fix_join_expr_context *context)
Definition setrefs.c:3198
static void add_rte_to_flat_rtable(PlannerGlobal *glob, List *rteperminfos, RangeTblEntry *rte)
Definition setrefs.c:565
static Plan * set_append_references(PlannerInfo *root, Append *aplan, int rtoffset)
Definition setrefs.c:1873
Plan * set_plan_references(PlannerInfo *root, Plan *plan)
Definition setrefs.c:291
static Plan * set_mergeappend_references(PlannerInfo *root, MergeAppend *mplan, int rtoffset)
Definition setrefs.c:1950
static List * set_returning_clause_references(PlannerInfo *root, List *rlist, Plan *topplan, Index resultRelation, int rtoffset)
Definition setrefs.c:3471
void record_plan_function_dependency(PlannerInfo *root, Oid funcid)
Definition setrefs.c:3626
static Relids offset_relid_set(Relids relids, int rtoffset)
Definition setrefs.c:2058
static bool flatten_rtes_walker(Node *node, flatten_rtes_walker_context *cxt)
Definition setrefs.c:520
static List * set_windowagg_runcondition_references(PlannerInfo *root, List *runcondition, Plan *plan)
Definition setrefs.c:3566
static void set_upper_references(PlannerInfo *root, Plan *plan, int rtoffset)
Definition setrefs.c:2553
static Var * search_indexed_tlist_for_sortgroupref(Expr *node, Index sortgroupref, indexed_tlist *itlist, int newvarno)
Definition setrefs.c:3098
static void flatten_unplanned_rtes(PlannerGlobal *glob, RangeTblEntry *rte)
Definition setrefs.c:508
static Node * fix_upper_expr(PlannerInfo *root, Node *node, indexed_tlist *subplan_itlist, int newvarno, int rtoffset, NullingRelsMatch nrm_match, double num_exec)
Definition setrefs.c:3350
static void set_param_references(PlannerInfo *root, Plan *plan)
Definition setrefs.c:2641
static Var * search_indexed_tlist_for_non_var(Expr *node, indexed_tlist *itlist, int newvarno)
Definition setrefs.c:3058
static Node * fix_upper_expr_mutator(Node *node, fix_upper_expr_context *context)
Definition setrefs.c:3370
Param * find_minmax_agg_replacement_param(PlannerInfo *root, Aggref *aggref)
Definition setrefs.c:3593
static Node * fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context)
Definition setrefs.c:2319
static void set_foreignscan_references(PlannerInfo *root, ForeignScan *fscan, int rtoffset)
Definition setrefs.c:1642
static Plan * set_subqueryscan_references(PlannerInfo *root, SubqueryScan *plan, int rtoffset)
Definition setrefs.c:1452
static Var * search_indexed_tlist_for_phv(PlaceHolderVar *phv, indexed_tlist *itlist, int newvarno, NullingRelsMatch nrm_match)
Definition setrefs.c:3005
static Plan * set_indexonlyscan_references(PlannerInfo *root, IndexOnlyScan *plan, int rtoffset)
Definition setrefs.c:1378
static List * fix_join_expr(PlannerInfo *root, List *clauses, indexed_tlist *outer_itlist, indexed_tlist *inner_itlist, Index acceptable_rel, int rtoffset, NullingRelsMatch nrm_match, double num_exec)
Definition setrefs.c:3176
static Node * convert_combining_aggrefs(Node *node, void *context)
Definition setrefs.c:2696
static void set_dummy_tlist_references(Plan *plan, int rtoffset)
Definition setrefs.c:2764
static int register_partpruneinfo(PlannerInfo *root, int part_prune_index, int rtoffset)
Definition setrefs.c:1812
static void set_customscan_references(PlannerInfo *root, CustomScan *cscan, int rtoffset)
Definition setrefs.c:1729
void extract_query_dependencies(Node *query, List **relationOids, List **invalItems, bool *hasRowSecurity)
Definition setrefs.c:3707
static Node * fix_windowagg_condition_expr_mutator(Node *node, fix_windowagg_cond_context *context)
Definition setrefs.c:3515
bool extract_query_dependencies_walker(Node *node, PlannerInfo *context)
Definition setrefs.c:3743
static List * fix_windowagg_condition_expr(PlannerInfo *root, List *runcondition, indexed_tlist *subplan_itlist)
Definition setrefs.c:3545
static Node * fix_alternative_subplan(PlannerInfo *root, AlternativeSubPlan *asplan, double num_exec)
Definition setrefs.c:2228
static void set_join_references(PlannerInfo *root, Join *join, int rtoffset)
Definition setrefs.c:2404
static indexed_tlist * build_tlist_index_other_vars(List *tlist, int ignore_rel)
Definition setrefs.c:2882
static Plan * clean_up_removed_plan_level(Plan *parent, Plan *child)
Definition setrefs.c:1598
static Node * fix_scan_expr(PlannerInfo *root, Node *node, int rtoffset, double num_exec)
Definition setrefs.c:2284
static Plan * set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset)
Definition setrefs.c:642
static bool fix_scan_expr_walker(Node *node, fix_scan_expr_context *context)
Definition setrefs.c:2384
static Var * search_indexed_tlist_for_var(Var *var, indexed_tlist *itlist, int newvarno, int rtoffset, NullingRelsMatch nrm_match)
Definition setrefs.c:2940
Definition plannodes.h:1208
Definition primnodes.h:460
Definition primnodes.h:1143
Definition pathnodes.h:3275
Definition plannodes.h:397
Definition plannodes.h:509
Definition plannodes.h:709
Definition plannodes.h:687
Definition plannodes.h:523
Definition bitmapset.h:50
Definition parsenodes.h:3670
Definition primnodes.h:325
Definition plannodes.h:818
Definition primnodes.h:2121
Definition plannodes.h:931
Definition plannodes.h:1867
Definition primnodes.h:190
Definition plannodes.h:889
Definition primnodes.h:780
Definition plannodes.h:783
Definition plannodes.h:1378
Definition plannodes.h:1355
Definition primnodes.h:558
Definition plannodes.h:1063
Definition plannodes.h:1420
Definition plannodes.h:653
Definition plannodes.h:603
Definition plannodes.h:983
Definition plannodes.h:1497
Definition pg_list.h:54
Definition plannodes.h:1481
Definition plannodes.h:1090
Definition primnodes.h:2030
Definition plannodes.h:432
Definition plannodes.h:1034
Definition pathnodes.h:3423
Definition plannodes.h:337
Definition plannodes.h:831
Definition plannodes.h:1012
Definition plannodes.h:1005
Definition nodes.h:135
Definition primnodes.h:847
Definition primnodes.h:392
Definition plannodes.h:1662
Definition plannodes.h:1693
Definition pathnodes.h:3101
Definition plannodes.h:1816
Definition plannodes.h:1604
Definition plannodes.h:192
Definition pathnodes.h:169
Definition pathnodes.h:303
Definition parsenodes.h:118
Definition parsenodes.h:1344
Definition parsenodes.h:1085
Definition pathnodes.h:998
Definition plannodes.h:302
Definition plannodes.h:559
Definition primnodes.h:927
Definition plannodes.h:550
Definition plannodes.h:1850
Definition primnodes.h:1093
Definition plannodes.h:772
Definition plannodes.h:807
Definition primnodes.h:112
Definition parsenodes.h:1402
Definition primnodes.h:2237
Definition plannodes.h:738
Definition plannodes.h:724
Definition plannodes.h:796
Definition primnodes.h:263
Definition plannodes.h:1250
Definition primnodes.h:595
Definition plannodes.h:842
Definition setrefs.c:66
Definition setrefs.c:59
Definition setrefs.c:77
Definition setrefs.c:87
Definition setrefs.c:95
Definition setrefs.c:50
Definition setrefs.c:42
Definition regcomp.c:282
void SS_compute_initplan_cost(List *init_plans, Cost *initplan_cost_p, bool *unsafe_initplans_p)
Definition subselect.c:2354
void apply_tlist_labeling(List *dest_tlist, List *src_tlist)
Definition tlist.c:327
Definition pg_list.h:46
◆ ISREGCLASSCONST
| #define ISREGCLASSCONST | ( | con | ) |
Value:
(((con)->consttype == REGCLASSOID || (con)->consttype == OIDOID) && \
!(con)->constisnull)
◆ NUM_EXEC_QUAL
| #define NUM_EXEC_QUAL | ( | parentplan | ) | ((parentplan)->plan_rows * 2.0) |
◆ NUM_EXEC_TLIST
| #define NUM_EXEC_TLIST | ( | parentplan | ) | ((parentplan)->plan_rows) |
Enumeration Type Documentation
◆ NullingRelsMatch
| Enumerator | |
|---|---|
| NRM_EQUAL | |
| NRM_SUBSET | |
| NRM_SUPERSET | |
Definition at line 34 of file setrefs.c.
35{
39} NullingRelsMatch;
Function Documentation
◆ add_rte_to_flat_rtable()
|
static |
Definition at line 565 of file setrefs.c.
567{
569
570 /* flat copy to duplicate all the scalar fields */
573
574 /* zap unneeded sub-structure */
589
591
592 /*
593 * If it's a plain relation RTE (or a subquery that was once a view
594 * reference), add the relation OID to relationOids. Also add its new RT
595 * index to the set of relations to be potentially accessed during
596 * execution.
597 *
598 * We do this even though the RTE might be unreferenced in the plan tree;
599 * this would correspond to cases such as views that were expanded, child
600 * tables that were eliminated by constraint exclusion, etc. Schema
601 * invalidation on such a rel must still force rebuilding of the plan.
602 *
603 * Note we don't bother to avoid making duplicate list entries. We could,
604 * but it would probably cost more cycles than it would save.
605 */
608 {
612 }
613
614 /*
615 * Add a copy of the RTEPermissionInfo, if any, corresponding to this RTE
616 * to the flattened global list.
617 */
619 {
622
623 /* Get the existing one from this query's rteperminfos. */
625
626 /*
627 * Add a new one to finalrteperminfos and copy the contents of the
628 * existing one into it. Note that addRTEPermissionInfo() also
629 * updates newrte->perminfoindex to point to newperminfo in
630 * finalrteperminfos.
631 */
635 }
636}
References addRTEPermissionInfo(), PlannerGlobal::allRelids, bms_add_member(), fb(), PlannerGlobal::finalrtable, PlannerGlobal::finalrteperminfos, getRTEPermissionInfo(), lappend(), lappend_oid(), list_length(), NIL, OidIsValid, palloc_object, PlannerGlobal::relationOids, RTE_RELATION, and RTE_SUBQUERY.
Referenced by add_rtes_to_flat_rtable(), and flatten_rtes_walker().
◆ add_rtes_to_flat_rtable()
|
static |
Definition at line 399 of file setrefs.c.
400{
402 Index rti;
404
405 /*
406 * Record enough information to make it possible for code that looks at
407 * the final range table to understand how it was constructed. (If
408 * finalrtable is still NIL, then this is the very topmost PlannerInfo,
409 * which will always have plan_name == NULL and rtoffset == 0; we omit the
410 * degenerate list entry.)
411 */
413 {
415
418
419 /* When recursing = true, it's an unplanned or dummy subquery. */
420 rtinfo->dummy = recursing;
421
423 }
424
425 /*
426 * Add the query's own RTEs to the flattened rangetable.
427 *
428 * At top level, we must add all RTEs so that their indexes in the
429 * flattened rangetable match up with their original indexes. When
430 * recursing, we only care about extracting relation RTEs (and subquery
431 * RTEs that were once relation RTEs).
432 */
434 {
436
440 }
441
442 /*
443 * If there are any dead subqueries, they are not referenced in the Plan
444 * tree, so we must add RTEs contained in them to the flattened rtable
445 * separately. (If we failed to do this, the executor would not perform
446 * expected permission checks for tables mentioned in such subqueries.)
447 *
448 * Note: this pass over the rangetable can't be combined with the previous
449 * one, because that would mess up the numbering of the live RTEs in the
450 * flattened rangetable.
451 */
452 rti = 1;
454 {
456
457 /*
458 * We should ignore inheritance-parent RTEs: their contents have been
459 * pulled up into our rangetable already. Also ignore any subquery
460 * RTEs without matching RelOptInfos, as they likewise have been
461 * pulled up.
462 */
464 rti < root->simple_rel_array_size)
465 {
467
469 {
471
472 /*
473 * The subquery might never have been planned at all, if it
474 * was excluded on the basis of self-contradictory constraints
475 * in our query level. In this case apply
476 * flatten_unplanned_rtes.
477 *
478 * If it was planned but the result rel is dummy, we assume
479 * that it has been omitted from our plan tree (see
480 * set_subquery_pathlist), and recurse to pull up its RTEs.
481 *
482 * Otherwise, it should be represented by a SubqueryScan node
483 * somewhere in our plan tree, and we'll pull up its RTEs when
484 * we process that plan node.
485 *
486 * However, if we're recursing, then we should pull up RTEs
487 * whether the subquery is dummy or not, because we've found
488 * that some upper query level is treating this one as dummy,
489 * and so we won't scan this level's plan tree at all.
490 */
493 else if (recursing ||
497 }
498 }
499 rti++;
500 }
501}
References add_rte_to_flat_rtable(), add_rtes_to_flat_rtable(), Assert, fb(), fetch_upper_rel(), flatten_unplanned_rtes(), IS_DUMMY_REL, lappend(), lfirst, list_length(), makeNode, NIL, OidIsValid, RelOptInfo::relid, root, RTE_RELATION, RTE_SUBQUERY, RelOptInfo::subroot, and UPPERREL_FINAL.
Referenced by add_rtes_to_flat_rtable(), and set_plan_references().
◆ build_tlist_index()
|
static |
Definition at line 2831 of file setrefs.c.
2832{
2835 ListCell *l;
2836
2837 /* Create data structure with enough slots for all tlist entries */
2841
2842 itlist->tlist = tlist;
2845
2846 /* Find the Vars and fill in the index array */
2848 foreach(l, tlist)
2849 {
2851
2853 {
2855
2856 vinfo->varno = var->varno;
2857 vinfo->varattno = var->varattno;
2859 vinfo->varnullingrels = var->varnullingrels;
2860 vinfo++;
2861 }
2864 else
2866 }
2867
2869
2871}
References fb(), IsA, lfirst, list_length(), palloc(), Var::varattno, and Var::varno.
Referenced by set_customscan_references(), set_foreignscan_references(), set_hash_references(), set_indexonlyscan_references(), set_join_references(), set_plan_refs(), set_upper_references(), and set_windowagg_runcondition_references().
◆ build_tlist_index_other_vars()
|
static |
Definition at line 2882 of file setrefs.c.
2883{
2886 ListCell *l;
2887
2888 /* Create data structure with enough slots for all tlist entries */
2892
2893 itlist->tlist = tlist;
2896
2897 /* Find the desired Vars and fill in the index array */
2899 foreach(l, tlist)
2900 {
2902
2904 {
2906
2908 {
2909 vinfo->varno = var->varno;
2910 vinfo->varattno = var->varattno;
2912 vinfo->varnullingrels = var->varnullingrels;
2913 vinfo++;
2914 }
2915 }
2918 }
2919
2921
2923}
References fb(), IsA, lfirst, list_length(), palloc(), Var::varattno, and Var::varno.
Referenced by set_returning_clause_references().
◆ clean_up_removed_plan_level()
Definition at line 1598 of file setrefs.c.
1599{
1600 /*
1601 * We have to be sure we don't lose any initplans, so move any that were
1602 * attached to the parent plan to the child. If any are parallel-unsafe,
1603 * the child is no longer parallel-safe. As a cosmetic matter, also add
1604 * the initplans' run costs to the child's costs.
1605 */
1607 {
1610
1617
1618 /*
1619 * Attach plans this way so that parent's initplans are processed
1620 * before any pre-existing initplans of the child. Probably doesn't
1621 * matter, but let's preserve the ordering just in case.
1622 */
1624 child->initPlan);
1625 }
1626
1627 /*
1628 * We also have to transfer the parent's column labeling info into the
1629 * child, else columns sent to client will be improperly labeled if this
1630 * is the topmost plan level. resjunk and so on may be important too.
1631 */
1633
1634 return child;
1635}
References apply_tlist_labeling(), fb(), Plan::initPlan, list_concat(), Plan::parallel_safe, SS_compute_initplan_cost(), Plan::startup_cost, Plan::targetlist, and Plan::total_cost.
Referenced by set_append_references(), set_mergeappend_references(), and set_subqueryscan_references().
◆ convert_combining_aggrefs()
Definition at line 2696 of file setrefs.c.
2697{
2701 {
2705
2706 /* Assert we've not chosen to partial-ize any unsupported cases */
2709
2710 /*
2711 * Since aggregate calls can't be nested, we needn't recurse into the
2712 * arguments. But for safety, flat-copy the Aggref node itself rather
2713 * than modifying it in-place.
2714 */
2717
2718 /*
2719 * For the parent Aggref, we want to copy all the fields of the
2720 * original aggregate *except* the args list, which we'll replace
2721 * below, and the aggfilter expression, which should be applied only
2722 * by the child not the parent. Rather than explicitly knowing about
2723 * all the other fields here, we can momentarily modify child_agg to
2724 * provide a suitable source for copyObject.
2725 */
2731
2732 /*
2733 * Now, set up child_agg to represent the first phase of partial
2734 * aggregation. For now, assume serialization is required.
2735 */
2737
2738 /*
2739 * And set up parent_agg to represent the second phase.
2740 */
2744
2746 }
2748}
References AGGSPLIT_FINAL_DESERIAL, AGGSPLIT_INITIAL_SERIAL, Assert, convert_combining_aggrefs(), copyObject, expression_tree_mutator, fb(), IsA, list_make1, makeNode, makeTargetEntry(), mark_partial_aggref(), and NIL.
Referenced by convert_combining_aggrefs(), and set_plan_refs().
◆ copyVar()
Definition at line 2080 of file setrefs.c.
References fb(), and palloc_object.
Referenced by fix_join_expr_mutator(), fix_scan_expr_mutator(), and search_indexed_tlist_for_var().
◆ extract_query_dependencies()
| void extract_query_dependencies | ( | Node * | query, |
| List ** | relationOids, | ||
| List ** | invalItems, | ||
| bool * | hasRowSecurity | ||
| ) |
Definition at line 3707 of file setrefs.c.
3711{
3712 PlannerGlobal glob;
3714
3715 /* Make up dummy planner state so we can use this module's machinery */
3717 glob.type = T_PlannerGlobal;
3720 /* Hack: we use glob.dependsOnRole to collect hasRowSecurity flags */
3722
3725 root.glob = &glob;
3726
3728
3729 *relationOids = glob.relationOids;
3730 *invalItems = glob.invalItems;
3731 *hasRowSecurity = glob.dependsOnRole;
3732}
References PlannerGlobal::dependsOnRole, extract_query_dependencies_walker(), fb(), PlannerGlobal::invalItems, MemSet, NIL, PlannerGlobal::relationOids, and root.
Referenced by CompleteCachedPlan(), and RevalidateCachedQuery().
◆ extract_query_dependencies_walker()
| bool extract_query_dependencies_walker | ( | Node * | node, |
| PlannerInfo * | context | ||
| ) |
Definition at line 3743 of file setrefs.c.
3744{
3746 return false;
3749 {
3752
3754 {
3755 /*
3756 * This logic must handle any utility command for which parse
3757 * analysis was nontrivial (cf. stmt_requires_parse_analysis).
3758 *
3759 * Notably, CALL requires its own processing.
3760 */
3762 {
3764
3765 /* We need not examine funccall, just the transformed exprs */
3767 context);
3769 context);
3770 return false;
3771 }
3772
3773 /*
3774 * Ignore other utility statements, except those (such as EXPLAIN)
3775 * that contain a parsed-but-not-planned query. For those, we
3776 * just need to transfer our attention to the contained query.
3777 */
3780 return false;
3781 }
3782
3783 /* Remember if any Query has RLS quals applied by rewriter */
3784 if (query->hasRowSecurity)
3786
3787 /* Collect relation OIDs in this Query's rtable */
3789 {
3791
3797 }
3798
3799 /* And recurse into the query's subexpressions */
3801 context, 0);
3802 }
3803 /* Extract function dependencies and check for regclass Consts */
3804 fix_expr_common(context, node);
3806 context);
3807}
References Assert, CMD_UTILITY, Query::commandType, PlannerGlobal::dependsOnRole, expression_tree_walker, extract_query_dependencies_walker(), fb(), fix_expr_common(), PlannerInfo::glob, IsA, lappend_oid(), lfirst, OidIsValid, query_tree_walker, PlannerGlobal::relationOids, Query::rtable, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_SUBQUERY, UtilityContainsQuery(), and Query::utilityStmt.
Referenced by expression_planner_with_deps(), extract_query_dependencies(), and extract_query_dependencies_walker().
◆ find_minmax_agg_replacement_param()
| Param * find_minmax_agg_replacement_param | ( | PlannerInfo * | root, |
| Aggref * | aggref | ||
| ) |
Definition at line 3593 of file setrefs.c.
3594{
3597 {
3600
3602 {
3604
3608 }
3609 }
3611}
References Aggref::aggfnoid, Aggref::args, equal(), fb(), lfirst, linitial, list_length(), NIL, MinMaxAggInfo::param, and root.
Referenced by finalize_primnode(), fix_scan_expr_mutator(), and fix_upper_expr_mutator().
◆ fix_alternative_subplan()
|
static |
Definition at line 2228 of file setrefs.c.
2230{
2234
2235 /*
2236 * Compute the estimated cost of each subplan assuming num_exec
2237 * executions, and keep the cheapest one. In event of exact equality of
2238 * estimates, we prefer the later plan; this is a bit arbitrary, but in
2239 * current usage it biases us to break ties against fast-start subplans.
2240 */
2242
2244 {
2247
2250 {
2253 }
2254
2255 /* Also mark all subplans that are in AlternativeSubPlans */
2257 }
2258
2259 /* Mark the subplan we selected */
2261
2263}
References Assert, fb(), lfirst, NIL, root, and SubPlan::startup_cost.
Referenced by fix_join_expr_mutator(), fix_scan_expr_mutator(), and fix_upper_expr_mutator().
◆ fix_expr_common()
|
static |
Definition at line 2102 of file setrefs.c.
2103{
2104 /* We assume callers won't call us on a NULL pointer */
2106 {
2108 ((Aggref *) node)->aggfnoid);
2109 }
2111 {
2113 ((WindowFunc *) node)->winfnoid);
2114 }
2116 {
2118 ((FuncExpr *) node)->funcid);
2119 }
2121 {
2125 }
2127 {
2131 }
2133 {
2137 }
2139 {
2141
2142 set_sa_opfuncid(saop);
2144
2147
2150 }
2152 {
2154
2155 /* Check for regclass reference */
2157 root->glob->relationOids =
2159 DatumGetObjectId(con->constvalue));
2160 }
2162 {
2165
2166 /* If there are no grouping sets, we don't need this. */
2167
2169
2171 {
2174
2176 {
2178 }
2179
2181
2182 if (!g->cols)
2183 g->cols = cols;
2184 }
2185 }
2186}
References Assert, DatumGetObjectId(), equal(), fb(), IsA, ISREGCLASSCONST, lappend_int(), lappend_oid(), lfirst_int, NIL, OidIsValid, record_plan_function_dependency(), root, set_opfuncid(), and set_sa_opfuncid().
Referenced by extract_query_dependencies_walker(), fix_join_expr_mutator(), fix_scan_expr_mutator(), fix_scan_expr_walker(), and fix_upper_expr_mutator().
◆ fix_join_expr()
|
static |
Definition at line 3176 of file setrefs.c.
3184{
3185 fix_join_expr_context context;
3186
3188 context.outer_itlist = outer_itlist;
3189 context.inner_itlist = inner_itlist;
3190 context.acceptable_rel = acceptable_rel;
3191 context.rtoffset = rtoffset;
3192 context.nrm_match = nrm_match;
3193 context.num_exec = num_exec;
3195}
References fix_join_expr_context::acceptable_rel, fix_join_expr_mutator(), fix_join_expr_context::inner_itlist, fix_join_expr_context::nrm_match, fix_join_expr_context::num_exec, fix_join_expr_context::outer_itlist, fix_join_expr_context::root, root, and fix_join_expr_context::rtoffset.
Referenced by set_join_references(), set_plan_refs(), and set_returning_clause_references().
◆ fix_join_expr_mutator()
|
static |
Definition at line 3198 of file setrefs.c.
3199{
3201
3205 {
3207
3208 /*
3209 * Verify that Vars with non-default varreturningtype only appear in
3210 * the RETURNING list, and refer to the target relation.
3211 */
3213 {
3216 context->acceptable_rel == 0)
3221 }
3222
3223 /* Look for the var in the input tlists, first in the outer */
3225 {
3227 context->outer_itlist,
3228 OUTER_VAR,
3229 context->rtoffset,
3230 context->nrm_match);
3233 }
3234
3235 /* then in the inner. */
3237 {
3239 context->inner_itlist,
3240 INNER_VAR,
3241 context->rtoffset,
3242 context->nrm_match);
3245 }
3246
3247 /* If it's for acceptable_rel, adjust and return it */
3249 {
3250 var = copyVar(var);
3252 if (var->varnosyn > 0)
3253 var->varnosyn += context->rtoffset;
3255 }
3256
3257 /* No referent found for Var */
3259 }
3261 {
3263
3264 /* See if the PlaceHolderVar has bubbled up from a lower plan node */
3266 {
3268 context->outer_itlist,
3269 OUTER_VAR,
3270 context->nrm_match);
3273 }
3275 {
3277 context->inner_itlist,
3278 INNER_VAR,
3279 context->nrm_match);
3282 }
3283
3284 /* If not supplied by input plans, evaluate the contained expr */
3285 /* XXX can we assert something about phnullingrels? */
3287 }
3288 /* Try matching more complex expressions too, if tlists have any */
3290 {
3292 context->outer_itlist,
3293 OUTER_VAR);
3296 }
3298 {
3300 context->inner_itlist,
3301 INNER_VAR);
3304 }
3305 /* Special cases (apply only AFTER failing to match to lower tlist) */
3310 (AlternativeSubPlan *) node,
3311 context->num_exec),
3312 context);
3315}
References fix_join_expr_context::acceptable_rel, copyVar(), elog, ERROR, expression_tree_mutator, fb(), fix_alternative_subplan(), fix_expr_common(), fix_join_expr_mutator(), fix_param_node(), indexed_tlist::has_non_vars, indexed_tlist::has_ph_vars, fix_join_expr_context::inner_itlist, INNER_VAR, IsA, fix_join_expr_context::nrm_match, fix_join_expr_context::num_exec, fix_join_expr_context::outer_itlist, OUTER_VAR, fix_join_expr_context::root, fix_join_expr_context::rtoffset, search_indexed_tlist_for_non_var(), search_indexed_tlist_for_phv(), search_indexed_tlist_for_var(), VAR_RETURNING_DEFAULT, Var::varno, and Var::varreturningtype.
Referenced by fix_join_expr(), and fix_join_expr_mutator().
◆ fix_param_node()
|
static |
Definition at line 2197 of file setrefs.c.
References copyObject, elog, ERROR, fb(), list_length(), list_nth(), PARAM_MULTIEXPR, Param::paramid, Param::paramkind, and root.
Referenced by fix_join_expr_mutator(), fix_scan_expr_mutator(), and fix_upper_expr_mutator().
◆ fix_scan_expr()
|
static |
Definition at line 2284 of file setrefs.c.
2285{
2286 fix_scan_expr_context context;
2287
2289 context.rtoffset = rtoffset;
2290 context.num_exec = num_exec;
2291
2292 if (rtoffset != 0 ||
2294 root->glob->lastPHId != 0 ||
2296 root->hasAlternativeSubPlans)
2297 {
2299 }
2300 else
2301 {
2302 /*
2303 * If rtoffset == 0, we don't need to change any Vars, and if there
2304 * are no MULTIEXPR subqueries then we don't need to replace
2305 * PARAM_MULTIEXPR Params, and if there are no placeholders anywhere
2306 * we won't need to remove them, and if there are no minmax Aggrefs we
2307 * won't need to replace them, and if there are no AlternativeSubPlans
2308 * we won't need to remove them. Then it's OK to just scribble on the
2309 * input node tree instead of copying (since the only change, filling
2310 * in any unset opfuncid fields, is harmless). This saves just enough
2311 * cycles to be noticeable on trivial queries.
2312 */
2314 return node;
2315 }
2316}
References fb(), fix_scan_expr_mutator(), fix_scan_expr_walker(), NIL, fix_scan_expr_context::num_exec, fix_scan_expr_context::root, root, and fix_scan_expr_context::rtoffset.
Referenced by set_plan_refs().
◆ fix_scan_expr_mutator()
|
static |
Definition at line 2319 of file setrefs.c.
2320{
2324 {
2326
2328
2329 /*
2330 * We should not see Vars marked INNER_VAR, OUTER_VAR, or ROWID_VAR.
2331 * But an indexqual expression could contain INDEX_VAR Vars.
2332 */
2338 if (var->varnosyn > 0)
2339 var->varnosyn += context->rtoffset;
2341 }
2345 {
2348
2349 /* See if the Aggref should be replaced by a Param */
2352 {
2353 /* Make a copy of the Param for paranoia's sake */
2355 }
2356 /* If no match, just fall through to process it normally */
2357 }
2359 {
2361
2365 }
2367 {
2368 /* At scan level, we should always just evaluate the contained expr */
2370
2371 /* XXX can we assert something about phnullingrels? */
2373 }
2376 (AlternativeSubPlan *) node,
2377 context->num_exec),
2378 context);
2381}
References Assert, copyObject, copyVar(), CurrentOfExpr::cvarno, expression_tree_mutator, fb(), find_minmax_agg_replacement_param(), fix_alternative_subplan(), fix_expr_common(), fix_param_node(), fix_scan_expr_mutator(), INNER_VAR, IS_SPECIAL_VARNO, IsA, fix_scan_expr_context::num_exec, OUTER_VAR, fix_scan_expr_context::root, ROWID_VAR, fix_scan_expr_context::rtoffset, Var::varlevelsup, and Var::varno.
Referenced by fix_scan_expr(), and fix_scan_expr_mutator().
◆ fix_scan_expr_walker()
|
static |
Definition at line 2384 of file setrefs.c.
2385{
2387 return false;
2393}
References Assert, expression_tree_walker, fb(), fix_expr_common(), fix_scan_expr_walker(), IsA, fix_scan_expr_context::root, and ROWID_VAR.
Referenced by fix_scan_expr(), and fix_scan_expr_walker().
◆ fix_upper_expr()
|
static |
Definition at line 3350 of file setrefs.c.
3357{
3358 fix_upper_expr_context context;
3359
3361 context.subplan_itlist = subplan_itlist;
3362 context.newvarno = newvarno;
3363 context.rtoffset = rtoffset;
3364 context.nrm_match = nrm_match;
3365 context.num_exec = num_exec;
3367}
References fix_upper_expr_mutator(), fix_upper_expr_context::newvarno, fix_upper_expr_context::nrm_match, fix_upper_expr_context::num_exec, fix_upper_expr_context::root, root, fix_upper_expr_context::rtoffset, and fix_upper_expr_context::subplan_itlist.
Referenced by set_customscan_references(), set_foreignscan_references(), set_hash_references(), set_indexonlyscan_references(), set_join_references(), and set_upper_references().
◆ fix_upper_expr_mutator()
|
static |
Definition at line 3370 of file setrefs.c.
3371{
3373
3377 {
3379
3381 context->subplan_itlist,
3382 context->newvarno,
3383 context->rtoffset,
3384 context->nrm_match);
3388 }
3390 {
3392
3393 /* See if the PlaceHolderVar has bubbled up from a lower plan node */
3395 {
3397 context->subplan_itlist,
3398 context->newvarno,
3399 context->nrm_match);
3402 }
3403 /* If not supplied by input plan, evaluate the contained expr */
3404 /* XXX can we assert something about phnullingrels? */
3406 }
3407 /* Try matching more complex expressions too, if tlist has any */
3409 {
3411 context->subplan_itlist,
3412 context->newvarno);
3415 }
3416 /* Special cases (apply only AFTER failing to match to lower tlist) */
3420 {
3423
3424 /* See if the Aggref should be replaced by a Param */
3427 {
3428 /* Make a copy of the Param for paranoia's sake */
3430 }
3431 /* If no match, just fall through to process it normally */
3432 }
3435 (AlternativeSubPlan *) node,
3436 context->num_exec),
3437 context);
3440}
References copyObject, elog, ERROR, expression_tree_mutator, fb(), find_minmax_agg_replacement_param(), fix_alternative_subplan(), fix_expr_common(), fix_param_node(), fix_upper_expr_mutator(), indexed_tlist::has_non_vars, indexed_tlist::has_ph_vars, IsA, fix_upper_expr_context::newvarno, fix_upper_expr_context::nrm_match, fix_upper_expr_context::num_exec, fix_upper_expr_context::root, fix_upper_expr_context::rtoffset, search_indexed_tlist_for_non_var(), search_indexed_tlist_for_phv(), search_indexed_tlist_for_var(), and fix_upper_expr_context::subplan_itlist.
Referenced by fix_upper_expr(), and fix_upper_expr_mutator().
◆ fix_windowagg_condition_expr()
|
static |
Definition at line 3545 of file setrefs.c.
3548{
3549 fix_windowagg_cond_context context;
3550
3552 context.subplan_itlist = subplan_itlist;
3553 context.newvarno = 0;
3554
3556 &context);
3557}
References fix_windowagg_condition_expr_mutator(), fix_windowagg_cond_context::newvarno, fix_windowagg_cond_context::root, root, and fix_windowagg_cond_context::subplan_itlist.
Referenced by set_windowagg_runcondition_references().
◆ fix_windowagg_condition_expr_mutator()
|
static |
Definition at line 3515 of file setrefs.c.
3517{
3520
3522 {
3524
3526 context->subplan_itlist,
3527 context->newvarno);
3531 }
3532
3535 context);
3536}
References elog, ERROR, expression_tree_mutator, fb(), fix_windowagg_condition_expr_mutator(), IsA, fix_windowagg_cond_context::newvarno, search_indexed_tlist_for_non_var(), and fix_windowagg_cond_context::subplan_itlist.
Referenced by fix_windowagg_condition_expr(), and fix_windowagg_condition_expr_mutator().
◆ flatten_rtes_walker()
|
static |
Definition at line 520 of file setrefs.c.
521{
523 return false;
525 {
527
528 /* As above, we need only save relation RTEs and former relations */
532 return false;
533 }
535 {
536 /*
537 * Recurse into subselects. Must update cxt->query to this query so
538 * that the rtable and rteperminfos correspond with each other.
539 */
541 bool result;
542
545 flatten_rtes_walker,
546 cxt,
547 QTW_EXAMINE_RTES_BEFORE);
549 return result;
550 }
552}
References add_rte_to_flat_rtable(), expression_tree_walker, fb(), flatten_rtes_walker(), flatten_rtes_walker_context::glob, IsA, OidIsValid, QTW_EXAMINE_RTES_BEFORE, flatten_rtes_walker_context::query, query_tree_walker, RTE_RELATION, and RTE_SUBQUERY.
Referenced by flatten_rtes_walker(), and flatten_unplanned_rtes().
◆ flatten_unplanned_rtes()
|
static |
Definition at line 508 of file setrefs.c.
509{
511
512 /* Use query_tree_walker to find all RTEs in the parse tree */
514 flatten_rtes_walker,
515 &cxt,
516 QTW_EXAMINE_RTES_BEFORE);
517}
References fb(), flatten_rtes_walker(), QTW_EXAMINE_RTES_BEFORE, and query_tree_walker.
Referenced by add_rtes_to_flat_rtable().
◆ offset_relid_set()
Definition at line 2058 of file setrefs.c.
2059{
2061 int rtindex;
2062
2063 /* If there's no offset to apply, we needn't recompute the value */
2064 if (rtoffset == 0)
2065 return relids;
2066 rtindex = -1;
2068 result = bms_add_member(result, rtindex + rtoffset);
2069 return result;
2070}
References bms_add_member(), bms_next_member(), and fb().
Referenced by register_partpruneinfo(), set_append_references(), set_customscan_references(), set_foreignscan_references(), set_mergeappend_references(), and set_plan_refs().
◆ record_elided_node()
|
static |
Definition at line 3815 of file setrefs.c.
3817{
3819
3820 n->plan_node_id = plan_node_id;
3821 n->elided_type = elided_type;
3822 n->relids = relids;
3823
3825}
References ElidedNode::elided_type, PlannerGlobal::elidedNodes, lappend(), makeNode, ElidedNode::plan_node_id, and ElidedNode::relids.
Referenced by set_append_references(), set_mergeappend_references(), and set_subqueryscan_references().
◆ record_plan_function_dependency()
| void record_plan_function_dependency | ( | PlannerInfo * | root, |
| Oid | funcid | ||
| ) |
Definition at line 3626 of file setrefs.c.
3627{
3628 /*
3629 * For performance reasons, we don't bother to track built-in functions;
3630 * we just assume they'll never change (or at least not in ways that'd
3631 * invalidate plans using them). For this purpose we can consider a
3632 * built-in function to be one with OID less than FirstUnpinnedObjectId.
3633 * Note that the OID generator guarantees never to generate such an OID
3634 * after startup, even at OID wraparound.
3635 */
3637 {
3639
3640 /*
3641 * It would work to use any syscache on pg_proc, but the easiest is
3642 * PROCOID since we already have the function's OID at hand. Note
3643 * that plancache.c knows we use PROCOID.
3644 */
3647 ObjectIdGetDatum(funcid));
3648
3650 }
3651}
References fb(), FirstUnpinnedObjectId, GetSysCacheHashValue1, lappend(), makeNode, ObjectIdGetDatum(), and root.
Referenced by fix_expr_common(), inline_function(), and inline_function_in_from().
◆ record_plan_type_dependency()
| void record_plan_type_dependency | ( | PlannerInfo * | root, |
| Oid | typid | ||
| ) |
Definition at line 3666 of file setrefs.c.
3667{
3668 /*
3669 * As in record_plan_function_dependency, ignore the possibility that
3670 * someone would change a built-in domain.
3671 */
3673 {
3675
3676 /*
3677 * It would work to use any syscache on pg_type, but the easiest is
3678 * TYPEOID since we already have the type's OID at hand. Note that
3679 * plancache.c knows we use TYPEOID.
3680 */
3683 ObjectIdGetDatum(typid));
3684
3686 }
3687}
References fb(), FirstUnpinnedObjectId, GetSysCacheHashValue1, lappend(), makeNode, ObjectIdGetDatum(), and root.
Referenced by eval_const_expressions_mutator().
◆ register_partpruneinfo()
|
static |
Definition at line 1812 of file setrefs.c.
1813{
1815 PartitionPruneInfo *pinfo;
1816 ListCell *l;
1817
1818 Assert(part_prune_index >= 0 &&
1821 part_prune_index);
1822
1825 {
1827 ListCell *l2;
1828
1829 foreach(l2, prune_infos)
1830 {
1833
1834 prelinfo->rtindex += rtoffset;
1835 prelinfo->initial_pruning_steps =
1837 rtoffset, 1);
1838 prelinfo->exec_pruning_steps =
1840 rtoffset, 1);
1841
1843 {
1844 /*
1845 * Non-leaf partitions and partitions that do not have a
1846 * subplan are not included in this map as mentioned in
1847 * make_partitionedrel_pruneinfo().
1848 */
1850 {
1855 }
1856 }
1857 }
1858 }
1859
1861
1863}
References Assert, bms_add_member(), fb(), fix_scan_list, i, lappend(), lfirst, list_length(), list_nth_node, offset_relid_set(), PlannerGlobal::partPruneInfos, PlannerGlobal::prunableRelids, PartitionPruneInfo::prune_infos, PartitionPruneInfo::relids, and root.
Referenced by set_append_references(), and set_mergeappend_references().
◆ search_indexed_tlist_for_non_var()
|
static |
Definition at line 3058 of file setrefs.c.
3060{
3062
3063 /*
3064 * If it's a simple Const, replacing it with a Var is silly, even if there
3065 * happens to be an identical Const below; a Var is more expensive to
3066 * execute than a Const. What's more, replacing it could confuse some
3067 * places in the executor that expect to see simple Consts for, eg,
3068 * dropped columns.
3069 */
3072
3075 {
3076 /* Found a matching subplan output expression */
3078
3081 newvar->varattnosyn = 0;
3083 }
3085}
References fb(), IsA, makeVarFromTargetEntry(), and tlist_member().
Referenced by fix_join_expr_mutator(), fix_upper_expr_mutator(), and fix_windowagg_condition_expr_mutator().
◆ search_indexed_tlist_for_phv()
|
static |
Definition at line 3005 of file setrefs.c.
3008{
3010
3012 {
3014
3016 {
3019
3020 /*
3021 * Analogously to search_indexed_tlist_for_var, we match on phid
3022 * only. We don't use equal(), partially for speed but mostly
3023 * because phnullingrels might not be exactly equal.
3024 */
3026 continue;
3027
3028 /* Verify that we kept all the nullingrels machinations straight */
3031 nrm_match == NRM_SUPERSET ?
3037 phv->phid);
3038
3039 /* Found a matching subplan output expression */
3042 newvar->varattnosyn = 0;
3044 }
3045 }
3047}
References bms_equal(), bms_is_subset(), bmsToString(), elog, ERROR, fb(), IsA, lfirst, makeVarFromTargetEntry(), NRM_SUBSET, and NRM_SUPERSET.
Referenced by fix_join_expr_mutator(), and fix_upper_expr_mutator().
◆ search_indexed_tlist_for_sortgroupref()
|
static |
Definition at line 3098 of file setrefs.c.
3102{
3104
3106 {
3108
3109 /*
3110 * Usually the equal() check is redundant, but in setop plans it may
3111 * not be, since prepunion.c assigns ressortgroupref equal to the
3112 * column resno without regard to whether that matches the topmost
3113 * level's sortgrouprefs and without regard to whether any implicit
3114 * coercions are added in the setop tree. We might have to clean that
3115 * up someday; but for now, just ignore any false matches.
3116 */
3119 {
3120 /* Found a matching subplan output expression */
3122
3125 newvar->varattnosyn = 0;
3127 }
3128 }
3130}
References equal(), fb(), lfirst, and makeVarFromTargetEntry().
Referenced by set_upper_references().
◆ search_indexed_tlist_for_var()
|
static |
Definition at line 2940 of file setrefs.c.
2943{
2948
2952 {
2954 {
2955 /* Found a match */
2957
2958 /*
2959 * Verify that we kept all the nullingrels machinations straight.
2960 *
2961 * XXX we skip the check for system columns and whole-row Vars.
2962 * That's because such Vars might be row identity Vars, which are
2963 * generated without any varnullingrels. It'd be hard to do
2964 * otherwise, since they're normally made very early in planning,
2965 * when we haven't looked at the jointree yet and don't know which
2966 * joins might null such Vars. Doesn't seem worth the expense to
2967 * make them fully valid. (While it's slightly annoying that we
2968 * thereby lose checking for user-written references to such
2969 * columns, it seems unlikely that a bug in nullingrels logic
2970 * would affect only system columns.)
2971 */
2972 if (!(varattno <= 0 ||
2973 (nrm_match == NRM_SUBSET ?
2975 nrm_match == NRM_SUPERSET ?
2979 bmsToString(var->varnullingrels),
2981 varno, varattno);
2982
2983 newvar->varno = newvarno;
2986 newvar->varnosyn += rtoffset;
2988 }
2989 vinfo++;
2990 }
2992}
References bms_equal(), bms_is_subset(), bmsToString(), copyVar(), elog, ERROR, fb(), i, NRM_SUBSET, NRM_SUPERSET, Var::varattno, and Var::varno.
Referenced by fix_join_expr_mutator(), and fix_upper_expr_mutator().
◆ set_append_references()
|
static |
Definition at line 1873 of file setrefs.c.
1876{
1877 ListCell *l;
1878
1879 /*
1880 * Append, like Sort et al, doesn't actually evaluate its targetlist or
1881 * check quals. If it's got exactly one child plan, then it's not doing
1882 * anything useful at all, and we can strip it out.
1883 */
1885
1886 /* First, we gotta recurse on the children */
1888 {
1890 }
1891
1892 /*
1893 * See if it's safe to get rid of the Append entirely. For this to be
1894 * safe, there must be only one child plan and that child plan's parallel
1895 * awareness must match the Append's. The reason for the latter is that
1896 * if the Append is parallel aware and the child is not, then the calling
1897 * plan may execute the non-parallel aware child multiple times. (If you
1898 * change these rules, update create_append_path to match.)
1899 */
1901 {
1903
1905 {
1906 Plan *result;
1907
1909
1910 /* Remember that we removed an Append */
1913
1914 return result;
1915 }
1916 }
1917
1918 /*
1919 * Otherwise, clean up the Append as needed. It's okay to do this after
1920 * recursing to the children, because set_dummy_tlist_references doesn't
1921 * look at those.
1922 */
1924
1926
1927 /*
1928 * Add PartitionPruneInfo, if any, to PlannerGlobal and update the index.
1929 * Also update the RT indexes present in it to add the offset.
1930 */
1932 aplan->part_prune_index =
1934
1935 /* We don't need to recurse to lefttree or righttree ... */
1938
1940}
References Assert, clean_up_removed_plan_level(), fb(), lfirst, linitial, list_length(), NIL, offset_relid_set(), Plan::parallel_aware, Plan::plan_node_id, record_elided_node(), register_partpruneinfo(), root, set_dummy_tlist_references(), and set_plan_refs().
Referenced by set_plan_refs().
◆ set_customscan_references()
|
static |
Definition at line 1729 of file setrefs.c.
1732{
1734
1735 /* Adjust scanrelid if it's valid */
1737 cscan->scan.scanrelid += rtoffset;
1738
1740 {
1741 /* Adjust tlist, qual, custom_exprs to reference custom scan tuple */
1743
1747 itlist,
1748 INDEX_VAR,
1749 rtoffset,
1750 NRM_EQUAL,
1755 itlist,
1756 INDEX_VAR,
1757 rtoffset,
1758 NRM_EQUAL,
1763 itlist,
1764 INDEX_VAR,
1765 rtoffset,
1766 NRM_EQUAL,
1769 /* custom_scan_tlist itself just needs fix_scan_list() adjustments */
1770 cscan->custom_scan_tlist =
1773 }
1774 else
1775 {
1776 /* Adjust tlist, qual, custom_exprs in the standard way */
1777 cscan->scan.plan.targetlist =
1780 cscan->scan.plan.qual =
1783 cscan->custom_exprs =
1786 }
1787
1788 /* Adjust child plan-nodes recursively, if needed */
1790 {
1792 }
1793
1795}
References build_tlist_index(), fb(), fix_scan_list, fix_upper_expr(), INDEX_VAR, lfirst, NIL, NRM_EQUAL, NUM_EXEC_QUAL, NUM_EXEC_TLIST, offset_relid_set(), pfree(), root, and set_plan_refs().
Referenced by set_plan_refs().
◆ set_dummy_tlist_references()
Definition at line 2764 of file setrefs.c.
2765{
2767 ListCell *l;
2768
2771 {
2775
2776 /*
2777 * As in search_indexed_tlist_for_non_var(), we prefer to keep Consts
2778 * as Consts, not Vars referencing Consts. Here, there's no speed
2779 * advantage to be had, but it makes EXPLAIN output look cleaner, and
2780 * again it avoids confusing the executor.
2781 */
2783 {
2784 /* just reuse the existing TLE node */
2786 continue;
2787 }
2788
2790 tle->resno,
2794 0);
2796 oldvar->varnosyn > 0)
2797 {
2800 }
2801 else
2802 {
2804 newvar->varattnosyn = 0;
2805 }
2806
2810 }
2812
2813 /* We don't touch plan->qual here */
2814}
References exprCollation(), exprType(), exprTypmod(), fb(), flatCopyTargetEntry(), IsA, lappend(), lfirst, makeVar(), NIL, OUTER_VAR, and plan.
Referenced by set_append_references(), set_hash_references(), set_mergeappend_references(), and set_plan_refs().
◆ set_foreignscan_references()
|
static |
Definition at line 1642 of file setrefs.c.
1645{
1646 /* Adjust scanrelid if it's valid */
1648 fscan->scan.scanrelid += rtoffset;
1649
1651 {
1652 /*
1653 * Adjust tlist, qual, fdw_exprs, fdw_recheck_quals to reference
1654 * foreign scan tuple
1655 */
1657
1661 itlist,
1662 INDEX_VAR,
1663 rtoffset,
1664 NRM_EQUAL,
1669 itlist,
1670 INDEX_VAR,
1671 rtoffset,
1672 NRM_EQUAL,
1677 itlist,
1678 INDEX_VAR,
1679 rtoffset,
1680 NRM_EQUAL,
1685 itlist,
1686 INDEX_VAR,
1687 rtoffset,
1688 NRM_EQUAL,
1691 /* fdw_scan_tlist itself just needs fix_scan_list() adjustments */
1692 fscan->fdw_scan_tlist =
1695 }
1696 else
1697 {
1698 /*
1699 * Adjust tlist, qual, fdw_exprs, fdw_recheck_quals in the standard
1700 * way
1701 */
1702 fscan->scan.plan.targetlist =
1705 fscan->scan.plan.qual =
1708 fscan->fdw_exprs =
1711 fscan->fdw_recheck_quals =
1714 }
1715
1718
1719 /* Adjust resultRelation if it's valid */
1721 fscan->resultRelation += rtoffset;
1722}
References build_tlist_index(), fb(), fix_scan_list, fix_upper_expr(), INDEX_VAR, NIL, NRM_EQUAL, NUM_EXEC_QUAL, NUM_EXEC_TLIST, offset_relid_set(), pfree(), and root.
Referenced by set_plan_refs().
◆ set_hash_references()
|
static |
Definition at line 2025 of file setrefs.c.
2026{
2029 indexed_tlist *outer_itlist;
2030
2031 /*
2032 * Hash's hashkeys are used when feeding tuples into the hashtable,
2033 * therefore have them reference Hash's outer plan (which itself is the
2034 * inner plan of the HashJoin).
2035 */
2040 outer_itlist,
2041 OUTER_VAR,
2042 rtoffset,
2043 NRM_EQUAL,
2045
2046 /* Hash doesn't project */
2048
2049 /* Hash nodes don't have their own quals */
2051}
References Assert, build_tlist_index(), fb(), fix_upper_expr(), Plan::lefttree, NIL, NRM_EQUAL, NUM_EXEC_QUAL, OUTER_VAR, plan, root, set_dummy_tlist_references(), and Plan::targetlist.
Referenced by set_plan_refs().
◆ set_indexonlyscan_references()
|
static |
Definition at line 1378 of file setrefs.c.
1381{
1385
1386 /*
1387 * Vars in the plan node's targetlist, qual, and recheckqual must only
1388 * reference columns that the index AM can actually return. To ensure
1389 * this, remove non-returnable columns (which are marked as resjunk) from
1390 * the indexed tlist. We can just drop them because the indexed_tlist
1391 * machinery pays attention to TLE resnos, not physical list position.
1392 */
1395 {
1397
1400 }
1401
1403
1404 plan->scan.scanrelid += rtoffset;
1408 index_itlist,
1409 INDEX_VAR,
1410 rtoffset,
1411 NRM_EQUAL,
1416 index_itlist,
1417 INDEX_VAR,
1418 rtoffset,
1419 NRM_EQUAL,
1424 index_itlist,
1425 INDEX_VAR,
1426 rtoffset,
1427 NRM_EQUAL,
1429 /* indexqual is already transformed to reference index columns */
1431 rtoffset, 1);
1432 /* indexorderby is already transformed to reference index columns */
1434 rtoffset, 1);
1435 /* indextlist must NOT be transformed to reference index columns */
1438
1440
1442}
References build_tlist_index(), fb(), fix_scan_list, fix_upper_expr(), INDEX_VAR, lappend(), lfirst, NIL, NRM_EQUAL, NUM_EXEC_QUAL, NUM_EXEC_TLIST, pfree(), plan, and root.
Referenced by set_plan_refs().
◆ set_join_references()
|
static |
Definition at line 2404 of file setrefs.c.
2405{
2406 Plan *outer_plan = join->plan.lefttree;
2407 Plan *inner_plan = join->plan.righttree;
2408 indexed_tlist *outer_itlist;
2409 indexed_tlist *inner_itlist;
2410
2413
2414 /*
2415 * First process the joinquals (including merge or hash clauses). These
2416 * are logically below the join so they can always use all values
2417 * available from the input tlists. It's okay to also handle
2418 * NestLoopParams now, because those couldn't refer to nullable
2419 * subexpressions.
2420 */
2422 join->joinqual,
2423 outer_itlist,
2424 inner_itlist,
2425 (Index) 0,
2426 rtoffset,
2427 NRM_EQUAL,
2429
2430 /* Now do join-type-specific stuff */
2432 {
2435
2437 {
2439
2440 /*
2441 * Because we don't reparameterize parameterized paths to match
2442 * the outer-join level at which they are used, Vars seen in the
2443 * NestLoopParam expression may have nullingrels that are just a
2444 * subset of those in the Vars actually available from the outer
2445 * side. (Lateral references can also cause this, as explained in
2446 * the comments for identify_current_nestloop_params.) Not
2447 * checking this exactly is a bit grotty, but the work needed to
2448 * make things match up perfectly seems well out of proportion to
2449 * the value.
2450 */
2453 outer_itlist,
2454 OUTER_VAR,
2455 rtoffset,
2456 NRM_SUBSET,
2457 NUM_EXEC_TLIST(outer_plan));
2458 /* Check we replaced any PlaceHolderVar with simple Var */
2462 }
2463 }
2465 {
2467
2469 mj->mergeclauses,
2470 outer_itlist,
2471 inner_itlist,
2472 (Index) 0,
2473 rtoffset,
2474 NRM_EQUAL,
2476 }
2478 {
2480
2482 hj->hashclauses,
2483 outer_itlist,
2484 inner_itlist,
2485 (Index) 0,
2486 rtoffset,
2487 NRM_EQUAL,
2489
2490 /*
2491 * HashJoin's hashkeys are used to look for matching tuples from its
2492 * outer plan (not the Hash node!) in the hashtable.
2493 */
2496 outer_itlist,
2497 OUTER_VAR,
2498 rtoffset,
2499 NRM_EQUAL,
2501 }
2502
2503 /*
2504 * Now we need to fix up the targetlist and qpqual, which are logically
2505 * above the join. This means that, if it's not an inner join, any Vars
2506 * and PHVs appearing here should have nullingrels that include the
2507 * effects of the outer join, ie they will have nullingrels equal to the
2508 * input Vars' nullingrels plus the bit added by the outer join. We don't
2509 * currently have enough info available here to identify what that should
2510 * be, so we just tell fix_join_expr to accept superset nullingrels
2511 * matches instead of exact ones.
2512 */
2514 join->plan.targetlist,
2515 outer_itlist,
2516 inner_itlist,
2517 (Index) 0,
2518 rtoffset,
2522 join->plan.qual,
2523 outer_itlist,
2524 inner_itlist,
2525 (Index) 0,
2526 rtoffset,
2529
2530 pfree(outer_itlist);
2531 pfree(inner_itlist);
2532}
References build_tlist_index(), elog, ERROR, fb(), fix_join_expr(), fix_upper_expr(), IsA, JOIN_INNER, Join::joinqual, Join::jointype, lfirst, NRM_EQUAL, NRM_SUBSET, NRM_SUPERSET, NUM_EXEC_QUAL, NUM_EXEC_TLIST, OUTER_VAR, NestLoopParam::paramval, pfree(), root, and Plan::targetlist.
Referenced by set_plan_refs().
◆ set_mergeappend_references()
|
static |
Definition at line 1950 of file setrefs.c.
1953{
1954 ListCell *l;
1955
1956 /*
1957 * MergeAppend, like Sort et al, doesn't actually evaluate its targetlist
1958 * or check quals. If it's got exactly one child plan, then it's not
1959 * doing anything useful at all, and we can strip it out.
1960 */
1962
1963 /* First, we gotta recurse on the children */
1965 {
1967 }
1968
1969 /*
1970 * See if it's safe to get rid of the MergeAppend entirely. For this to
1971 * be safe, there must be only one child plan and that child plan's
1972 * parallel awareness must match the MergeAppend's. The reason for the
1973 * latter is that if the MergeAppend is parallel aware and the child is
1974 * not, then the calling plan may execute the non-parallel aware child
1975 * multiple times. (If you change these rules, update
1976 * create_merge_append_path to match.)
1977 */
1979 {
1981
1983 {
1984 Plan *result;
1985
1987
1988 /* Remember that we removed a MergeAppend */
1991
1992 return result;
1993 }
1994 }
1995
1996 /*
1997 * Otherwise, clean up the MergeAppend as needed. It's okay to do this
1998 * after recursing to the children, because set_dummy_tlist_references
1999 * doesn't look at those.
2000 */
2002
2004
2005 /*
2006 * Add PartitionPruneInfo, if any, to PlannerGlobal and update the index.
2007 * Also update the RT indexes present in it to add the offset.
2008 */
2010 mplan->part_prune_index =
2012
2013 /* We don't need to recurse to lefttree or righttree ... */
2016
2018}
References Assert, clean_up_removed_plan_level(), fb(), lfirst, linitial, list_length(), NIL, offset_relid_set(), Plan::parallel_aware, Plan::plan_node_id, record_elided_node(), register_partpruneinfo(), root, set_dummy_tlist_references(), and set_plan_refs().
Referenced by set_plan_refs().
◆ set_param_references()
|
static |
Definition at line 2641 of file setrefs.c.
2642{
2644
2646 {
2649 ListCell *l;
2650
2652 {
2654 {
2656 ListCell *l2;
2657
2659 {
2661 }
2662 }
2663 }
2664
2665 /*
2666 * Remember the list of all external initplan params that are used by
2667 * the children of Gather or Gather merge node.
2668 */
2672 else
2675 }
2676}
References Assert, bms_add_member(), bms_intersect(), fb(), IsA, lfirst, lfirst_int, plan, and root.
Referenced by set_plan_refs().
◆ set_plan_references()
| Plan * set_plan_references | ( | PlannerInfo * | root, |
| Plan * | plan | ||
| ) |
Definition at line 291 of file setrefs.c.
292{
293 Plan *result;
297
298 /*
299 * Add all the query's RTEs to the flattened rangetable. The live ones
300 * will have their rangetable indexes increased by rtoffset. (Additional
301 * RTEs, not referenced by the Plan tree, might get added after those.)
302 */
304
305 /*
306 * Adjust RT indexes of PlanRowMarks and add to final rowmarks list
307 */
309 {
312
313 /* sanity check on existing row marks */
316
317 /* flat copy is enough since all fields are scalars */
320
321 /* adjust indexes ... but *not* the rowmarkId */
322 newrc->rti += rtoffset;
323 newrc->prti += rtoffset;
324
326 }
327
328 /*
329 * Adjust RT indexes of AppendRelInfos and add to final appendrels list.
330 * We assume the AppendRelInfos were built during planning and don't need
331 * to be copied.
332 */
334 {
336
337 /* adjust RT indexes */
338 appinfo->parent_relid += rtoffset;
339 appinfo->child_relid += rtoffset;
340
341 /*
342 * Rather than adjust the translated_vars entries, just drop 'em.
343 * Neither the executor nor EXPLAIN currently need that data.
344 */
346
348 }
349
350 /* If needed, create workspace for processing AlternativeSubPlans */
352 {
357 }
358
359 /* Now fix the Plan tree */
361
362 /*
363 * If we have AlternativeSubPlans, it is likely that we now have some
364 * unreferenced subplans in glob->subplans. To avoid expending cycles on
365 * those subplans later, get rid of them by setting those list entries to
366 * NULL. (Note: we can't do this immediately upon processing an
367 * AlternativeSubPlan, because there may be multiple copies of the
368 * AlternativeSubPlan, and they can get resolved differently.)
369 */
371 {
373 {
375
376 /*
377 * If it was used by some AlternativeSubPlan in this query level,
378 * but wasn't selected as best by any AlternativeSubPlan, then we
379 * don't need it. Do not touch subplans that aren't parts of
380 * AlternativeSubPlans.
381 */
384 }
385 }
386
387 return result;
388}
References add_rtes_to_flat_rtable(), PlannerGlobal::appendRelations, Assert, fb(), PlannerGlobal::finalrowmarks, PlannerGlobal::finalrtable, foreach_current_index, lappend(), lfirst, lfirst_node, list_length(), NIL, palloc0(), palloc_object, plan, root, PlanRowMark::rti, set_plan_refs(), and PlannerGlobal::subplans.
Referenced by set_subqueryscan_references(), and standard_planner().
◆ set_plan_refs()
|
static |
Definition at line 642 of file setrefs.c.
643{
644 ListCell *l;
645
648
649 /* Assign this node a unique ID. */
651
652 /*
653 * Plan-type-specific fixes
654 */
656 {
658 {
660
662 splan->scan.plan.targetlist =
665 splan->scan.plan.qual =
668 }
669 break;
671 {
673
675 splan->scan.plan.targetlist =
678 splan->scan.plan.qual =
683 rtoffset, 1);
684 }
685 break;
687 {
689
691 splan->scan.plan.targetlist =
694 splan->scan.plan.qual =
697 splan->indexqual =
699 rtoffset, 1);
700 splan->indexqualorig =
703 splan->indexorderby =
705 rtoffset, 1);
706 splan->indexorderbyorig =
709 }
710 break;
712 {
714
716 }
717 break;
719 {
721
723 /* no need to fix targetlist and qual */
726 splan->indexqual =
728 splan->indexqualorig =
731 }
732 break;
734 {
736
738 splan->scan.plan.targetlist =
741 splan->scan.plan.qual =
744 splan->bitmapqualorig =
747 }
748 break;
750 {
752
754 splan->scan.plan.targetlist =
757 splan->scan.plan.qual =
760 splan->tidquals =
762 rtoffset, 1);
763 }
764 break;
766 {
768
770 splan->scan.plan.targetlist =
773 splan->scan.plan.qual =
776 splan->tidrangequals =
778 rtoffset, 1);
779 }
780 break;
782 /* Needs special treatment, see comments below */
785 rtoffset);
787 {
789
791 splan->scan.plan.targetlist =
794 splan->scan.plan.qual =
797 splan->functions =
799 }
800 break;
802 {
804
806 splan->scan.plan.targetlist =
809 splan->scan.plan.qual =
814 rtoffset, 1);
815 }
816 break;
818 {
820
822 splan->scan.plan.targetlist =
825 splan->scan.plan.qual =
828 splan->values_lists =
830 rtoffset, 1);
831 }
832 break;
834 {
836
838 splan->scan.plan.targetlist =
841 splan->scan.plan.qual =
844 }
845 break;
847 {
849
851 splan->scan.plan.targetlist =
854 splan->scan.plan.qual =
857 }
858 break;
860 {
862
864 splan->scan.plan.targetlist =
867 splan->scan.plan.qual =
870 }
871 break;
874 break;
877 break;
878
883 break;
884
887 {
890 }
891 break;
892
895 break;
896
898 {
900
901 /*
902 * Memoize does not evaluate its targetlist. It just uses the
903 * same targetlist from its outer subnode.
904 */
906
908 rtoffset,
910 break;
911 }
912
918
919 /*
920 * These plan types don't actually bother to evaluate their
921 * targetlists, because they just return their unmodified input
922 * tuples. Even though the targetlist won't be used by the
923 * executor, we fix it up for possible use by EXPLAIN (not to
924 * mention ease of debugging --- wrong varnos are very confusing).
925 */
927
928 /*
929 * Since these plan types don't check quals either, we should not
930 * find any qual expression attached to them.
931 */
933 break;
935 {
937
938 /*
939 * Like the plan types above, LockRows doesn't evaluate its
940 * tlist or quals. But we have to fix up the RT indexes in
941 * its rowmarks.
942 */
945
947 {
949
950 rc->rti += rtoffset;
951 rc->prti += rtoffset;
952 }
953 }
954 break;
956 {
958
959 /*
960 * Like the plan types above, Limit doesn't evaluate its tlist
961 * or quals. It does have live expressions for limit/offset,
962 * however; and those cannot contain subplan variable refs, so
963 * fix_scan_expr works for them.
964 */
967
968 splan->limitOffset =
970 splan->limitCount =
972 }
973 break;
975 {
977
978 /*
979 * If this node is combining partial-aggregation results, we
980 * must convert its Aggrefs to contain references to the
981 * partial-aggregate subexpressions that will be available
982 * from the child plan node.
983 */
985 {
988 NULL);
991 NULL);
992 }
993
995 }
996 break;
999 break;
1001 {
1003
1004 /*
1005 * Adjust the WindowAgg's run conditions by swapping the
1006 * WindowFuncs references out to instead reference the Var in
1007 * the scan slot so that when the executor evaluates the
1008 * runCondition, it receives the WindowFunc's value from the
1009 * slot that the result has just been stored into rather than
1010 * evaluating the WindowFunc all over again.
1011 */
1013 wplan->runCondition,
1015
1017
1018 /*
1019 * Like Limit node limit/offset expressions, WindowAgg has
1020 * frame offset expressions, which cannot contain subplan
1021 * variable refs, so fix_scan_expr works for them.
1022 */
1023 wplan->startOffset =
1025 wplan->endOffset =
1028 wplan->runCondition,
1029 rtoffset,
1032 wplan->runConditionOrig,
1033 rtoffset,
1035 }
1036 break;
1038 {
1040
1041 /*
1042 * Result may or may not have a subplan; if not, it's more
1043 * like a scan node than an upper node.
1044 */
1047 else
1048 {
1049 /*
1050 * The tlist of a childless Result could contain
1051 * unresolved ROWID_VAR Vars, in case it's representing a
1052 * target relation which is completely empty because of
1053 * constraint exclusion. Replace any such Vars by null
1054 * constants, as though they'd been resolved for a leaf
1055 * scan node that doesn't support them. We could have
1056 * fix_scan_expr do this, but since the case is only
1057 * expected to occur here, it seems safer to special-case
1058 * it here and keep the assertions that ROWID_VARs
1059 * shouldn't be seen by fix_scan_expr.
1060 *
1061 * We also must handle the case where set operations have
1062 * been short-circuited resulting in a dummy Result node.
1063 * prepunion.c uses varno==0 for the set op targetlist.
1064 * See generate_setop_tlist() and generate_setop_tlist().
1065 * Here we rewrite these to use varno==1, which is the
1066 * varno of the first set-op child. Without this, EXPLAIN
1067 * will have trouble displaying targetlists of dummy set
1068 * operations.
1069 */
1071 {
1074
1076 {
1079 var->vartypmod,
1080 var->varcollid);
1081 else if (var->varno == 0)
1083 var->varattno,
1084 var->vartype,
1085 var->vartypmod,
1086 var->varcollid,
1087 var->varlevelsup);
1088 }
1089 }
1090
1097 }
1098 /* resconstantqual can't contain any subplan variable refs */
1099 splan->resconstantqual =
1101 /* adjust the relids set */
1103 }
1104 break;
1107 break;
1109 {
1112
1115
1116 splan->withCheckOptionLists =
1118 rtoffset, 1);
1119
1121 {
1124 *lcrr;
1125
1126 /*
1127 * Pass each per-resultrel returningList through
1128 * set_returning_clause_references().
1129 */
1133 {
1136
1138 rlist,
1139 subplan,
1140 resultrel,
1141 rtoffset);
1143 }
1145
1146 /*
1147 * Set up the visible plan targetlist as being the same as
1148 * the first RETURNING list. This is mostly for the use
1149 * of EXPLAIN; the executor won't execute that targetlist,
1150 * although it does use it to prepare the node's result
1151 * tuple slot. We postpone this step until here so that
1152 * we don't have to do set_returning_clause_references()
1153 * twice on identical targetlists.
1154 */
1156 }
1157
1158 /*
1159 * We treat ModifyTable with ON CONFLICT as a form of 'pseudo
1160 * join', where the inner side is the EXCLUDED tuple.
1161 * Therefore use fix_join_expr to setup the relevant variables
1162 * to INNER_VAR. We explicitly don't create any OUTER_VARs as
1163 * those are already used by RETURNING and it seems better to
1164 * be non-conflicting.
1165 */
1168 {
1170
1172
1173 splan->onConflictSet =
1178
1184
1186
1187 splan->exclRelTlist =
1189 }
1190
1191 /*
1192 * The MERGE statement produces the target rows by performing
1193 * a right join between the target relation and the source
1194 * relation (which could be a plain relation or a subquery).
1195 * The INSERT and UPDATE actions of the MERGE statement
1196 * require access to the columns from the source relation. We
1197 * arrange things so that the source relation attributes are
1198 * available as INNER_VAR and the target relation attributes
1199 * are available from the scan tuple.
1200 */
1202 {
1205 *lcj,
1206 *lcr;
1207
1208 /*
1209 * Fix the targetList of individual action nodes so that
1210 * the so-called "source relation" Vars are referenced as
1211 * INNER_VAR. Note that for this to work correctly during
1212 * execution, the ecxt_innertuple must be set to the tuple
1213 * obtained by executing the subplan, which is what
1214 * constitutes the "source relation".
1215 *
1216 * We leave the Vars from the result relation (i.e. the
1217 * target relation) unchanged i.e. those Vars would be
1218 * picked from the scan slot. So during execution, we must
1219 * ensure that ecxt_scantuple is setup correctly to refer
1220 * to the tuple from the target relation.
1221 */
1223
1225
1229 {
1233
1234 foreach(l, mergeActionList)
1235 {
1237
1238 /* Fix targetList of each action. */
1240 action->targetList,
1242 resultrel,
1243 rtoffset,
1244 NRM_EQUAL,
1246
1247 /* Fix quals too. */
1251 resultrel,
1252 rtoffset,
1253 NRM_EQUAL,
1255 }
1256
1257 /* Fix join condition too. */
1258 mergeJoinCondition = (Node *)
1260 (List *) mergeJoinCondition,
1262 resultrel,
1263 rtoffset,
1264 NRM_EQUAL,
1267 }
1269 }
1270
1271 splan->nominalRelation += rtoffset;
1273 splan->rootRelation += rtoffset;
1274 splan->exclRelRTI += rtoffset;
1275
1277 {
1278 lfirst_int(l) += rtoffset;
1279 }
1281 {
1283
1284 rc->rti += rtoffset;
1285 rc->prti += rtoffset;
1286 }
1287
1288 /*
1289 * Append this ModifyTable node's final result relation RT
1290 * index(es) to the global list for the plan.
1291 */
1292 root->glob->resultRelations =
1294 splan->resultRelations);
1296 {
1297 root->glob->resultRelations =
1299 splan->rootRelation);
1300 }
1301 }
1302 break;
1304 /* Needs special treatment, see comments below */
1307 rtoffset);
1309 /* Needs special treatment, see comments below */
1312 rtoffset);
1314 /* This doesn't evaluate targetlist or check quals either */
1317 break;
1319 {
1321
1322 /* BitmapAnd works like Append, but has no tlist */
1326 {
1329 rtoffset);
1330 }
1331 }
1332 break;
1334 {
1336
1337 /* BitmapOr works like Append, but has no tlist */
1341 {
1344 rtoffset);
1345 }
1346 }
1347 break;
1348 default:
1351 break;
1352 }
1353
1354 /*
1355 * Now recurse into child plans, if any
1356 *
1357 * NOTE: it is essential that we recurse into child plans AFTER we set
1358 * subplan references in this plan's tlist and quals. If we did the
1359 * reference-adjustments bottom-up, then we would fail to match this
1360 * plan's var nodes against the already-modified nodes of the children.
1361 */
1364
1366}
References Assert, BitmapAnd::bitmapplans, BitmapOr::bitmapplans, BitmapHeapScan::bitmapqualorig, build_tlist_index(), convert_combining_aggrefs(), copyObject, DO_AGGSPLIT_COMBINE, elog, ERROR, ModifyTable::exclRelRTI, ModifyTable::exclRelTlist, fb(), fix_join_expr(), fix_scan_expr(), fix_scan_list, forboth, forthree, FunctionScan::functions, IndexScan::indexorderby, IndexScan::indexorderbyorig, IndexScan::indexqual, BitmapIndexScan::indexqual, IndexScan::indexqualorig, BitmapIndexScan::indexqualorig, IsA, lappend(), lappend_int(), lca(), Plan::lefttree, lfirst, lfirst_int, Limit::limitCount, Limit::limitOffset, linitial, linitial_int, list_concat(), list_length(), makeNullConst(), makeVar(), ModifyTable::mergeActionLists, ModifyTable::mergeJoinConditions, NIL, nodeTag, ModifyTable::nominalRelation, NRM_EQUAL, NUM_EXEC_QUAL, NUM_EXEC_TLIST, offset_relid_set(), ONCONFLICT_SELECT, ONCONFLICT_UPDATE, ModifyTable::onConflictAction, ModifyTable::onConflictSet, ModifyTable::onConflictWhere, outerPlan, pfree(), Result::plan, ModifyTable::plan, BitmapAnd::plan, BitmapOr::plan, LockRows::plan, Limit::plan, plan, PlanRowMark::prti, Plan::qual, Result::relids, Result::resconstantqual, ModifyTable::resultRelations, ModifyTable::returningLists, root, ModifyTable::rootRelation, ROWID_VAR, ModifyTable::rowMarks, LockRows::rowMarks, PlanRowMark::rti, WindowAgg::runCondition, SeqScan::scan, SampleScan::scan, IndexScan::scan, BitmapIndexScan::scan, BitmapHeapScan::scan, TidScan::scan, TidRangeScan::scan, FunctionScan::scan, ValuesScan::scan, TableFuncScan::scan, CteScan::scan, NamedTuplestoreScan::scan, WorkTableScan::scan, Scan::scanrelid, set_append_references(), set_customscan_references(), set_dummy_tlist_references(), set_foreignscan_references(), set_hash_references(), set_indexonlyscan_references(), set_join_references(), set_mergeappend_references(), set_param_references(), set_plan_refs(), set_returning_clause_references(), set_subqueryscan_references(), set_upper_references(), set_windowagg_runcondition_references(), TableFuncScan::tablefunc, SampleScan::tablesample, Plan::targetlist, TidScan::tidquals, TidRangeScan::tidrangequals, ValuesScan::values_lists, Var::varattno, Var::varlevelsup, Var::varno, and ModifyTable::withCheckOptionLists.
Referenced by set_append_references(), set_customscan_references(), set_mergeappend_references(), set_plan_references(), and set_plan_refs().
◆ set_returning_clause_references()
|
static |
Definition at line 3471 of file setrefs.c.
3476{
3478
3479 /*
3480 * We can perform the desired Var fixup by abusing the fix_join_expr
3481 * machinery that formerly handled inner indexscan fixup. We search the
3482 * top plan's targetlist for Vars of non-result relations, and use
3483 * fix_join_expr to convert RETURNING Vars into references to those tlist
3484 * entries, while leaving result-rel Vars as-is.
3485 *
3486 * PlaceHolderVars will also be sought in the targetlist, but no
3487 * more-complex expressions will be. Note that it is not possible for a
3488 * PlaceHolderVar to refer to the result relation, since the result is
3489 * never below an outer join. If that case could happen, we'd have to be
3490 * prepared to pick apart the PlaceHolderVar and evaluate its contained
3491 * expression instead.
3492 */
3494
3496 rlist,
3497 itlist,
3498 NULL,
3499 resultRelation,
3500 rtoffset,
3501 NRM_EQUAL,
3503
3505
3507}
References build_tlist_index_other_vars(), fb(), fix_join_expr(), NRM_EQUAL, NUM_EXEC_TLIST, pfree(), and root.
Referenced by set_plan_refs().
◆ set_subqueryscan_references()
|
static |
Definition at line 1452 of file setrefs.c.
1455{
1456 RelOptInfo *rel;
1457 Plan *result;
1458
1459 /* Need to look up the subquery's RelOptInfo, since we need its subroot */
1461
1462 /* Recursively process the subplan */
1464
1466 {
1467 Index scanrelid;
1468
1469 /*
1470 * We can omit the SubqueryScan node and just pull up the subplan.
1471 */
1473
1474 /* Remember that we removed a SubqueryScan */
1475 scanrelid = plan->scan.scanrelid + rtoffset;
1478 }
1479 else
1480 {
1481 /*
1482 * Keep the SubqueryScan node. We have to do the processing that
1483 * set_plan_references would otherwise have done on it. Notice we do
1484 * not do set_upper_references() here, because a SubqueryScan will
1485 * always have been created with correct references to its subplan's
1486 * outputs to begin with.
1487 */
1488 plan->scan.scanrelid += rtoffset;
1489 plan->scan.plan.targetlist =
1492 plan->scan.plan.qual =
1495
1497 }
1498
1499 return result;
1500}
References bms_make_singleton(), clean_up_removed_plan_level(), fb(), find_base_rel(), fix_scan_list, NUM_EXEC_QUAL, NUM_EXEC_TLIST, plan, record_elided_node(), root, set_plan_references(), RelOptInfo::subroot, and trivial_subqueryscan().
Referenced by set_plan_refs().
◆ set_upper_references()
|
static |
Definition at line 2553 of file setrefs.c.
2554{
2556 indexed_tlist *subplan_itlist;
2558 ListCell *l;
2559
2561
2562 /*
2563 * If it's a grouping node with grouping sets, any Vars and PHVs appearing
2564 * in the targetlist and quals should have nullingrels that include the
2565 * effects of the grouping step, ie they will have nullingrels equal to
2566 * the input Vars/PHVs' nullingrels plus the RT index of the grouping
2567 * step. In order to perform exact nullingrels matches, we remove the RT
2568 * index of the grouping step first.
2569 */
2571 root->group_rtindex > 0 &&
2573 {
2577 NULL);
2581 NULL);
2582 }
2583
2586 {
2589
2590 /* If it's a sort/group item, first try to match by sortref */
2592 {
2595 tle->ressortgroupref,
2596 subplan_itlist,
2597 OUTER_VAR);
2601 subplan_itlist,
2602 OUTER_VAR,
2603 rtoffset,
2604 NRM_EQUAL,
2606 }
2607 else
2610 subplan_itlist,
2611 OUTER_VAR,
2612 rtoffset,
2613 NRM_EQUAL,
2618 }
2620
2624 subplan_itlist,
2625 OUTER_VAR,
2626 rtoffset,
2627 NRM_EQUAL,
2629
2630 pfree(subplan_itlist);
2631}
References bms_make_singleton(), build_tlist_index(), fb(), fix_upper_expr(), flatCopyTargetEntry(), IsA, lappend(), Plan::lefttree, lfirst, NIL, NRM_EQUAL, NUM_EXEC_QUAL, NUM_EXEC_TLIST, OUTER_VAR, pfree(), plan, remove_nulling_relids(), root, search_indexed_tlist_for_sortgroupref(), and Plan::targetlist.
Referenced by set_plan_refs().
◆ set_windowagg_runcondition_references()
|
static |
Definition at line 3566 of file setrefs.c.
3569{
3572
3574
3576
3578
3580}
References build_tlist_index(), fb(), fix_windowagg_condition_expr(), pfree(), plan, and root.
Referenced by set_plan_refs().
◆ trivial_subqueryscan()
| bool trivial_subqueryscan | ( | SubqueryScan * | plan | ) |
Definition at line 1528 of file setrefs.c.
1529{
1532 *lc;
1533
1534 /* We might have detected this already; in which case reuse the result */
1536 return true;
1538 return false;
1540 /* Initially, mark the SubqueryScan as non-deletable from the plan tree */
1542
1544 return false;
1545
1548 return false; /* tlists not same length */
1549
1550 attrno = 1;
1552 {
1555
1557 return false; /* tlist doesn't match junk status */
1558
1559 /*
1560 * We accept either a Var referencing the corresponding element of the
1561 * subplan tlist, or a Const equaling the subplan element. See
1562 * generate_setop_tlist() for motivation.
1563 */
1565 {
1567
1569 Assert(var->varlevelsup == 0);
1571 return false; /* out of order */
1572 }
1574 {
1576 return false;
1577 }
1578 else
1579 return false;
1580
1581 attrno++;
1582 }
1583
1584 /* Re-mark the SubqueryScan as deletable from the plan tree */
1586
1587 return true;
1588}
References Assert, equal(), fb(), forboth, IsA, lfirst, list_length(), NIL, plan, SUBQUERY_SCAN_NONTRIVIAL, SUBQUERY_SCAN_TRIVIAL, SUBQUERY_SCAN_UNKNOWN, Var::varattno, Var::varlevelsup, and Var::varno.
Referenced by mark_async_capable_plan(), and set_subqueryscan_references().
