Add new function planstate_tree_walker.

ExplainPreScanNode knows how to iterate over a generic tree of plan
states; factor that logic out into a separate walker function so that
other code, such as upcoming patches for parallel query, can also use
it.

Patch by me, reviewed by Tom Lane.

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 4f32400011fe4cfbfb04ce36129e5de1a6fb378b..f0d9e94eed2d19a14a22b43eef935b050212690d 100644 (file)
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -55,10 +55,7 @@ static void ExplainOneQuery(Query *query, IntoClause *into, ExplainState *es,
 static void report_triggers(ResultRelInfo *rInfo, bool show_relname,
                                ExplainState *es);
 static double elapsed_time(instr_time *starttime);
-static void ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used);
-static void ExplainPreScanMemberNodes(List *plans, PlanState **planstates,
-                                                 Bitmapset **rels_used);
-static void ExplainPreScanSubPlans(List *plans, Bitmapset **rels_used);
+static bool ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used);
 static void ExplainNode(PlanState *planstate, List *ancestors,
                        const char *relationship, const char *plan_name,
                        ExplainState *es);
@@ -724,7 +721,7 @@ elapsed_time(instr_time *starttime)
  * This ensures that we don't confusingly assign un-suffixed aliases to RTEs
  * that never appear in the EXPLAIN output (such as inheritance parents).
  */
-static void
+static bool
 ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
 {
        Plan       *plan = planstate->plan;
@@ -764,91 +761,7 @@ ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
                        break;
        }
 
-       /* initPlan-s */
-       if (planstate->initPlan)
-               ExplainPreScanSubPlans(planstate->initPlan, rels_used);
-
-       /* lefttree */
-       if (outerPlanState(planstate))
-               ExplainPreScanNode(outerPlanState(planstate), rels_used);
-
-       /* righttree */
-       if (innerPlanState(planstate))
-               ExplainPreScanNode(innerPlanState(planstate), rels_used);
-
-       /* special child plans */
-       switch (nodeTag(plan))
-       {
-               case T_ModifyTable:
-                       ExplainPreScanMemberNodes(((ModifyTable *) plan)->plans,
-                                                                 ((ModifyTableState *) planstate)->mt_plans,
-                                                                         rels_used);
-                       break;
-               case T_Append:
-                       ExplainPreScanMemberNodes(((Append *) plan)->appendplans,
-                                                                       ((AppendState *) planstate)->appendplans,
-                                                                         rels_used);
-                       break;
-               case T_MergeAppend:
-                       ExplainPreScanMemberNodes(((MergeAppend *) plan)->mergeplans,
-                                                               ((MergeAppendState *) planstate)->mergeplans,
-                                                                         rels_used);
-                       break;
-               case T_BitmapAnd:
-                       ExplainPreScanMemberNodes(((BitmapAnd *) plan)->bitmapplans,
-                                                                ((BitmapAndState *) planstate)->bitmapplans,
-                                                                         rels_used);
-                       break;
-               case T_BitmapOr:
-                       ExplainPreScanMemberNodes(((BitmapOr *) plan)->bitmapplans,
-                                                                 ((BitmapOrState *) planstate)->bitmapplans,
-                                                                         rels_used);
-                       break;
-               case T_SubqueryScan:
-                       ExplainPreScanNode(((SubqueryScanState *) planstate)->subplan,
-                                                          rels_used);
-                       break;
-               default:
-                       break;
-       }
-
-       /* subPlan-s */
-       if (planstate->subPlan)
-               ExplainPreScanSubPlans(planstate->subPlan, rels_used);
-}
-
-/*
- * Prescan the constituent plans of a ModifyTable, Append, MergeAppend,
- * BitmapAnd, or BitmapOr node.
- *
- * Note: we don't actually need to examine the Plan list members, but
- * we need the list in order to determine the length of the PlanState array.
- */
-static void
-ExplainPreScanMemberNodes(List *plans, PlanState **planstates,
-                                                 Bitmapset **rels_used)
-{
-       int                     nplans = list_length(plans);
-       int                     j;
-
-       for (j = 0; j < nplans; j++)
-               ExplainPreScanNode(planstates[j], rels_used);
-}
-
-/*
- * Prescan a list of SubPlans (or initPlans, which also use SubPlan nodes).
- */
-static void
-ExplainPreScanSubPlans(List *plans, Bitmapset **rels_used)
-{
-       ListCell   *lst;
-
-       foreach(lst, plans)
-       {
-               SubPlanState *sps = (SubPlanState *) lfirst(lst);
-
-               ExplainPreScanNode(sps->planstate, rels_used);
-       }
+       return planstate_tree_walker(planstate, ExplainPreScanNode, rels_used);
 }
 
 /*

diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c
index c517dfd9d69c6264ecdd0c4904b8b8337ccea099..4a2447409a9e7c84678e14746c65fdf45eedd036 100644 (file)
--- a/src/backend/nodes/nodeFuncs.c
+++ b/src/backend/nodes/nodeFuncs.c
@@ -18,6 +18,7 @@
 #include "catalog/pg_type.h"
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
+#include "nodes/execnodes.h"
 #include "nodes/nodeFuncs.h"
 #include "nodes/relation.h"
 #include "utils/builtins.h"
@@ -26,6 +27,10 @@
 
 static bool expression_returns_set_walker(Node *node, void *context);
 static int     leftmostLoc(int loc1, int loc2);
+static bool planstate_walk_subplans(List *plans, bool (*walker) (),
+                                                                                               void *context);
+static bool planstate_walk_members(List *plans, PlanState **planstates,
+                                          bool (*walker) (), void *context);
 
 
 /*
@@ -3412,3 +3417,123 @@ raw_expression_tree_walker(Node *node,
        }
        return false;
 }
+
+/*
+ * planstate_tree_walker --- walk plan state trees
+ *
+ * The walker has already visited the current node, and so we need only
+ * recurse into any sub-nodes it has.
+ */
+bool
+planstate_tree_walker(PlanState *planstate, bool (*walker) (), void *context)
+{
+       Plan       *plan = planstate->plan;
+
+       /* initPlan-s */
+       if (planstate_walk_subplans(planstate->initPlan, walker, context))
+               return true;
+
+       /* lefttree */
+       if (outerPlanState(planstate))
+       {
+               if (walker(outerPlanState(planstate), context))
+                       return true;
+       }
+
+       /* righttree */
+       if (innerPlanState(planstate))
+       {
+               if (walker(innerPlanState(planstate), context))
+                       return true;
+       }
+
+       /* special child plans */
+       switch (nodeTag(plan))
+       {
+               case T_ModifyTable:
+                       if (planstate_walk_members(((ModifyTable *) plan)->plans,
+                                                                 ((ModifyTableState *) planstate)->mt_plans,
+                                                                          walker, context))
+                               return true;
+                       break;
+               case T_Append:
+                       if (planstate_walk_members(((Append *) plan)->appendplans,
+                                                                       ((AppendState *) planstate)->appendplans,
+                                                                          walker, context))
+                               return true;
+                       break;
+               case T_MergeAppend:
+                       if (planstate_walk_members(((MergeAppend *) plan)->mergeplans,
+                                                               ((MergeAppendState *) planstate)->mergeplans,
+                                                                          walker, context))
+                               return true;
+                       break;
+               case T_BitmapAnd:
+                       if (planstate_walk_members(((BitmapAnd *) plan)->bitmapplans,
+                                                                ((BitmapAndState *) planstate)->bitmapplans,
+                                                                          walker, context))
+                               return true;
+                       break;
+               case T_BitmapOr:
+                       if (planstate_walk_members(((BitmapOr *) plan)->bitmapplans,
+                                                                 ((BitmapOrState *) planstate)->bitmapplans,
+                                                                          walker, context))
+                               return true;
+                       break;
+               case T_SubqueryScan:
+                       if (walker(((SubqueryScanState *) planstate)->subplan, context))
+                               return true;
+                       break;
+               default:
+                       break;
+       }
+
+       /* subPlan-s */
+       if (planstate_walk_subplans(planstate->subPlan, walker, context))
+               return true;
+
+       return false;
+}
+
+/*
+ * Walk a list of SubPlans (or initPlans, which also use SubPlan nodes).
+ */
+static bool
+planstate_walk_subplans(List *plans, bool (*walker) (), void *context)
+{
+       ListCell   *lc;
+
+       foreach(lc, plans)
+       {
+               SubPlanState *sps = (SubPlanState *) lfirst(lc);
+
+               Assert(IsA(sps, SubPlanState));
+               if (walker(sps->planstate, context))
+                       return true;
+       }
+
+       return false;
+}
+
+/*
+ * Walk the constituent plans of a ModifyTable, Append, MergeAppend,
+ * BitmapAnd, or BitmapOr node.
+ *
+ * Note: we don't actually need to examine the Plan list members, but
+ * we need the list in order to determine the length of the PlanState array.
+ */
+static bool
+planstate_walk_members(List *plans, PlanState **planstates,
+                                          bool (*walker) (), void *context)
+{
+       int                     nplans = list_length(plans);
+       int                     j;
+
+       for (j = 0; j < nplans; j++)
+       {
+               if (walker(planstates[j], context))
+                       return true;
+       }
+
+       return false;
+}

diff --git a/src/include/nodes/nodeFuncs.h b/src/include/nodes/nodeFuncs.h
index 7b1b1d6dca9f4c04907a1a152a13a1eadcb76457..36b5dac0c5a90b2742f1e764fdc9bcb351815a14 100644 (file)
--- a/src/include/nodes/nodeFuncs.h
+++ b/src/include/nodes/nodeFuncs.h
@@ -63,4 +63,8 @@ extern Node *query_or_expression_tree_mutator(Node *node, Node *(*mutator) (),
 extern bool raw_expression_tree_walker(Node *node, bool (*walker) (),
                                                                                                   void *context);
 
+struct PlanState;
+extern bool planstate_tree_walker(struct PlanState *planstate, bool (*walker) (),
+                                                                                         void *context);
+
 #endif   /* NODEFUNCS_H */