Store information about range-table flattening in the final plan.

Suppose that we're currently planning a query and, when that same
query was previously planned and executed, we learned something about
how a certain table within that query should be planned. We want to
take note when that same table is being planned during the current
planning cycle, but this is difficult to do, because the RTI of the
table from the previous plan won't necessarily be equal to the RTI
that we see during the current planning cycle. This is because each
subquery has a separate range table during planning, but these are
flattened into one range table when constructing the final plan,
changing RTIs.

Commit 8c49a484e8ebb0199fba4bd68eaaedaf49b48ed0 allows us to match up
subqueries seen in the previous planning cycles with the subqueries
currently being planned just by comparing textual names, but that's
not quite enough to let us deduce anything about individual tables,
because we don't know where each subquery's range table appears in
the final, flattened range table.

To fix that, store a list of SubPlanRTInfo objects in the final
planned statement, each including the name of the subplan, the offset
at which it begins in the flattened range table, and whether or not
it was a dummy subplan -- if it was, some RTIs may have been dropped
from the final range table, but also there's no need to control how
a dummy subquery gets planned. The toplevel subquery has no name and
always begins at rtoffset 0, so we make no entry for it.

This commit teaches pg_overexplain's RANGE_TABLE option to make use
of this new data to display the subquery name for each range table
entry.

NOTE TO REVIEWERS: If there's a clean way to make pg_overexplain display
this information without the new infrastructure provided by this patch,
then this patch is unnecessary. I thought there would be a way to do
that, but I couldn't figure anything out: there seems to be nothing that
records in the final PlannedStmt where subquery's range table ends and
the next one begins. In practice, one could usually figure it out by
matching up tables by relation OID, but that's neither clean nor
theoretically sound.

diff --git a/contrib/pg_overexplain/pg_overexplain.c b/contrib/pg_overexplain/pg_overexplain.c
index fcdc17012da2ebce38e97915f5dcd78ad670885a..1c4c796adb2317dd46c8c09b94f1e1372cc57f69 100644 (file)
--- a/contrib/pg_overexplain/pg_overexplain.c
+++ b/contrib/pg_overexplain/pg_overexplain.c
@@ -395,6 +395,8 @@ static void
 overexplain_range_table(PlannedStmt *plannedstmt, ExplainState *es)
 {
        Index           rti;
+       ListCell   *lc_subrtinfo = list_head(plannedstmt->subrtinfos);
+       SubPlanRTInfo *rtinfo = NULL;
 
        /* Open group, one entry per RangeTblEntry */
        ExplainOpenGroup("Range Table", "Range Table", false, es);
@@ -405,6 +407,18 @@ overexplain_range_table(PlannedStmt *plannedstmt, ExplainState *es)
                RangeTblEntry *rte = rt_fetch(rti, plannedstmt->rtable);
                char       *kind = NULL;
                char       *relkind;
+               SubPlanRTInfo *next_rtinfo;
+
+               /* Advance to next SubRTInfo, if it's time. */
+               if (lc_subrtinfo != NULL)
+               {
+                       next_rtinfo = lfirst(lc_subrtinfo);
+                       if (rti > next_rtinfo->rtoffset)
+                       {
+                               rtinfo = next_rtinfo;
+                               lc_subrtinfo = lnext(plannedstmt->subrtinfos, lc_subrtinfo);
+                       }
+               }
 
                /* NULL entries are possible; skip them */
                if (rte == NULL)
@@ -469,6 +483,28 @@ overexplain_range_table(PlannedStmt *plannedstmt, ExplainState *es)
                        ExplainPropertyBool("In From Clause", rte->inFromCl, es);
                }
 
+               /*
+                * Indicate which subplan is the origin of which RTE. Note dummy
+                * subplans. Here again, we crunch more onto one line in text format.
+                */
+               if (rtinfo != NULL)
+               {
+                       if (es->format == EXPLAIN_FORMAT_TEXT)
+                       {
+                               if (!rtinfo->dummy)
+                                       ExplainPropertyText("Subplan", rtinfo->plan_name, es);
+                               else
+                                       ExplainPropertyText("Subplan",
+                                                                               psprintf("%s (dummy)",
+                                                                                                rtinfo->plan_name), es);
+                       }
+                       else
+                       {
+                               ExplainPropertyText("Subplan", rtinfo->plan_name, es);
+                               ExplainPropertyBool("Subplan Is Dummy", rtinfo->dummy, es);
+                       }
+               }
+
                /* rte->alias is optional; rte->eref is requested */
                if (rte->alias != NULL)
                        overexplain_alias("Alias", rte->alias, es);

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 8b22c30559b26d7a744bd3bfd75ba47663daa688..31dcbdf3422c7b2f360ebf5c0cfded1d1aabf687 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -607,6 +607,7 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions,
        result->unprunableRelids = bms_difference(glob->allRelids,
                                                                                          glob->prunableRelids);
        result->permInfos = glob->finalrteperminfos;
+       result->subrtinfos = glob->subrtinfos;
        result->resultRelations = glob->resultRelations;
        result->appendRelations = glob->appendRelations;
        result->subplans = glob->subplans;

diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index cd7ea1e6b587354c0384e859786853ccf5be1450..edcd4aaa53e3575d2d9420a93ac75d23d8a39d8f 100644 (file)
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -399,6 +399,26 @@ add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing)
        Index           rti;
        ListCell   *lc;
 
+       /*
+        * Record enough information to make it possible for code that looks at
+        * the final range table to understand how it was constructed. (If
+        * finalrtable is still NIL, then this is the very topmost PlannerInfo,
+        * which will always have plan_name == NULL and rtoffset == 0; we omit the
+        * degenerate list entry.)
+        */
+       if (root->glob->finalrtable != NIL)
+       {
+               SubPlanRTInfo *rtinfo = makeNode(SubPlanRTInfo);
+
+               rtinfo->plan_name = root->plan_name;
+               rtinfo->rtoffset = list_length(root->glob->finalrtable);
+
+               /* When recursing = true, it's an unplanned or dummy subquery. */
+               rtinfo->dummy = recursing;
+
+               root->glob->subrtinfos = lappend(root->glob->subrtinfos, rtinfo);
+       }
+
        /*
         * Add the query's own RTEs to the flattened rangetable.
         *

diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h
index 46a8655621d5a1ed85d4be2ea78deb127a43760e..3782bc640754aba227898cff21b7d8bb8301ac80 100644 (file)
--- a/src/include/nodes/pathnodes.h
+++ b/src/include/nodes/pathnodes.h
@@ -135,6 +135,9 @@ typedef struct PlannerGlobal
        /* "flat" list of RTEPermissionInfos */
        List       *finalrteperminfos;
 
+       /* list of SubPlanRTInfo nodes */
+       List       *subrtinfos;
+
        /* "flat" list of PlanRowMarks */
        List       *finalrowmarks;
 

diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index c4393a9432116e72ee8ebb098cc0f85752cc9319..1526dd2ec6bdb2c276d2a715c7c2abe13bf41130 100644 (file)
--- a/src/include/nodes/plannodes.h
+++ b/src/include/nodes/plannodes.h
@@ -131,6 +131,9 @@ typedef struct PlannedStmt
         */
        List       *subplans;
 
+       /* a list of SubPlanRTInfo objects */
+       List       *subrtinfos;
+
        /* indices of subplans that require REWIND */
        Bitmapset  *rewindPlanIDs;
 
@@ -1821,4 +1824,18 @@ typedef enum MonotonicFunction
        MONOTONICFUNC_BOTH = MONOTONICFUNC_INCREASING | MONOTONICFUNC_DECREASING,
 } MonotonicFunction;
 
+/*
+ * SubPlanRTInfo
+ *
+ * Information about which range table entries came from which subquery
+ * planning cycles.
+ */
+typedef struct SubPlanRTInfo
+{
+       NodeTag         type;
+       const char *plan_name;
+       Index           rtoffset;
+       bool            dummy;
+} SubPlanRTInfo;
+
 #endif                                                 /* PLANNODES_H */

diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 9dd65b102544e9c7de89839359936ee589b0936a..025bba87834508a0f8dcba7f0cee11d59545d4ad 100644 (file)
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2902,6 +2902,7 @@ SubLink
 SubLinkType
 SubOpts
 SubPlan
+SubPlanRTInfo
 SubPlanState
 SubRelInfo
 SubRemoveRels